Guarda, il mio consiglio è di buttare tutto, ricominciare da capo e ... FARE UN PASSO ALLA VOLTA ...
... cercare di fare tutto assieme non porta mai a nulla di buono ... quindi, dividi in fasi il tuo progetto, comincia dalla prima fase (es. "far girare una pedana circolare in senso orario che si fermi 4 volte per tot secondi in punti precisi") e solo quando questa prima fase sarà perfettamente funzionante ed ottimizzata passi ad una fase successiva, e così via.
Vedrai che in questo modo arrivi a sviluppare tutto il tuo progetto
Grazie per la risposta...
Forse è proprio questo il fatto... sono confuso...
Ho collegato su breadboard l'arduino e messo solo il codice che mi dovrebbe stoppare il relè del motore dive ci sono i finecorsa che mu arrivano domani.
In sostituzione ho messo dei bottoni per pcb collegati in pullup con delle resistenze da 10kohm, ma l'arduino fa quello che vuole... o meglio non glielo faccio capire che deve fare...
Il problema secondo me è che non ho capito come funzionano bene le istruzioni if o switch case...
Guarda, potresti cominciare con lo studiare un po' più approfonditamente QUESTO e puoi scaricarti QUESTO libro (... tranquillo, è un sito legale, purché per esclusivo uso PERSONALE).
Salve a tutti!
Ho seguito il consiglio di gpb01 che gentilmente mi ha passato delle guide su cui poter approfondire in questi giorni le funzioni di arduino.
Ho tirato un pò le somme e per gestire un pò il tutto dovevo cambiare totalmente il codice proposto prima.
Ho fatto delle prove cercando di gestire solo la pedana mobile e non i cubi che poggiano sopra per semplificare un po il codice e capirci un pochino anch'io.
Il ragionamento che ho seguito a mio parere sembrava logico, ma non l'ho potuto verificare perche l'IDE mi da degli errori e oltretutto non so i comandi che devo mettere per far partire il motore.
Vi incollo il codice con la speranza che ci sia qualcuno che possa darmi una mano a capire gli sbagli e le eventuali correzioni.
Mi dispiace ma non sono un programmatore ma volenteroso nel capire ....
Grazie
/* AUTOMAZIONE PIAZZETTA SIGNURARA
FP1 FineCorsa primo step pedana, che chiuderà verso massa il circuito restituendo un livello logico zero; collegare R di pull-up (10K) tra piedino di Arduino e +5V
FP2 FineCorsa secondo step pedana, che chiuderà verso massa il circuito restituendo un livello logico zero; collegare R di pull-up (10K) tra piedino di Arduino e +5V
FP3 FineCorsa terzo step pedana, che chiuderà verso massa il circuito restituendo un livello logico zero; collegare R di pull-up (10K) tra piedino di Arduino e +5V
FP4 FineCorsa quarto step pedana, che chiuderà verso massa il circuito restituendo un livello logico zero; collegare R di pull-up (10K) tra piedino di Arduino e +5V
FC1 FineCorsa primo step Cubo, che chiuderà verso massa il circuito restituendo un livello logico zero; collegare R di pull-up (10K) tra piedino di Arduino e +5V
FC2 FineCorsa secondo step Cubo, che chiuderà verso massa il circuito restituendo un livello logico zero; collegare R di pull-up (10K) tra piedino di Arduino e +5V
*/
# define FP1 2 //Finecorsa1 pedana collegato al pin digitale n.2
# define FP2 3 //Finecorsa2 pedana collegato al pin digitale n.3
# define FP3 4 //Finecorsa3 pedana collegato al pin digitale n.4
# define FP4 5 //Finecorsa4 pedana collegato al pin digitale n.5
# define FPR 8 //Finecorsa RITORNO pedana collegato al pin digitale n.8
# define MPA 9 //Relè Motore avanti pedana
# define MPI 10 //Relè Motore indietro pedana
# define LED1 13 //Faretto 13
int letturaFP1 = 1; //Definiz. e assegnaz. delle variabili di programma
int letturaFP2 = 1;
int letturaFP3 = 1;
int letturaFP4 = 1;
int letturaFPR = 1;
int FP1;
int FP2;
int FP3;
int FP4;
int FPR;
int MPA;
int MPI;
int LED1;
int FP1temp;
int FP2temp;
int FP3temp;
int FP4temp;
int FPRtemp;
int MPA;
int MPI;
int posizMPA;
int posizMPI;
int k;
unsigned long time;
unsigned long MPAtime;
unsigned long MPItime;
unsigned long letturadati;
unsigned long letturafinec_time;
void setup()
{
pinMode(FP1, INPUT); //Impostaz. dei piedini di Arduino come INPUT o OUTPUT
pinMode(FP2, INPUT);
pinMode(FP3, INPUT);
pinMode(FP4, INPUT);
pinMode(FPR, INPUT);
pinMode(MPA, INPUT);
pinMode(MPI, INPUT);
Serial.begin(9600);
time=millis();
MPAtime=millis();
MPItime=millis();
letturadati=millis();
letturafinec_time=millis();
k=0;
FP1=0;
FP2=0;
FP3=0;
FP4=0;
FPR=0;
}
void loop()
{
time=millis();
if (time>letturafinec_time+5)
{
FP1=digitalRead(FP1);
FP2=digitalRead(FP2);
FP3=digitalRead(FP3);
FP4=digitalRead(FP4);
FPR=digitalRead(FPR);
k=k+1;
FP1temp=FP1temp+FP1;
FP2temp=FP2temp+FP2;
FP3temp=FP3temp+FP3;
FP4temp=FP4temp+FP4;
FPRtemp=FPRtemp+FPR;
}
if(k==20)
{
k=0;
letturaFP1=FP1temp/20;
letturaFP2=FP2temp/20;
letturaFP3=FP3temp/20;
letturaFP4=FP4temp/20;
letturaFPR=FPRtemp/20;
FP1temp=0;
FP2temp=0;
FP3temp=0;
FP4temp=0;
FPRtemp=0;
}
if(time>MPAtime+15)
{
posizMPA=digitalRead(letturaFP1);
posizMPA=(posizMPA,0,1); //Non capisco che tipo di comando devo mettere...
digitalWrite(MPA,HIGH); //Non capisco che tipo di comando devo mettere...
MPAtime=millis();
}
if(time>letturadati+3000)
{
Serial.print("FP1: ");
Serial.println(letturaFP1, DEC);
Serial.print("FP2: ");
Serial.println(letturaFP2, DEC);
Serial.print("Posizione MPA: ");
Serial.println(posizMPA, DEC);
Serial.print("Posizione MPI: ");
Serial.println(posizMPI, DEC);
Serial.print("FP3: ");
Serial.println(letturaFP3, DEC);
Serial.print("FP4: ");
Serial.println(letturaFP4, DEC);
Serial.print("FPR: ");
Serial.println(letturaFPR, DEC);
letturadati=millis();
}
}
... ci vuole molta pazienza e, come spiega il regolamento, aspettare almeno 48 ore prima di fare "up" ... non sempre tutti sono qui e disponibili
Però ... non hai fatto un passo per volta come ti avevo detto, ma già hai messo molta carne al fuoco ...
... perché NON cominci semplicemente a capire SOLO come far girare la pedana (... che mi sembra già per te un primo problema) ?
T'ho detto, metti tutto da parte, parti con un programma VUOTO ed inizia UNA COSA PER VOLTA ... o non ne esci.
Quindi ...
metti uno schema di come hai collegato il motore che fa girare la pedana
metti il codice che serve SOLO a far girare la pedana
Quando il tutto sarà giusto (HW + SW) si passerà al controllo delle 4 posizioni.
perche' ad esempio l'ultimo codice che hai inserito è talmente contorto, privo di senso e con tanti di quegli errori che è quasi impossibile commentarlo.
e' come trovarsi davanti a un eschimese e chiedere dove trovare della mozzarella..
cosa c'entra questo con la tua richiesta ? Niente, è questo il problema
Comunque, siamo tutti quà, fai come dice Guglielmo, inizia con farci vedere come hai collegato il motore e inizia con uno sketch semplice,.
Avete ragione @gpb01 e @brunello, devo fare un passo per volta... domani disegnerò gli schemi e abbozzerò uno sketch semplice che mi consenta di far girare la pedana....
2 schede relè da 8 moduli per comandare 2 motori, uno per la pedana ed uno per il cubo (1 relè avanti ed uno indietro per ogni motore).
non avrai mica idea di collegare l'alimentazione delle schede relè come hai disegnato ?
prevedi da subito un alimentatore esterno
Un motore Avanti-Indietro o 2 motori ?
Di che motori si tratta ?
Al motore va' direttamente il Neutro, non la Fase
Hai collegato male i relè al motore, il Common è il centrale
Quando disegni, fai attenzione, i cavi di alimentazione del 5V vanno sulla Breadboard nelle due righe orizzontali, tu li hai collegati in mod errato. E non venire a dire "che si capisce"
Salve, e grazie a @Brunello per la risposta ed i consigli...
Comunque:
Ho provveduto all'alimentazione supplementare delle schede relay.
Avevo previsto un motore che facesse avanti ed indietro ma visto che non so come fare per fargli cambiare rotazione in alternativa potrei mettere 2 motori...
Hai qualche consiglio da darmi in merito?? Io sto usando dei motori ridotti o motoriduttore da 24V non so come si dice con queste caratteristiche. Premi qui!
Corretto errore fase neutro
4.Non avevo fatto caso al simbolino sul relè comunque corretto.
Non ho capito bene questo punto ma penso ti riferissi hai collegamenti della resistenza...
Ho provveduto all'alimentazione supplementare delle schede relay.
guarda QUI come alimentare correttamente codeste schedine.
Avevo previsto un motore che facesse avanti ed indietro ma visto che non so come fare per fargli cambiare rotazione in alternativa potrei mettere 2 motori...
Con solo due relè SPDT, vedo una sola possibilità di collegamento.
Hai ragione non non sapevo che l'alimentazione supplementare si collegasse così...
Per quanto riguarda la rotazione avanti ed indietro del motore devo dire che quei tipi di collegamenti sono una cosa geniale... Complimenti per la tua preparazione!!
Comunque posso abbozzare lo sketch che comanda le due rotazioni del motore o che includa anche i finecorsa... No perchè il mio problema era quale funzione e meglio usare per leggere lo stato dei finecorsa (if... else.... switch... case....).
Secondo te cosa è meglio usare, o meglio come impostare lo sketch?
/* AUTOMAZIONE PIAZZETTA SIGNURARA
*/
# define rele1 10 //Relè1
# define rele2 9 //Relè2
# define finec1 2 //Finecorsa inizio
# define finec2 3 //Finecorsa primo step
# define finec3 4 //Finecorsa secondo step
# define finec4 5 //Finecorsa terzo step
# define finecRitorno 8 //Finecorsa quarta step e ritorno
void setup()
{
Serial.begin(9600); // for serial monitor output
pinMode(rele1, OUTPUT);
pinMode(rele2, OUTPUT);
pinMode(finec1, INPUT);
pinMode(finec2, INPUT);
pinMode(finec3, INPUT);
pinMode(finec4, INPUT);
pinMode(finecRitorno, INPUT);
}
void loop()
{
if (finec1==HIGH || finec2==HIGH || finec3==HIGH || finec4==HIGH) //Se i finecorsa non sono attivi - finecorsa collegati con resistenze di pull-up (10K) tra piedino di Arduino e +5V
{
digitalWrite(rele1,LOW);
digitalWrite(rele2,HIGH); //il motore deve girare in avanti.
}
if (finec1==LOW || finec2==LOW || finec3==LOW || finec4==LOW) //Se i finecorsa sono attivi - finecorsa collegati con resistenze di pull-up (10K) tra piedino di Arduino e +5V
{
digitalWrite(rele1,LOW);
digitalWrite(rele2,LOW); //il motore si deve fermare.
}
if (finecRitorno==LOW) //Se il finecorsa che indica che si deve ritornare al primo step è attivo - finecorsa collegati con resistenze di pull-up (10K) tra piedino di Arduino e +5V
{
digitalWrite(rele1,HIGH);
digitalWrite(rele2,LOW); //il motore deve tornare indietro al primo step.
}
}
Il succo è questo:
La pedana si deve fermare ad ogni step e rimanere in quella posizione per 1 minuto per poi ripartire ed andare avanti al prossimo finecorsa, fino ad arrivare al finecorsa di ritorno. Una volta arrivato al finecorsa di ritorno si deve fermare sempre per 1 minuto per poi ripartire all'indietro fino al finecorsa 1 cioè quello di inizio....
A parte il fatto che non leggi i sensori (manca il digitalRead() ), quindi il motore si avvia e mai piu' si ferma.
Anche se li leggi, si ferma al primo sensore che trova e mai più riparte
Ti voglio dare un'aiutino, quindi ti metto una base su cui lavorare. Ho cercato di farla semplice, sperando che tu riesca a comprenderla meglio. Come denominazione dei sensori preferisco quella che usavi prima
# define FP1 2 //Finecorsa1 pedana
# define FP2 3 //Finecorsa2 pedana
# define FP3 4 //Finecorsa3 pedana
# define FP4 5 //Finecorsa4 pedana
# define FPR 6 //Finecorsa RITORNO
# define MPA 9 //Relè Motore avanti pedana
# define MPI 10 //Relè Motore indietro pedana
boolean stato_errore = false ;
unsigned int ritardo = 5000 ; // tempo in cui pedana stà ferma
void setup()
{
Serial.begin (9600);
pinMode(FP1, INPUT_PULLUP); // sensore posizione iniziale
pinMode(FP2, INPUT_PULLUP);
pinMode(FP3, INPUT_PULLUP);
pinMode(FP4, INPUT_PULLUP);
pinMode(FPR, INPUT_PULLUP);
pinMode(MPA, OUTPUT);
pinMode(MPI, OUTPUT);
motore_pedana_stop();
Serial.println("inizia fino alla posizione di Start");
reset_pedana(); // il motore va' fino a posizione di Start
}
void loop() {
// 1° Step *************************************
Serial.println("Inizia Primo Step");
motore_pedana_avanti() ;
while (digitalRead(FP2) == HIGH ) {
if (digitalRead(FP3) == 0 || digitalRead(FP4) == 0 || digitalRead(FPR) == 0 )
{
stato_errore = true ;
break ;
}
}
motore_pedana_stop();
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Primo Step");
delay(ritardo);
// attivare cubo
// attivare led
// 2° Step *************************************
Serial.println("Inizia Secondo Step");
motore_pedana_avanti() ;
while (digitalRead(FP3) == HIGH ) {
if (digitalRead(FP4) == 0 || digitalRead(FPR) == 0 || digitalRead(FP1) == 0 )
{
stato_errore = true ;
break ;
}
}
motore_pedana_stop();
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Secondo Step");
delay(ritardo);
// attivare cubo
// attivare led
// 3° Step *************************************
Serial.println("Inizia Terzo Step");
motore_pedana_avanti() ;
while (digitalRead(FP4) == HIGH ) {
if (digitalRead(FPR) == 0 || digitalRead(FP1) == 0 || digitalRead(FP2) == 0 )
{
stato_errore = true ;
break ;
}
}
motore_pedana_stop();
if (stato_errore)
{
errore_sensori();;
}
Serial.println("finito Terzo Step");
delay(ritardo);
// attivare cubo
// attivare led
// 4° Step *************************************
Serial.println("Inizia Quarto Step");
motore_pedana_avanti() ;
while (digitalRead(FPR) == HIGH ) {
if (digitalRead(FP1) == 0 || digitalRead(FP2) == 0 || digitalRead(FP3) == 0 )
{
stato_errore = true ;
break ;
}
}
motore_pedana_stop();
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Quarto Step");
delay(ritardo);
// attivare cubo
// attivare led
// fine del ciclo. Torna a posizione di Start
Serial.println();
Serial.println("Torna a Start e rincomincia");
reset_pedana();
} // Fine LOOP ***************************
void errore_sensori() { // Se un sensore non richiesto si attiva
Serial.println();
Serial.println("Errore sui sensori");
// tone (pin_buzzer,frequenza); // Attiva un buzzer
while (1); // blocca tutto e aspetta un reset Hardware ( volendo si puo' inserire un Reset software)
}
void reset_pedana() {
while (digitalRead(FP1) == HIGH) { // legge sensore di posizione iniziale
motore_pedana_indietro(); // avvia motore indietro fino al sensore di posizione iniziale
}
Serial.println("finito reset. Posizionato su Start"); // esce dal while quando si attiva il sensore di posizione iniziale
motore_pedana_stop();
}
void motore_pedana_avanti() {
digitalWrite(MPA, LOW);
digitalWrite(MPI, HIGH);
}
void motore_pedana_indietro() {
digitalWrite(MPA, HIGH);
digitalWrite(MPI, LOW);
}
void motore_pedana_stop() {
digitalWrite(MPA, HIGH);
digitalWrite(MPI, HIGH);
}
e visto che ancora devi capire come strutturare un programma, abituati a stendere su carta i vari passaggi
Ciao Brunello è grazie per l’aiuto che mi stai dando.
Per il fatto della lettura dei finecorsa nello sketch che ho fatto io è stata una dimeticanza (e anche grossa)!
Ma ho visto che lo sketch che ho abbozzato io non c’entra niente con quello completo che hai postato tu….
E meno male che non ho caricato la struttura del programma che avevo fatto su carta… avresti riso per un mese…
Comunque domattina provo il tuo sketch e proverò ad inserire le accensioni dei faretti e il movimento del motore del cubo tra gli altri 2 finecorsa che deve essere sincronizzato con gli step della pedana…
Ciao Brunello.... ero convinto di avere postato già il codice...
Eccolo:
# define FP1 2 //Finecorsa1 pedana
# define FP2 3 //Finecorsa2 pedana
# define FP3 4 //Finecorsa3 pedana
# define FP4 5 //Finecorsa4 pedana
# define FPR 6 //Finecorsa pedana RITORNO
# define MPA 9 //Relè Motore avanti pedana
# define MPI 10 //Relè Motore indietro pedana
# define FC1 8 //Finecorsa1 cubo
# define FC2 7 //Finecorsa2 cubo
# define MCA 11 //Relè Motore avanti cubo
# define MCI 12 //Relè Motore indietro cubo
boolean stato_errore = false ;
unsigned int ritardo = 5000 ; // tempo in cui pedana stà ferma
void setup()
{
Serial.begin (9600);
pinMode(FP1, INPUT_PULLUP); // sensore posizione iniziale
pinMode(FP2, INPUT_PULLUP);
pinMode(FP3, INPUT_PULLUP);
pinMode(FP4, INPUT_PULLUP);
pinMode(FPR, INPUT_PULLUP);
pinMode(MPA, OUTPUT);
pinMode(MPI, OUTPUT);
pinMode(FC1, INPUT_PULLUP);
pinMode(FC2, INPUT_PULLUP);
pinMode(MCA, OUTPUT);
pinMode(MCI, OUTPUT);
motore_pedana_stop();
Serial.println("inizia fino alla posizione di Start");
reset_pedana(); // il motore va' fino a posizione di Start
motore_cubo_stop();
Serial.println("Inizia cubo fino alla posizione di Start");
reset_cubo(); //Il motore sposta il cubo fino alla posizione di Start
}
void loop() {
// 1° Step *************************************
Serial.println("Inizia Primo Step");
motore_pedana_avanti() ;
while (digitalRead(FP2) == HIGH ) {
if (digitalRead(FP3) == 0 || digitalRead(FP4) == 0 || digitalRead(FPR) == 0 )
{
stato_errore = true ;
break ;
}
}
motore_pedana_stop();
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Primo Step");
delay(ritardo);
// attivare cubo
Serial.println("Inizia primo step Cubo");
motore_cubo_indietro();
while (digitalRead(FC1) == HIGH ){
if (digitalRead(FC2) == 0)
{
stato_errore = true;
break;
}
}
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Primo Step Cubo");
// attivare led
// 2° Step *************************************
Serial.println("Inizia Secondo Step");
motore_pedana_avanti() ;
while (digitalRead(FP3) == HIGH ) {
if (digitalRead(FP4) == 0 || digitalRead(FPR) == 0 || digitalRead(FP1) == 0 )
{
stato_errore = true ;
break ;
}
}
motore_pedana_stop();
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Secondo Step");
delay(ritardo);
// attivare cubo
Serial.println("Inizia Secondo Step Cubo");
motore_cubo_avanti() ;
while (digitalRead(FC2) == HIGH ) {
if (digitalRead(FC1) == 0)
{
stato_errore = true ;
break ;
}
}
motore_cubo_stop();
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Secondo Step Cubo");
// attivare led
// 3° Step *************************************
Serial.println("Inizia Terzo Step");
motore_pedana_avanti() ;
while (digitalRead(FP4) == HIGH ) {
if (digitalRead(FPR) == 0 || digitalRead(FP1) == 0 || digitalRead(FP2) == 0 )
{
stato_errore = true ;
break ;
}
}
motore_pedana_stop();
if (stato_errore)
{
errore_sensori();;
}
Serial.println("finito Terzo Step");
delay(ritardo);
// attivare cubo
Serial.println("Inizia Terzo Step Cubo");
motore_cubo_indietro() ;
while (digitalRead(FC1) == HIGH ) {
if (digitalRead(FC2) == 0)
{
stato_errore = true ;
break ;
}
}
motore_cubo_stop();
if (stato_errore)
{
errore_sensori();;
}
Serial.println("finito Terzo Step Cubo");
// attivare led
// 4° Step *************************************
Serial.println("Inizia Quarto Step");
motore_pedana_avanti() ;
while (digitalRead(FPR) == HIGH ) {
if (digitalRead(FP1) == 0 || digitalRead(FP2) == 0 || digitalRead(FP3) == 0 )
{
stato_errore = true ;
break ;
}
}
motore_pedana_stop();
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Quarto Step");
delay(ritardo);
// attivare cubo
Serial.println("Inizia Quarto Step");
motore_cubo_avanti() ;
while (digitalRead(FC2) == HIGH ) {
if (digitalRead(FC1) == 0)
{
stato_errore = true ;
break ;
}
}
motore_cubo_stop();
if (stato_errore)
{
errore_sensori();
}
Serial.println("finito Quarto Step Cubo");
// attivare led
// fine del ciclo. Torna a posizione di Start
Serial.println();
Serial.println("Torna a Start e rincomincia");
reset_pedana();
// fine del ciclo. Torna a posizione di Start
Serial.println();
Serial.println("Rimani in posizione per ricominciare da start");
reset_cubo();
} // Fine LOOP ***************************
void errore_sensori() { // Se un sensore non richiesto si attiva
Serial.println();
Serial.println("Errore sui sensori");
// tone (pin_buzzer,frequenza); // Attiva un buzzer
while (1); // blocca tutto e aspetta un reset Hardware ( volendo si puo' inserire un Reset software)
}
void reset_pedana() {
while (digitalRead(FP1) == HIGH) { // legge sensore di posizione iniziale
motore_pedana_indietro(); // avvia motore indietro fino al sensore di posizione iniziale
}
Serial.println("finito reset. Posizionato su Start"); // esce dal while quando si attiva il sensore di posizione iniziale
motore_pedana_stop();
}
void reset_cubo() {
while (digitalRead(FC1) == HIGH) { // legge sensore di posizione iniziale
motore_cubo_indietro(); // avvia motore indietro fino al sensore di posizione iniziale
}
Serial.println("finito reset. Posizionato cubo su Start"); // esce dal while quando si attiva il sensore di posizione iniziale
motore_cubo_stop();
}
void motore_pedana_avanti() {
digitalWrite(MPA, LOW);
digitalWrite(MPI, HIGH);
}
void motore_pedana_indietro() {
digitalWrite(MPA, HIGH);
digitalWrite(MPI, LOW);
}
void motore_pedana_stop() {
digitalWrite(MPA, HIGH);
digitalWrite(MPI, HIGH);
}
void motore_cubo_avanti() {
digitalWrite(MCA, HIGH);
digitalWrite(MCI, LOW);
}
void motore_cubo_indietro() {
digitalWrite(MCA, LOW);
digitalWrite(MCI, HIGH);
}
void motore_cubo_stop() {
digitalWrite(MCA, LOW);
digitalWrite(MCI, LOW);
}