WALTER - O Arduino Photovore Insect

Ferramentas e máquinas necessárias

	Ferro de soldar (genérico)
	Pistola de cola quente (genérica)

Aplicativos e serviços online

Arduino IDE

Sobre este projeto

Código

• WALTER.ino

WALTER.ino Arduino

 / * WALTER - THE 4 LEGGED PHOTOVORETeste esboço do Arduino é minha tentativa de construir um robô 5 servo quadrúpede (4 pernas) chamado "WALTER". Para usar este esboço, você pode precisar alterar alguns valores para sua conveniência ou para ajustar à configuração do seu próprio hardware. Encontre (Ctrl + F) essas marcas para pesquisar facilmente quais valores podem precisar ser alterados:- ****:Essas marcas significam que eles são a posição central dos servos e devem ser calibrados (seu robô posicionamento das pernas quando está ocioso). - ***:Essas marcas significam atribuição de pinos do Arduino (conexão de sensores e servos ao Arduino). Consulte isso ao construir o robô. - **:Estas marcas significam que os valores podem ser alterados opcionalmente de acordo com o seu gosto (largura dos passos das pernas, quanto virar ao detectar luz / obstáculo, etc). Apenas deixe como está se você não souber o que está fazendo. Você pode usar este esboço por sua própria conta e risco .. e, é fornecido como está e .. uh .. O que são todos esses direitos autorais que as pessoas usam para escrever no código-fonte publicado ?? A questão é que não quero ser responsabilizado se algo de ruim aconteceu quando você estava usando esses códigos.Divirta-se! Yohanes Martedi - 2015 * / # include  // ** ** Calibre o ângulo central dos servos (em microssegundos porque usaremos o comando "xx.writeMicroseconds ();"). Comece com 1500.const int ANGLE_mid_Shaft =1520; const int ANGLE_mid_FLeft =1550; const int ANGLE_mid_FRight =1570; const int ANGLE_mid_BLeft =1450; const int ANGLE_mid_BRight =1450; const int ANGLE_mid_sweep =250; // ** Defina este valor (em microssegundos) para determinar a largura da varredura dos servos (largura dos passos das pernas). Um valor maior significa um ângulo de varredura mais amplo.const int ANGLE_res =10; // ** Defina a resolução do movimento do servo (em microssegundos) pelo menos na largura de banda morta padrão do servo (resolução mais alta) ou mais (menos resolução). Exemplo:a largura da banda morta do servo SG90 é 10 microssegundos.int sweepSPEED; // variável para determinar a rapidez com que os servos irão sweep.int sweepSPEED_Rand [3] ={4, 6, 8}; // ** A velocidade do servo (velocidade de marcha) mudará aleatoriamente em 3 modos. Defina a velocidade (em milissegundos) para cada modo. Valor menor significa mais rápido.const int ANGLE_turnMAX =ANGLE_sweep * 1.5; // ** Defina este valor para determinar quanto máximo o bot girará em direção à luz. Maior valor significa maior turn.const int ANGLE_turnNARROW =ANGLE_sweep * 0,25; // ** Defina este valor para determinar quanto máximo o bot girará evitando objetos em seus lados em um espaço estreito. Maior valor significa maior turn.const int SONAR_sum =3; // Quantidade de sonares usados.const int PHOTO_sum =4; // Quantidade de fotodiodos usados.int PIN_trig [SONAR_sum] ={13, 11, 8}; // *** Definir os pinos do Arduino conectados aos pinos do gatilho dos sensores ultrassônicos; {frente, esquerda, direita} .int PIN_ec [SONAR_sum] ={12, 10, 7}; // *** Definir os pinos do Arduino conectados aos pinos de eco dos sensores ultrassônicos; {frente, esquerda, direita} .int PIN_PHOTO [PHOTO_sum] ={2, 3, 1, 0}; // *** Definir os pinos de entrada analógica do Arduino conectados aos fotodiodos; {frontal esquerdo, frontal direito, posterior esquerdo, posterior direito} .const int distRotate =25; // ** Configure a distância mínima (em cm) entre o robô e o obstáculo antes que o robô evite girando.const int distRetreat =10; // ** Configure a distância mínima (em cm) entre o robô e o obstáculo antes que o robô evite recuando.const int distTurn =20; // ** Configure a distância mínima (em cm) entre o robô e o obstáculo antes que o robô evite girando.const int counter_gait_max =8; // ** Configure quantos passos o robô levará para evitar obstáculos (ao girar ou recuar) .// ** Configure quanto tempo o bot descansa e executa (em milissegundos) .const int RUN_time =25000; const int REST_time =3000; // IDs para sonares:int SONAR_id; const int FRONT =0; const int LEFT =1; const int RIGHT =2; // IDs para fotodiodos:const int FRONT_LEFT =0; const int FRONT_RIGHT =1; const int BACK_LEFT =2; const int BACK_RIGHT =3; // Variáveis ​​para leitura de fotodiodos:int PHOTO_Front_Left; int PHOTO_Front_Right; int PHOTO_Back_Left; int PHOTO_Back_Right; const int SONAR_TrigSig =10; // Duração (em S) do sinal de disparo dos sensores necessários para produzir som ultrassônico (já especificado pelos produtos, não altere este valor) .const unsigned long SONAR_MaxEc =50000; // Duração máxima (em S) do sinal de eco dado pelos sensores (já especificado pelos produtos, não altere este valor) .const float SOUND_speed =0.034; // A velocidade do som no ar em S / cm (já especificada por sciene, avatar Aang é necessário para fazer a dobra no ar se este valor for alterado) .int distance [SONAR_sum]; // Resultados do cálculo da distância.// Ddeclaração dos servos:Servo SERVO_shaft; Servo SERVO_front_left; Servo SERVO_front_right; Servo SERVO_back_left; Servo SERVO_back_right; // Variáveis ​​para os ângulos de cada servo:int ANGLE_shaft =ANGLE_mid_Shaft =ANGLE_frontFL_frontmidleft; ANGLE_front_right =ANGLE_mid_FRight; int ANGLE_back_left =ANGLE_mid_BLeft; int ANGLE_back_right =ANGLE_mid_BRight; // Manipulação do ângulo para o servo médio (eixo) .const int ANGLE_max_Shaft =ANGLE_mid_Shaft // ANGLE_sweep_valor + ANGLE_sweep; ângulos de cada servo:int ANGLE_shaft_record; int ANGLE_front_left_record; int ANGLE_front_right_record; int ANGLE_back_left_record; int ANGLE_back_right_record; // Variáveis ​​para correção de ângulos dos servos de acordo com a detecção de luz:int LIGHT_left; int int SONAR_left; int SONAR_right; // Essas coisas como sinalizadores, contadores, registros que nem sempre tenho certeza de como explicar. :(int ANGLE_prev; int flag_shaft_reverse; int flag_transition_rotate; int flag_transition_start =1; int flag_rest =0; int flag_RUN_time =0; int rotate_random; int counter_gait; void setup () {// Serial.begin (9600); // Serial. . você sabe, verificando e depurando .. SERVO_shaft.attach (2); // *** Configurar o pino de sinal do servo horizontal (eixo) no arduino. SERVO_front_left.attach (4); // *** Configurar front-left pino de sinal do servo no arduino. SERVO_front_right.attach (3); // *** Configure o pino de sinal do servo frontal direito no arduino. SERVO_back_left.attach (6); // *** Configure o pino de sinal do servo traseiro esquerdo em arduino. SERVO_back_right.attach (5); // *** Configure o pino de sinal do servo traseiro direito no arduino. // Prepare os servos em seus ângulos médios. SERVO_shaft.writeMicroseconds (ANGLE_mid_Shaft); SERVO_front_left.writeMicroseconds (ANGLE_mid_FL); SERVO_front_right.writeMicroseconds (ANGLE_mid_FRight); SERVO_back_left.writeMicroseconds (ANGLE_mid_BLeft); SERVO_back_right.writeMicroseconds (ANGLE_mid_BRight); // Definição do pino s para sonares, pinMode e value. para (SONAR_id =0; SONAR_id  distRotate) {flag_RUN_time =0; while (flag_RUN_time ==0) {FORWARD (); }} while (distance [FRONT]> distRetreat &&distance [FRONT] <=distRotate) {while (distance [LEFT]> distance [RIGHT]) {ROTATE_LEFT_AVOID (); pausa; } enquanto (distância [ESQUERDA]  =ANGLE_max_Shaft) {ANGLE_prev =ANGLE_eixo; Eixo_ ANGLE - =ANGLE_res; } else if (ANGLE_prev> ANGLE_eixo &&ANGLE_eixo> ANGLE_min_eixo) {ANGLE_prev =ANGLE_eixo; Eixo_ ANGLE - =ANGLE_res; } else if (ANGLE_eixo <=ANGLE_min_Shaft) {ANGLE_prev =ANGLE_eixo; ANGLE_eixo + =ANGLE_res; } SERVO_shaft.writeMicroseconds (ANGLE_shaft);} void SHAFT_REVERSE () {if (ANGLE_prev  ANGLE_shaft) {ANGLE_prev =ANGLE_shaft - 1; }} / * ==================================FIM DO MOVIMENTO DO EIXO ==================================* // * =======================================TRANSIÇÃO =======================================* / void TRANSITION_GAIT () {ANGLE_front_left_record =ANGLE_front_left; ANGLE_front_right_record =ANGLE_front_right; ANGLE_back_left_record =ANGLE_back_left; ANGLE_back_right_record =ANGLE_back_right; ANGLE_shaft_record =ANGLE_shaft; sinalizador interno =ALTO; contador interno =0; enquanto (sinalizador ==ALTO) {EIXO (); LIGHT_left =0; LIGHT_right =0; contador ++; ANGLE_front_left =map (counter, 1, ((ANGLE_sweep * 2) / ANGLE_res), ANGLE_front_left_record, ANGLE_mid_FLeft); ANGLE_front_right =map (contador, 1, ((ANGLE_sweep * 2) / ANGLE_res), ANGLE_front_right_record, ANGLE_mid_FRight); ANGLE_back_left =map (contador, 1, ((ANGLE_sweep * 2) / ANGLE_res), ANGLE_back_left_record, ANGLE_mid_BLeft); ANGLE_back_right =mapa (contador, 1, ((ANGLE_sweep * 2) / ANGLE_res), ANGLE_back_right_record, ANGLE_mid_BRight); SERVO_shaft.writeMicroseconds (ANGLE_shaft); SERVO_front_left.writeMicroseconds (ANGLE_front_left); SERVO_front_right.writeMicroseconds (ANGLE_front_right); SERVO_back_left.writeMicroseconds (ANGLE_back_left); SERVO_back_right.writeMicroseconds (ANGLE_back_right); if (contador ==((ANGLE_sweep * 2) / ANGLE_res)) {flag =LOW; COMEÇAR(); flag_transition_rotate =0; }}} void TRANSITION_START () {if (ANGLE_eixo ==ANGLE_mid_Shaft || (ANGLE_eixo> ANGLE_mid_Shaft &&ANGLE_eixo> ANGLE_prev) || (ANGLE_eixo  =ANGLE_mid_Shaft &&ANGLE_prev  =ANGLE_mid_Shaft &&ANGLE_prev> ANGLE_seixo) {ANGLE_front_left =map (ANGLE_frontal_esquerdo =map (ANGLE_eixo, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_FLeft, ((ANGLE_mid_value_esquerda) - ESQUERDA_Valor_esquerda) - ANGLE_front_right =map (ANGLE_volta, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_FRight, ((ANGLE_mid_FRight + ANGLE_sweep_val) + LIGHT_right + SONAR_right)); ANGLE_back_left =map (ANGLE_mid_left, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BLeft, ((ANGLE_mid_BLeft - ANGLE_sweep_val) + LIGHT_left + SONAR_left)); ANGLE_back_right =map (ANGLE_back_right, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BRight, ((ANGLE_mid_BRight - ANGLE_sweep_val) - LIGHT_right - SONAR_right)); } else if (ANGLE_shaft  ANGLE_shaft) {ANGLE_front_left =map (ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, ((ANGLE_mid_FLeft + ANGLE_sweep_val), LIGHT_left_esquerdo - ANGLE_esquerdo); ANGLE_front_right =mapa (ANGLE_mid_Shaft, ANGLE_mid_Shaft, ((ANGLE_mid_FRight + ANGLE_sweep_val) + LIGHT_right + SONAR_right), ANGLE_mid_FRight); ANGLE_back_left =map (ANGLE_eshaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, ((ANGLE_mid_BLeft - ANGLE_sweep_val) + LIGHT_esquerdo + SONAR_esquerdo), ANGLE_mid_BLeft); ANGLE_back_right =map (ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, ((ANGLE_mid_BRight - ANGLE_sweep_val) - LIGHT_right - SONAR_right), ANGLE_mid_BRight); } else if (ANGLE_haft  =ANGLE_mid_Shaft &&ANGLE_prev  =ANGLE_mid_Shaft &&ANGLE_prev> ANGLE_seixo) {ANGLE_front_left =map (ANGLE_front_left =map (ANGLE_haft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_FLeft, (ANGLE_mid_FLeepes - ANGLE_sweep_val)); ANGLE_front_right =map (ANGLE_mid_FRight, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_FRight, (ANGLE_mid_FRight + ANGLE_sweep_val)); ANGLE_back_left =map (ANGLE_mid_BLeft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BLeft, (ANGLE_mid_BLeft + ANGLE_sweep_val)); ANGLE_back_right =map (ANGLE_mid_BRight, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BRight, (ANGLE_mid_BRight - ANGLE_sweep_val)); } else if (ANGLE_eixo  ANGLE_eft) {ANGLE_front_left =map (ANGLE_haft, ANGLE_mid_Shaft, ANGLE_min_Shaft, (ANGLE_mid_FLeft - ANGLE_sweep_val), ANGLE_mid_fleft); ANGLE_front_right =map (ANGLE_mid_haft, ANGLE_mid_Shaft, ANGLE_min_Shaft, (ANGLE_mid_FRight + ANGLE_sweep_val), ANGLE_mid_FRight); ANGLE_back_left =map (ANGLE_mid_Shaft, ANGLE_mid_Shaft, (ANGLE_mid_BLeft + ANGLE_sweep_val), ANGLE_mid_BLeft); ANGLE_back_right =map (ANGLE_mid_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BRight, (ANGLE_mid_BRight - ANGLE_sweep_val), ANGLE_mid_BRight); } else if (ANGLE_haft  0.0) {SONAR_distance =SONAR_EcInterval * (SOUND_speed / 2.0); pausa; } enquanto (SONAR_EcInterval ==0.0) {SONAR_distance =501.0; pausa; } return SONAR_distance;} / * ===============================FIM DA LEITURA ULTRASSÔNICA ===============================* // * ========================================LIGHT DETECT ========================================* / void LIGHT_COMPARE_EXECUTE () {// PHOTO_FLeft_RAW =analogRead (PIN_PHOTO [FRONT_LEFT]); // PHOTO_FRight_RAW =analogRead (PIN_PHOTO [FRONT_RIGHT]); PHOTO_Front_Left =analogRead (PIN_PHOTO [FRONT_LEFT]); PHOTO_Front_Right =analogRead (PIN_PHOTO [FRONT_RIGHT]); PHOTO_Back_Left =analogRead (PIN_PHOTO [BACK_LEFT]); PHOTO_Back_Right =analogRead (PIN_PHOTO [BACK_RIGHT]); if ((PHOTO_Front_Left + PHOTO_Front_Right)> =(PHOTO_Back_Left + PHOTO_Back_Right)) {int LIGHT_Sensitivity =50; if (LIGHT_COMPARE ()> LIGHT_Sensitivity) {LIGHT_left =LIGHT_COMPARE (); LIGHT_right =0; } else if (LIGHT_COMPARE () <-LIGHT_Sensitivity) {LIGHT_left =0; LIGHT_right =LIGHT_COMPARE (); } else {LIGHT_left =0; LIGHT_right =0; }} else {if (PHOTO_Back_Left> PHOTO_Back_Right) {LIGHT_right =0; LIGHT_left =ANGLE_turnMAX; } else if (PHOTO_Back_Left  PHOTO_Front_Right) {LIGHT_rate =PHOTO_Front_Left; } else if (PHOTO_Front_Right> PHOTO_Front_Left) {LIGHT_rate =PHOTO_Front_Right; } else {// escolhe usar um e comenta a outra dessas variáveis ​​abaixo // LIGHT_rate =PHOTO_Front_Left; LIGHT_rate =PHOTO_Front_Right; } int LIGHT_compareRAW =PHOTO_Front_Left - PHOTO_Front_Right; LIGHT_compareRAW =map (LIGHT_compareRAW, -LIGHT_rate, LIGHT_rate, -ANGLE_turnMAX, ANGLE_turnMAX);; return LIGHT_compareRAW;} / * =====================================FIM DA LUZ DETECT ===================================* // * ========================================COMPORTAMENTO ==========================================* / void RETREAT_AVOID () {counter_gait =0; while (counter_gait <=counter_gait_max) {RETREAT (); }} void ROTATE_LEFT_AVOID () {counter_gait =0; rotate_random =2; while (counter_gait <=counter_gait_max) {ROTATE_LEFT (); }} void ROTATE_RIGHT_AVOID () {counter_gait =0; rotate_random =2; while (counter_gait <=counter_gait_max) {ROTATE_RIGHT (); }} void ROTATE_RANDOM_AVOID () {rotate_random =ROTATE_RANDOM (); while (rotate_random ==0) {ROTATE_LEFT_AVOID (); } while (rotate_random ==1) {ROTATE_RIGHT_AVOID (); }} void SIDE_AVOID () {if (distance [LEFT] <=distTurn &&distance [RIGHT]> distTurn) {LIGHT_left =0; LIGHT_right =0; SONAR_esquerda =0; SONAR_right =- (mapa (distância [LEFT], 0, distTurn, ANGLE_turnMAX, 0)); } else if (distance [RIGHT] <=distTurn &&distance [LEFT]> distTurn) {LIGHT_left =0; LIGHT_right =0; SONAR_right =0; SONAR_esquerda =mapa (distância [RIGHT], 0, distTurn, ANGLE_turnMAX, 0); } else if (distância [LEFT] <=distTurn &&distance [RIGHT] <=distTurn) {LIGHT_left =0; LIGHT_right =0; if (distância [ESQUERDA]  

Esquemas