define polling 10 // the scan rate
// If the packets internal retry register matches// the set retry count then communication is stopped// on that packet. To re-enable the packet you must// set the "connection" variable to true.#define retry_count 10
// used to toggle the receive/transmit pin on the driver#define TxEnablePin 20
#define LED 9
// This is the easiest way to create new packets// Add as many as you want. TOTAL_NO_OF_PACKETS// is automatically updated.enum{ PACKET1, PACKET2, PACKET3, PACKET4, PACKET5, PACKET6, PACKET7, PACKET8, PACKET9, PACKET10, PACKET11, PACKET12, PACKET13, PACKET14, PACKET15, PACKET16, PACKET17, TOTAL_NO_OF_PACKETS // leave this last entry};
// Create an array of Packets to be configuredPacket packets[TOTAL_NO_OF_PACKETS];
// Create a packetPointer to access each packet// individually. This is not required you can access// the array explicitly. E.g. packets[PACKET1].id = 2;// This does become tedious though...//////////////////////////HMI READS/////////////////////////////packetPointer enableDisableHMI = &packets[PACKET1];packetPointer runFwdHMI = &packets[PACKET2];packetPointer runRevHMI = &packets[PACKET3];packetPointer resetHMI = &packets[PACKET4];packetPointer eStopHMI = &packets[PACKET5];packetPointer userSetSpeedHMI = &packets[PACKET6];
//////////////////////////HMI WRITES////////////////////////////packetPointer runLedHMI = &packets[PACKET7];packetPointer stopLedHMI = &packets[PACKET8];packetPointer errorLedHMI = &packets[PACKET9];packetPointer actualSpeedHMI = &packets[PACKET10];packetPointer motorCurrentHMI = &packets[PACKET11];
/////////////////////////VSD READS//////////////////////////////packetPointer statusWordVSD = &packets[PACKET12];packetPointer actualSpeedVSD = &packets[PACKET13];packetPointer motorCurrentVSD = &packets[PACKET14];
/////////////////////////VSD WRITES/////////////////////////////packetPointer commandWordVSD = &packets[PACKET15];packetPointer userSetSpeedVSD = &packets[PACKET16];packetPointer clearFaultsVSD = &packets[PACKET17];
////////HMI READ VARIABLES////////////unsigned int readEnableDisableHMI[1];unsigned int readRunFwdHMI[1];unsigned int readRunRevHMI[1];unsigned int readResetHMI[1];unsigned int readEstopHMI[1];unsigned int readUserSetSpeedHMI[1];
////////HMI WRITE VARIABLES//////////unsigned int writeRunLedHMI[1];unsigned int writeStopLedHMI[1];unsigned int writeErrorLedHMI[1];unsigned int writeActualSpeedHMI[1];unsigned int writeMotorCurrentHMI[1];
////////VSD READ VARIABLES///////////unsigned int readStatusWordVSD[1];unsigned int readActualSpeedVSD[1];unsigned int readMotorCurrentVSD[1];
////////VSD WRITE VARIABLES//////////unsigned int writeControlWordVSD[1];unsigned int writeUserSetSpeedVSD[1]={0};unsigned int writeClearFaultsVSD[1];
// High or Low variables as arraysunsigned int writeHigh[1]={1};unsigned int writeLow[1]={0};
const int vccPin = 17;const int gndPin = 21;
unsigned int BUTTONSTATE;unsigned int PREVBUTTONSTATE;
void setup(){ Serial.begin(19200); // Set modes of some pins for LED outputs pinMode(vccPin, OUTPUT); pinMode(gndPin, OUTPUT); digitalWrite(vccPin, HIGH); digitalWrite(gndPin, LOW); // Read all values from HMI modbus_construct(enableDisableHMI, 3, READ_HOLDING_REGISTERS, 50, 1, readEnableDisableHMI); modbus_construct(runFwdHMI, 3, READ_HOLDING_REGISTERS, 60, 1, readRunFwdHMI); modbus_construct(runRevHMI, 3, READ_HOLDING_REGISTERS, 70, 1, readRunRevHMI); modbus_construct(resetHMI, 3, READ_HOLDING_REGISTERS, 80, 1, readResetHMI); modbus_construct(eStopHMI, 3, READ_HOLDING_REGISTERS, 90, 1, readEstopHMI); modbus_construct(userSetSpeedHMI, 3, READ_HOLDING_REGISTERS, 10, 1, readUserSetSpeedHMI); // Write required values to HMI modbus_construct(runLedHMI, 3, PRESET_MULTIPLE_REGISTERS, 100, 1, writeRunLedHMI); modbus_construct(stopLedHMI, 3, PRESET_MULTIPLE_REGISTERS, 110, 1, writeStopLedHMI); modbus_construct(errorLedHMI, 3, PRESET_MULTIPLE_REGISTERS, 120, 1, writeErrorLedHMI); modbus_construct(actualSpeedHMI, 3, PRESET_MULTIPLE_REGISTERS, 0, 1, readActualSpeedVSD); modbus_construct(motorCurrentHMI, 3, PRESET_MULTIPLE_REGISTERS, 20, 1, readMotorCurrentVSD); // Read all values from VSD modbus_construct(statusWordVSD, 2, READ_HOLDING_REGISTERS, 8603, 1, readStatusWordVSD); modbus_construct(actualSpeedVSD, 2, READ_HOLDING_REGISTERS, 8604, 1, readActualSpeedVSD); modbus_construct(motorCurrentVSD, 2, READ_HOLDING_REGISTERS, 3204, 1, readMotorCurrentVSD); // Write required values to VSD modbus_construct(commandWordVSD, 2, PRESET_MULTIPLE_REGISTERS, 8601, 1, writeControlWordVSD); modbus_construct(userSetSpeedVSD, 2, PRESET_MULTIPLE_REGISTERS, 8602, 1, readUserSetSpeedHMI); modbus_construct(clearFaultsVSD, 2, PRESET_MULTIPLE_REGISTERS, 8501, 1, writeClearFaultsVSD); // Configure the MODBUS connection modbus_configure(baud, SERIAL_8E1, timeout, polling, retry_count, TxEnablePin, packets, TOTAL_NO_OF_PACKETS); pinMode(LED, OUTPUT); pinMode(6,OUTPUT); pinMode(5,OUTPUT); digitalWrite(5,LOW); pinMode(3,OUTPUT); pinMode(2,OUTPUT); digitalWrite(2,LOW); pinMode(11,OUTPUT); pinMode(10,OUTPUT); digitalWrite(10,LOW);}
void loop(){ modbus_update(); // Get the latest register values for the buttons and screen elements... checkState(); // Convert the button register states into a single integer value for use in switch|case statement... switch(BUTTONSTATE){ case 0: while(BUTTONSTATE==0) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 1: while(BUTTONSTATE==1) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 2: while(BUTTONSTATE==2) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 3: while(BUTTONSTATE==3) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 4: while(BUTTONSTATE==4) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 5: while(BUTTONSTATE==5) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 6: while(BUTTONSTATE==6) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 7: while(BUTTONSTATE==7) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 8: while(BUTTONSTATE==8) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 9: while(BUTTONSTATE==9) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 10: while(BUTTONSTATE==10) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; case 16: while(BUTTONSTATE==16) { modbus_update(); checkState(); Serial.println(BUTTONSTATE); // Your Code Here... } break; default: break; } }
void checkState() // This function simply reads whether each button is active("1") or inactive ("0") and bitshifts each button to create a unique BUTTONSTATE value for each combination of button presses...{ PREVBUTTONSTATE=BUTTONSTATE; BUTTONSTATE = (readEnableDisableHMI[0])+(readRunFwdHMI[0]<<1)+(readRunRevHMI[0]<<2)+(readResetHMI[0]<<3)+(readEstopHMI[0]<<4); // Example: Drive enabled, and run forward... 0b00011 = dec "3"... so BUTTONSTATE = 3. if(BUTTONSTATE==11||BUTTONSTATE==12||BUTTONSTATE==13||BUTTONSTATE==14||BUTTONSTATE==15) // For our implementation these button press combinations are not valid... so just make them = to state 10... { BUTTONSTATE=10; } // As above... These are all the possible BUTTONSTATE values when the E-stop button is pressed... but if E-Stop is pressed we want to kill all buttons anyway... if(BUTTONSTATE==17||BUTTONSTATE==18||BUTTONSTATE==19||BUTTONSTATE==20||BUTTONSTATE==21||BUTTONSTATE==22||BUTTONSTATE==23||BUTTONSTATE==24||BUTTONSTATE==25||BUTTONSTATE==26||BUTTONSTATE==27||BUTTONSTATE==28||BUTTONSTATE==29||BUTTONSTATE==30||BUTTONSTATE==31) { BUTTONSTATE=16; } }…
Adicionado por Rodrigo Sutto ao 10:36 em 27 outubro 2016
ild
o codigo é esse
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//Programa : Controle 2 motores DC usando Ponte H L298N
//Definicoes pinos Arduino ligados a entrada da Ponte H
int IN1 = 4;
int IN2 = 5;
int IN3 = 6;
int IN4 = 7;
void setup()
{
//Define os pinos como saida
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop()
{
//Gira o Motor A no sentido horario
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
delay(2000);
//Para o motor A
digitalWrite(IN1, HIGH);
digitalWrite(IN2, HIGH);
delay(500);
//Gira o Motor B no sentido horario
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
delay(2000);
//Para o motor B
digitalWrite(IN3, HIGH);
digitalWrite(IN4, HIGH);
delay(500);
//Gira o Motor A no sentido anti-horario
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
delay(2000);
//Para o motor A
digitalWrite(IN1, HIGH);
digitalWrite(IN2, HIGH);
delay(500);
//Gira o Motor B no sentido anti-horario
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
delay(2000);
//Para o motor B
digitalWrite(IN3, HIGH);
digitalWrite(IN4, HIGH);
delay(500);
}
…
m o mesmo funcionamento, mas não estou conseguindo receber quaisquer dados do sensor por meio desta biblioteca.
Está junto anexado a biblioteca QTRSensors.
// Inclusão de bibliotecas #include <Button.h>#include <QTRSensors.h>#include <Wire.h>#include <LiquidCrystal.h>
// Definição de constantes#define NUMREADINGS 10 // número de leituras para tirar a média // da tensão da bateria
// Definção de objetosButton button = Button(2,BUTTON_PULLUP_INTERNAL); // botão no pino 2// sensores nos pinos analógicos 0, 1, 2, 3 e 4// usados como digital 14, 15, 16, 17 e 18// 5 sensores, time-out 2000, sem pino de LEDQTRSensorsRC qtr((unsigned char[]) {14, 15, 16, 17, 18}, 5, 2000, QTR_NO_EMITTER_PIN);// display nos pinos R/W - 13, Enable - 12, daods - 9, 8, 7 e 4LiquidCrystal lcd(13, 12, 9, 8, 7, 4);
// Definição de variáveisunsigned int sensors[5]; // Matriz para armazenar valores dos sensores
int inA1 = 10; // Pinagem para a PONTE-Hint inA2 = 11;int inB1 = 5;int inB2 = 6;
//int pinButton = 2; // Pino do botãoint pinBatery = 5; // Pino do sensor de bateria// |GND|---/\/\/\/------/\/\/\/-----|VCC|// 10K | 5K// |int pinAudio = 3; // Pino do Buzzer/Speaker
int voltage;int readings[NUMREADINGS];float volts = 0;int total = 0;float average = 0;int index = 0;int last_proportional;int integral;
// Executado na inicialização do Arduinovoid setup(){ lcd.begin(16, 2); Serial.begin(9600); // Inicializa a comunicação serial pinMode(pinAudio, OUTPUT); // Define pino de audio como saída set_motors(0,0); // Enquanto espera, motores permanecem parados lcd.clear(); lcd.setCursor(0, 0); lcd.print(" LINUSBot"); lcd.setCursor(0, 1); lcd.print(" Line Follower "); delay(2000); voltage = read_batery(); // Lê a tensão da bateria lcd.clear(); lcd.setCursor(0, 0); lcd.print("Bateria"); lcd.setCursor(0, 1); lcd.print(voltage); lcd.print(" mV"); delay(2000); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Inicializando..."); delay(1500); lcd.setCursor(0, 1); lcd.print("OK!"); delay(1000); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Pressione Botao"); while(!button.isPressed()){ } delay(500); // Atraso para dar tempo de tirar o dedo do botão // Sempre espere por um botão ser pressionado antes de que // seu robot possa iniciar a movimentação lcd.clear(); lcd.setCursor(0, 0); lcd.print("Auto-calibracao"); //Serial.println("Auto-calibracao"); // Auto-calibração: gira para a direita e depois esquerda e volta ao início // calibrando os sensores unsigned int counter; // usado como um simples contador for(counter=0; counter<80; counter++){ if(counter < 20 || counter >= 60){ set_motors(50,-50); // Gira para a direita } else{ set_motors(-50,50); // Gira para a esquerda } // Esta função armazena um conjunto de leituras dos sensores, e mantém // informações sobre o máximo e mínimo valores encontrados qtr.calibrate(); // Desde que contamos até 80, o total do tempo de calibração // será de 80 * 10 = 800 ms delay(10); } set_motors(0,0); // Garante motores parados após o processo // de calibração lcd.setCursor(0, 1); lcd.print("Calibrado!"); delay(1000); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Pressione botao"); // Enquanto botão não é pressionado // mostra a posição da linha em relação aos sensores no console serial // usado para debug /* while(!button.isPressed()){ unsigned int position = qtr.readLine(sensors); Serial.println(position); } */}
// Esta é a função principal, onde o código inicia. Todo programa Arduino// deve ter uma função loop() definida em algum lugarvoid loop(){ while(!button.isPressed()){ } delay(200); playMusic(); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Go! go! go! ..."); delay(500); // Este é o loop principal - irá rodar para sempre while(1){ // Obtém a posição da linha // Aqui não estamos interessados nos valores individuais de cada sensor unsigned int position = qtr.readLine(sensors); // O termo proporcional deve ser 0 quando estamos na linha int proportional = ((int)position) - 2000; // Calcula o termo derivativo (mudança) e o termo integral (soma) // da posição int derivative = proportional - last_proportional; integral += proportional; // Lembrando a ultima posição last_proportional = proportional; // Calcula a diferença entre o aranjo de potência dos dois motores // m1 - m2. Se for um número positivo, o robot irá virar para a // direita. Se for um número negativo, o robot irá virar para a esquerda // e a magnetude dos números determinam a agudez com que fará as curvas/giros int power_difference = proportional/10 + integral/10000 + derivative*3/2; // Calcula a configuração atual dos motores. Nunca vamos configurar // um motor com valor negativo const int max = 180; if(power_difference > max) power_difference = max; if(power_difference < -max) power_difference = -max; if(power_difference < 0) set_motors(max+power_difference, max); else set_motors(max, max-power_difference); }}
// Acionamento dos motoresvoid set_motors(int left_speed, int right_speed){ if(right_speed >= 0 && left_speed >= 0){ analogWrite(inA1, 0); analogWrite(inA2, right_speed); analogWrite(inB1, 0); analogWrite(inB2, left_speed); } if(right_speed >= 0 && left_speed < 0){ left_speed = -left_speed; analogWrite(inA1, 0); analogWrite(inA2, right_speed); analogWrite(inB1, left_speed); analogWrite(inB2, 0); } if(right_speed < 0 && left_speed >= 0){ right_speed = -right_speed; analogWrite(inA1, right_speed); analogWrite(inA2, 0); analogWrite(inB1, 0); analogWrite(inB2, left_speed); } }
// Verifica tensão da bateriaunsigned int read_batery(){ // Tirando a média for (int k = 0; k < NUMREADINGS; k++){ // Zerando a matriz readings[k] = 0; } total -= readings[index]; // Inicializa total readings[index] = analogRead(pinBatery); // Faz a leitura do sensor total += readings[index]; // Soma valores da matriz index = (index + 1); // Próximo valor if (index >= NUMREADINGS){ // Verifica se chegou ao fim das leituras index = 0; // Se sim zera o índice } average = total / NUMREADINGS; // Média simples //Serial.println(average); // Para debug, se necessário // Agora calculamos a tensão baseado na leitura analógica média volts = average * 5000 * 3 / 2 / 1023 * 10; return (volts); // Retorna com o valor}
// Toca música e sonsvoid playMusic(){ // Definição de frequência das notas #define NOTE_B0 31 #define NOTE_C1 33 #define NOTE_CS1 35 #define NOTE_D1 37 #define NOTE_DS1 39 #define NOTE_E1 41 #define NOTE_F1 44 #define NOTE_FS1 46 #define NOTE_G1 49 #define NOTE_GS1 52 #define NOTE_A1 55 #define NOTE_AS1 58 #define NOTE_B1 62 #define NOTE_C2 65 #define NOTE_CS2 69 #define NOTE_D2 73 #define NOTE_DS2 78 #define NOTE_E2 82 #define NOTE_F2 87 #define NOTE_FS2 93 #define NOTE_G2 98 #define NOTE_GS2 104 #define NOTE_A2 110 #define NOTE_AS2 117 #define NOTE_B2 123 #define NOTE_C3 131 #define NOTE_CS3 139 #define NOTE_D3 147 #define NOTE_DS3 156 #define NOTE_E3 165 #define NOTE_F3 175 #define NOTE_FS3 185 #define NOTE_G3 196 #define NOTE_GS3 208 #define NOTE_A3 220 #define NOTE_AS3 233 #define NOTE_B3 247 #define NOTE_C4 262 #define NOTE_CS4 277 #define NOTE_D4 294 #define NOTE_DS4 311 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_FS4 370 #define NOTE_G4 392 #define NOTE_GS4 415 #define NOTE_A4 440 #define NOTE_AS4 466 #define NOTE_B4 494 #define NOTE_C5 523 #define NOTE_CS5 554 #define NOTE_D5 587 #define NOTE_DS5 622 #define NOTE_E5 659 #define NOTE_F5 698 #define NOTE_FS5 740 #define NOTE_G5 784 #define NOTE_GS5 831 #define NOTE_A5 880 #define NOTE_AS5 932 #define NOTE_B5 988 #define NOTE_C6 1047 #define NOTE_CS6 1109 #define NOTE_D6 1175 #define NOTE_DS6 1245 #define NOTE_E6 1319 #define NOTE_F6 1397 #define NOTE_FS6 1480 #define NOTE_G6 1568 #define NOTE_GS6 1661 #define NOTE_A6 1760 #define NOTE_AS6 1865 #define NOTE_B6 1976 #define NOTE_C7 2093 #define NOTE_CS7 2217 #define NOTE_D7 2349 #define NOTE_DS7 2489 #define NOTE_E7 2637 #define NOTE_F7 2794 #define NOTE_FS7 2960 #define NOTE_G7 3136 #define NOTE_GS7 3322 #define NOTE_A7 3520 #define NOTE_AS7 3729 #define NOTE_B7 3951 #define NOTE_C8 4186 #define NOTE_CS8 4435 #define NOTE_D8 4699 #define NOTE_DS8 4978
// Definição de músicas int note[] = {NOTE_C4, NOTE_C4, NOTE_G4, NOTE_C5, NOTE_G4, NOTE_C5}; int duration[] = {100, 100, 100, 300, 100, 300};
int starttune[] = {NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_G4, NOTE_F4, NOTE_E4, NOTE_F4, NOTE_G4}; int duration2[] = {100, 200, 100, 200, 100, 400, 100, 100, 100, 100, 200, 100, 500};
int error[] = {NOTE_G3, NOTE_C3, NOTE_G3, NOTE_C3, NOTE_G3, NOTE_C3, NOTE_G3, NOTE_C3}; int duration3[] = {100, 200, 100, 200, 100, 200, 100, 200}; // Loop com a quandiade de notas a serem tocadas // Se necessário, mude o valor interno do loop "for" for(int i=0;i<6;i++){ tone(pinAudio, note[i], duration[i]); // Emite o som nota/duração delay(duration[i]); // Pausa do som noTone(pinAudio); // Finaliza som }}
…