Ciao a tutti, sto facendo un progetto per la mia scuola per competere nella maze entry della robocup.. Avrei un paio di domande sul arduino.. La prima è come faccio a togliere i delay scambiando con qualcos'altro che non blocchi il programma? E la seconda è come faccio io a mandare e ricevere in contemporanea variabili che variano ogni 10 MS? Ps ho provato un po' di tutto ma ancora non riesco a fare gli ultimi preparativi... 
Avrei una domanda anche sul mio programma da farvi ma magari più avanti.... Grazie mille di tutto.
Ti segnalo che, nella sezione in lingua Inglese, si può scrivere SOLO in Inglese ... quindi, per favore, la prossima volta presta più attenzione in quale sezione metti i tuoi post; questa volta esso è stato spostato, da un moderatore della sezione di lingua Inglese, nella sezione di lingua Italiana ... la prossima volta potrebbe venire direttamente eliminato.
Grazie.
A quanto detto da UKHeliBob aggiungo ...
... cortesemente, come prima cosa, leggi attentamente il REGOLAMENTO della sezione Italiana del forum, (... e, per evitare future possibili discussioni/incomprensioni, prestando sempre molta attenzione al punto 15), dopo di che, come da suddetto regolamento (punto 16.7), fai la tua presentazione NELL'APPOSITA DISCUSSIONE (... quello che vedi in blu è un link, fai click su di esso per raggiungere la discussione) spiegando bene quali esperienze hai in elettronica e programmazione, affinché noi possiamo conoscere la tua esperienza ed esprimerci con termini adeguati.
Grazie,
Guglielmo
P.S.: Ti ricordo che, purtroppo, fino a quando non sarà fatta la presentazione nell’apposita discussione, nel rispetto del succitato regolamento nessuno ti risponderà (eventuali risposte o tuoi ulteriori post, verrebbero temporaneamente nascosti), quindi ti consiglio di farla al più presto. 
P.P.S.: Evitate di utilizzare la traduzione automatica fatta dal browser ... vi impedisce di capire la lingua della sezione dove andate a scrivere ...
Mi scusi....staro più attento
Usando delay(t) ritardi l'esecuzione della "istruzione" che segue di t tempo. Al pari di delay, qualunque funzione che detiene il controllo per t tempo sarà da considerarsi bloccante. Ad esempio una funzione utente di nome miaFunzione() esegue un ciclo for che per terminare impiega (detenendo il controllo) 1 secondo. Questa funzione sarà considerabile "bloccante" come per il delay.
La "soluzione" a questi problemi comporta l'impiega di una macchina a stati finiti (FSM Finite State Machine), dove l'esecuzione di porzioni di codice temporizzate viene effettuata tramite il contatore di millesimi di secondo presente in tutti i toolkit software. La funzione millis() restituisce il valore di questo contatore che banalmente è riconducibile ad un orologio.
Oltre millis() c'è anche micros() che restituisce il tempo in microsecondi (us).
C'è una certa difficoltà comune dovuta al cambio di prospettiva, cioè se i tuoi neuroni litigano e vai in confusione considerala cosa normale.
Dal seguente link devi dedurre e verificare che:
- non compare la chiamata a funzione delay
- non ci sono for, while e in genere cicli annidati dentro il ciclo principale
- ogni stato impegna la CPU per poche decine di microsecondi
- ogni stato restituisce il controllo al chiamante.
Ciao.
E comunque, per aiutarci ad aiutarti, oltre ai consigli che ti ha già dato @Maurotec sarebbe in ogni caso opportuno che tu postassi il tuo codice, così potremo darti consigli più mirati.
Il problema, oltre al delay che forse ho risolto ma non sono sicuro , sembra anche essere che non riesco a fare andare avanti il mio robottino di 30 cm senza il delay......devo fare 30 cm e potrebbero esserci degli ostacoli nel labirinto quindi indifferentemente da quello che ha davanti deve andare avanti di 30 cm +- 10% (ho 2 encoder che posso usare su 4) se riesco a fare avanti dopo faccio un void e lo scambio dappertutto come con destragyro in più mi farebbe piacere se mi diceste qualche miglioramento generale e se posso far vedere il muro davanti in direzione== 'a' dentro al while c'è direzione == 'alt' (muro davanti si ferma) in modo che non vada a sbattere sul muro
Ecco qui i codice. P.S. ho imparato da solo quindi il codice potrebbe essere uno schifo..... Aiutatemi ,grazie.
motiri2.ino (9,3 KB)
ah un'altra cosa è che oggi in gara le porte usb del mio raspberry hanno smesso di funzionare quindi non riuscivo più a comunicare con l'arduino per fortuna avevo fatto un po di punti nella prima gara e nella seconda mi sono limitato a metterlo in posizione e dire al valutatore che non andava più niente. Qualificato x nazionali ma ancora molto lavoro da fare quindi mi affido anche a voi......
Per favore, posta il codice non come allegato ma direttamente nel testo (marcandolo con il tag "CODE") così è più facile per noi visionarlo e copiarlo.
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>
#include <Servo.h>
Servo myServo;
const int inputPin = 52;
const int ledPin = 53;
int start=0;
int bottone=0;
int angolo_precedente= 0;
String direzione;
String colore;
String giro_prima;
String rear;
int front;
int angolo_attuale;
String forward;
const int servoPin = 8;
const int startPos = 45;
const int endPos1 = 0;
const int endPos2 = 90;
int servoState = startPos;
//pin controllo motori
const int in1 = 22;
const int in2 = 23;
const int in3 = 24;
const int in4 = 25;
const int in5 = 26;
const int in6 = 27;
const int in7 = 28;
const int in8 = 29 ;
const int pwmPin = 9;
const int pwmPin1 = 10;
const int pwmPin2 = 11;
const int pwmPin3 = 12;
// id, address
Adafruit_BNO055 bno = Adafruit_BNO055(55, 0x28, &Wire);
void avanti() {
digitalWrite(in1, LOW); //motore RL
digitalWrite(in2, HIGH);
digitalWrite(in3, HIGH); //motore RR
digitalWrite(in4, LOW);
digitalWrite(in5, HIGH); //motore FL
digitalWrite(in6, LOW);
digitalWrite(in7, HIGH); //motore FR
digitalWrite(in8, LOW);
}
void destra() {
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
digitalWrite(in3, LOW);
digitalWrite(in4, HIGH);
digitalWrite(in5, HIGH);
digitalWrite(in6, LOW);
digitalWrite(in7, LOW );
digitalWrite(in8, HIGH);
}
void sinistra() {
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
digitalWrite(in3, HIGH);
digitalWrite(in4, LOW);
digitalWrite(in5, LOW);
digitalWrite(in6, HIGH);
digitalWrite(in7, HIGH);
digitalWrite(in8, LOW);
}
void indietro() {
digitalWrite(in1, HIGH); //motore RL
digitalWrite(in2, LOW);
digitalWrite(in3, LOW); //motore RR
digitalWrite(in4, HIGH);
digitalWrite(in5, LOW); //motore FL
digitalWrite(in6, HIGH);
digitalWrite(in7, LOW); //motore FR
digitalWrite(in8, HIGH);
}
void stop() {
digitalWrite(in1, LOW);
digitalWrite(in2, LOW);
digitalWrite(in3, LOW);
digitalWrite(in4, LOW);
digitalWrite(in5, LOW);
digitalWrite(in6, LOW);
digitalWrite(in7, LOW);
digitalWrite(in8, LOW);
}
void moveServo(int position) {
if (servoState < position) {
for (int i = servoState; i <= position; i++) {
myServo.write(i);
}
} else {
for (int i = servoState; i >= position; i--) {
myServo.write(i);
delay(10);
}
}
servoState = position;
}
int correzione_gradi(int dato) {
if (dato >= 355 || dato<= 5) {
dato = 0;
}
if (dato >= 85 && dato <= 95) {
dato = 90;
}
if (dato >= 175 && dato <= 185) {
dato = 180;
}
if (dato >= 265 && dato <= 275) {
dato = 270;
}
return dato;
}
int correzione_inclinazione(int Dato) {
if (Dato >= -3 && Dato <= 3) {
Dato = 0;
}
return Dato;
}
int X_value() {
sensors_event_t event;
bno.getEvent(&event);
return int(event.orientation.x);
}
int Y_value() {
sensors_event_t event;
bno.getEvent(&event);
return int(event.orientation.y);
}
int Z_vale() {
sensors_event_t event;
bno.getEvent(&event);
return int(event.orientation.z); //
}
void leggi_dati_seriale() {
if (Serial.available() > 0) { // Controlla se ci sono dati disponibili
direzione = Serial.readStringUntil('\n'); // Legge una riga di dati
}
}
void destragyro(){
angolo_attuale = X_value();
angolo_attuale = correzione_gradi(angolo_attuale);
if(angolo_precedente==360){
angolo_precedente=0;
}
while(angolo_attuale < (angolo_precedente+77)){
destra();
angolo_attuale = X_value();
angolo_attuale = correzione_gradi(angolo_attuale);
delay(10);
}
angolo_precedente=angolo_precedente+90;
if(angolo_precedente==360){
angolo_precedente=0;
}
}
void sinistragyro(){
angolo_attuale = X_value();
angolo_attuale = correzione_gradi(angolo_attuale);
if(angolo_precedente==0){
angolo_precedente=360;
}
while((angolo_attuale > (angolo_precedente-79)) || ((angolo_attuale == 0) && (angolo_precedente==360)) ){
sinistra();
angolo_attuale = X_value();
angolo_attuale = correzione_gradi(angolo_attuale);
delay(10);
}
angolo_precedente=angolo_precedente-90;
if(angolo_precedente==0){
angolo_precedente=360;
}
}
void setup() {
// Inizializzazione dei pin di controllo come OUTPUT
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(in3, OUTPUT);
pinMode(in4, OUTPUT);
pinMode(pwmPin, OUTPUT);
pinMode(pwmPin1, OUTPUT);
pinMode(in5, OUTPUT);
pinMode(in6, OUTPUT);
pinMode(in7, OUTPUT);
pinMode(in8, OUTPUT);
pinMode(pwmPin2, OUTPUT);
pinMode(pwmPin3, OUTPUT);
TCCR1A = 0b10100001;
TCCR1B = 0b00001101;
OCR1A=80;
OCR1B=80;
TCCR2A = 0b10100011;
TCCR2B = 0b00000111;
OCR2A = 80;
OCR2B = 80;
myServo.write(startPos);
myServo.attach(servoPin);
pinMode(ledPin, OUTPUT);
pinMode(30,OUTPUT);
pinMode(inputPin, INPUT);
Serial.begin(9600);
while (!Serial) delay(10);
bno.setExtCrystalUse(true);
}
void loop() {
colore="";
direzione="";
int valore_Y;
int tim = 0;
int val = digitalRead(inputPin);
if (val == HIGH){
start=1;
digitalWrite(ledPin, HIGH);
}
else{
digitalWrite(ledPin, LOW);
}
if (start>0)
{
if (bottone==0){
Serial.print('S');
bottone=1;
bno.begin();
delay(1000);
}
//si accende quando va il programma
digitalWrite(ledPin, HIGH);
leggi_dati_seriale();
if (forward == "a") {
direzione= "a";
forward= "";
}
if (direzione == "a") {
avanti();
while (true) {
delay(100);
leggi_dati_seriale();
int inclinazione = Y_value();
inclinazione = correzione_inclinazione(inclinazione);
if (inclinazione<-3){
inclinazione = Y_value();
inclinazione = correzione_inclinazione(inclinazione);
while(inclinazione != 0){
inclinazione = Y_value();
inclinazione = correzione_inclinazione(inclinazione);
}
break;
}
if((direzione=="n")){
indietro();
delay(700);
break;
}
if((tim >= 1300) || (direzione=="alt")){
break;
}
tim += 105;
direzione="";
}
stop();
delay(200);
Serial.print('y');
}
if (direzione == "rs"){
OCR1A = 100;
OCR1B = 100;
OCR2A = 100;
OCR2B = 100;
sinistragyro();
stop();
delay(100);
indietro();
delay(700);
avanti();
delay(300);
stop();
delay(1000);
moveServo(endPos1);
delay(1000);
moveServo(endPos2);
delay(1000);
moveServo(startPos);
destragyro();
stop();
delay(200);
Serial.print('y');
}
if (direzione == "rd"){
OCR1A = 80;
OCR1B = 80;
OCR2A = 80;
OCR2B = 80;
destragyro();
indietro;
delay(700);
avanti();
delay(400);
stop();
delay(1000);
moveServo(endPos1);
delay(1000);
moveServo(endPos2);
delay(1000);
moveServo(startPos);
sinistragyro();
stop();
delay(200);
Serial.print('y');
}
if (direzione == "ra"){
OCR1A = 100;
OCR1B = 100;
OCR2A = 100;
OCR2B = 100;
avanti();
delay(500);
stop();
delay(1000);
moveServo(endPos1);
delay(1000);
moveServo(endPos2);
delay(1000);
moveServo(startPos);
stop();
delay(200);
Serial.print('y');
}
if (direzione == "rz"){
OCR1A = 100;
OCR1B = 100;
OCR2A = 100;
OCR2B = 100;
destragyro();
stop();
delay(100);
destragyro();
indietro;
delay(700);
avanti();
delay(400);
stop();
delay(1000);
moveServo(endPos1);
delay(1000);
moveServo(endPos2);
delay(1000);
moveServo(startPos);
stop();
delay(200);
Serial.print('y');
}
if (direzione == "dm") {
OCR1A = 100;
OCR1B = 100;
OCR2A = 100;
OCR2B = 100;
stop();
delay(200);
destragyro();
stop();
delay(500);
indietro();
delay(1000);
avanti();
delay(300);
stop();
delay(200);
forward="a";
}
//////destra/////
if (direzione == "d") {
OCR1A = 100;
OCR1B = 100;
OCR2A = 100;
OCR2B = 100;
stop();
delay(200);
destragyro();
stop();
delay(200);
forward="a";
}
if (direzione == "c") {
OCR1A = 100;
OCR1B = 100;
OCR2A = 100;
OCR2B = 100;
stop();
delay(200);
destragyro();
stop();
delay(200);
Serial.print('y');
}
if (direzione == "sm") {
OCR1A = 100;
OCR1B = 100;
OCR2A = 100;
OCR2B = 100;
stop();
delay(200);
sinistragyro();
stop();
delay(200);
indietro();
delay(1000);
avanti();
delay(300);
stop();
delay(200);
forward="a";
}
if (direzione == "s") {
OCR1A = 100;
OCR1B = 100;
OCR2A = 100;
OCR2B = 100;
stop();
delay(200);
sinistragyro();
stop();
delay(200);
forward="a";
}
OCR1A = 80;/////fr
OCR1B = 83;/////fl
OCR2A = 83;////rl
OCR2B = 80;////rr
colore="";
Serial.flush();
}
}
Purtroppo questi programmi con i delay non possono essere modificati per rimuovere i delay. Ti tocca ripensare tutto.
Nel momento in cui ti viene in mente di usare while o for chiediti se puoi farne a meno e al loro posto usare il main loop, cioè la funzione loop.
Chiediti anche il while o il for quanto tempo cpu consuma per completarsi, ad esempio: ciclo for che consuma 2ms eseguito incondizionatamente ad ogni ciclo di loop comporta un tempo di ciclo di 2ms. Se il for invece dura 1 secondo durante questo periodo non verranno letti ne sensori ne seriale.
Il buffer della seriale riceve dati anche durante un delay(1000) o un for che dura 1 secondo. In questa ottica delay e for sono considerati equivalenti dal punto di vista del consumo di tempo CPU e sono entrambe "bloccanti".
Vedo che usi il delay(10) per rallentare il movimento del servo, questo cosuma 10ms moltiplicato il numero di passi, ad esempio 90 passi x 10ms 90ms rubati. Nel link che ti ho dato c'è come movimentare il servo senza usare il delay. Inoltre considera che il segnale del servo è una onda quadra di periodo 20ms e pertanto aggiornare la posizione del servo prima di 20ms non ha molto senso.
Ciao.
Avrei molte domande, le cui risposte possono tornare utili coloro i quali volessero rispondere.
- Che scheda stai usando?
- A cosa serve il servo RC?
- Quanti motori ci sono?
- Quante ruote?
Anche un foto potrebbe essere di spunto per interessare gli utenti a rispondere.
Ho messo su del codice che però non è quello che ti aspetti.
Il codice serve a comprendere alcuni punti essenziali:
- Il codice che ha agito e che non serve rieseguirlo consuma risorse CPU.
Esempio: Funzione avanti() eseguita la prima volta non deve più essere eseguita. Stessa cosa per le altre funzioni simili. Il vantaggio sta nel tempo di ciclo medio, il quale deve essere il più basso possibile, potrebbe essere meno di 10ms. Minore è il tempo di ciclo medio, maggiore sarà la reattività, cioè al comando inviato, arduino esegui con un tempo di 10ms. - C'è il contatore
uint32_t g_cnt; // global counterche viene incrementato di una unità dopo avere inviato su seriale il comando 'w' (Avanti). Premendo 's' cessa l'incremento e viene visualizzato il valore. Il valore che visualizzo è 229821, che vuole dire che arduino ha eseguito 229821 cicli di loop in circa 1 secondo. Il tempo di ciclo medio è allora 1000ms / 229821 = 0,00435ms (4.3us).
Si è fatto tardi e tanto c'è da dire, ad esempio le String usale il meno possibile, specie per i comandi bastano i byte.
#include <LiquidCrystal.h>
// RS, E, D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 10, 9, 8, 7);
byte g_lastCmd; // ci salvi l'ultimo comando
uint8_t g_cpwm; // current pwm
uint8_t g_opwm = 255; // old pwm
uint32_t g_cnt; // global counter
void setup() {
lcd.begin(16, 2);
Serial.begin(115200);
Serial.println("Setup ok");
}
void marcia(byte cmd) {
switch (cmd) {
case 'w': // avanti
Serial.println("Avanti");
g_lastCmd = 'w'; // ricorda l'ultimo comando
// avanti();
break;
case 'z': // indietro
Serial.println("Indietro");
g_lastCmd = 'z'; // ricorda l'ultimo comando
// indietro(); // chiamata a funzione
break;
case 's': // Stop
Serial.println("Stop");
g_lastCmd = 's'; // ricorda l'ultimo comando
break;
case 'd': // destra
Serial.println("Destra");
g_lastCmd = 'd'; // ricorda l'ultimo comando
// destra();
break;
case 'a': // sinistra
Serial.println("Sinistra");
g_lastCmd = 'a'; // ricorda l'ultimo comando
// sinistra();
break;
}
}
void loop() {
char l_cmd = 0;
if (Serial.available()) {
l_cmd = Serial.read();
}
marcia(l_cmd);
if (isDigit(l_cmd)) {
//Serial.println(l_cmd);
g_cpwm = (l_cmd - 48) * 28;
Serial.println(g_cpwm);
}
switch (g_lastCmd) {
case 'w':
g_cnt++;
if (g_opwm != g_cpwm) {
g_opwm = g_cpwm;
lcd.setCursor(10, 0);
lcd.print(" ");
lcd.setCursor(10, 0);
lcd.print(g_cpwm);
}
// controlla sensori agisci
// se questo comando deve essere fermato
// scrivi g_lastCmd = 0;
break;
case 's':
Serial.println(g_cnt);
g_cnt = 0;
g_lastCmd = 0; // dimentica l'ultimo comando
break;
}
}
Ciao.
Allora la scheda che uso è la 2560 mega il servo motore mi serve per 'salvare' le vittime che trovo nel labirinto lasciando un cubetto ho 4 ruote e 4 motori di cui solo 2 hanno l'encoder ecco qui una foto
In più se conoscete qualche algoritmo per esplorare labirinti sconosciuti e senza bisogno di start e finish è il benvenuto. P. S. Adesso fa decisione randomiche e mi sono reso conto che è troppo random
Solo per fissare le idee, dammi conferma se quanto segue è corretto.
Schede programmabili
n° 1 arduino MEGA
n°1 raspberry pi (quale?)
Connessioni MEGA
BNO055 via I2C, adafruit lib
4 Ponti H uno per motore
2 encoder tipo? hall?
USB MEGA <-> raspberry
Sembra che i sensori di distanza siano allora collegati alla raspberry o no?
Ciao.
tutto quanto vero raspberri pi 4 e 4 motori jgb 37 520( hanno gli encoder già installati) solo 2 con encoder che funziona
Nel codice che hai pubblicato però non vedo traccia della lettura degli encoder, giusto?
Ora si capisce meglio. Poiché alcuni sensori sono connessi alla pi4 e altri alla MEGA c'è la necessità di scambiarsi queste informazioni per condividerle. Certamente il delay non ci dovrebbe proprio essere ed è questo il problema più tosto da affrontare.
Come si condividono le informazioni.
Ci sono due strade:
Master (pi4) Slave (MEGA). Il master interroga e lo slave risponde. Dopo l'interrogazione il master si mette in ascolto su seriale (lo è già perché è fulduplex) tira fuori le sequenze di byte inviate dalla MEGA, esegue un post processo su questi dati. Sempre il master inizia il dialogo con la MEGA e adesso non interroga ma notifica, la mega processa il byte di notifica e si mette in ascolto su seriale tira via i dati dal buffer esegue post processo e fine.
La seconda strada è "su domanda" e sostanzialmente sia pi4 che MEGA possono iniziare la conversazione.
In entrambe i casi vista la velocità ridotta della MEGA conviene comunicare in binario. Intanto alza più possibile la velocità di comunicazione, cioè begin(2500000), prova anche 500000 e 1000000 sperimenta quella che offre maggiore velocità e affidabilità.
Le variabili da inviare dovranno essere tutte dentro una struttura (struct), es:
struct Data {
byte pwm1;
byte pwm2;
byte pwm3;
byte pwm4;
qui altre le variabili, facendo attenzione al padding
};
Cosa si intende per padding? Ora non sono capace di riassumere, ma Guglielmo spero di si. Dovrebbe essere sufficiente che la struttura sia composta in multipli di 4 byte, così che la lunghezza non possa essere dispari, quindi 4, 8, 12 ecc, se viene 11 byte ci aggiungi una variabile da 1 byte (un dummy byte).
PS: ci vado piano anche perché poi mi confondo pure io.
Ciao.
I due comunicano su domanda, quando premo il pulsante di start il mega manda 'S' al raspberry che riceve e manda la direzione da prendere, alla fine di ogni direzione quando il mega ha finito manda y per prendere un'altra decisione.....Gli encoder devo ancora farli ho chiesto qui nel forum come integrarli il meglio possibile.....Se volete posso mettere online anche il programma di Python.......La comunicazione seriale sembra essere abbastanza veloce adesso che ho risolto 2 robette su python....
... mi viene in mente solo QUESTO (punto 4, padding) 
Guglielmo
1 Like
Hmmmmm ok forse ho capito....
Se scambi dati tra Arduino MEGA e raspberry deve tenere conto che le lunghezze delle variabili sono diverse ... tutte le MCU AVR sono ad 8 bit, la raspberry è a 32 bit, quindi, nelle definizioni, se NON vuoi avere problemi, evita di usare i tipi standard, come byte, int, long, ecc. ma usa quanto è definito in <stdint.h> ovvero, ad esempio, unit8_t, int16_t, int32_t, ecc. così le lunghezze delle variabili sono ben definite e non rischi di avere dimensioni differenti.
Guglielmo