... perdona @Zorkk ma ... devo intervenire ... puoi dirgli che si pone male, che ha un atteggiamento supponente o arrogante, ma NON puoi dire che è stato maleducato
Non ti ha insultato ne ha usato male parole (... sarebbe già stato bannato) ... è solo un modo di fare che può risultare più o meno antipatico, ma nulla più.
Il consiglio, in questi casi, è sempre lo stesso, IGNORATE e NON rispondete alle persone con cui non volete avere contatti ... così evitiamo discussioni e incomprensioni.
non capisco in che senso non letti correttamente, sto semplicemente usando una lettura analogica per determinare se viene chiuso a GND un contatto. il pull-up è dato tramite resistenza esterna, se la lettura scende sotto i 250 è considerato chiuso.
certo, il ritorno della funzione sopra viene passato direttamente a questa:
void send_command_by_input(uint8_t command)
{
switch (command) // Seleziona il comando corrispondente
{
case 1:
selectorObj.resetLed(probeA_led); // Resetta i LED del probe A
selectorObj.set_SELx_bit(probeV.probe_A_bit_array); // Imposta il probe A
globalV.pre_input_decoded = command; // Memorizza il comando
break;
case 2:
selectorObj.resetLed(probeB_led); // Resetta i LED del probe B
selectorObj.set_SELx_bit(probeV.probe_B_bit_array); // Imposta il probe B
globalV.pre_input_decoded = command;
break;
case 3:
selectorObj.resetLed(probeF_led); // Resetta i LED del probe F
selectorObj.set_SELx_bit(probeV.probe_F_bit_array); // Imposta il probe F
globalV.pre_input_decoded = command;
break;
case 4:
selectorObj.resetLed(probeRST_led); // Resetta i LED del probe RST
selectorObj.set_SELx_bit(probeV.probeRST_bitArray); // Imposta il probe su tutti LOW
globalV.pre_input_decoded = command;
break;
case 5:
selectorObj.set_SELx_bit(probeV.probe_IDLE_bit_array); // Imposta il probe su stato idle
globalV.pre_input_decoded = command;
break;
case 6:
selectorObj.set_SELx_bit(probeV.bank_11_12_set_bit_array); // Imposta i relè della bank 1.1-1.2
globalV.pre_input_decoded = command;
break;
case 7:
selectorObj.set_SELx_bit(probeV.bank_11_12_reset_bit_array); // Resetta i relè della bank 1.1-1.2
globalV.pre_input_decoded = command;
break;
case 8:
selectorObj.set_SELx_bit(probeV.bank_13_14_set_bit_array); // Imposta i relè della bank 1.3-1.4
globalV.pre_input_decoded = command;
break;
case 9:
selectorObj.set_SELx_bit(probeV.bank_13_14_reset_bit_array); // Resetta i relè della bank 1.3-1.4
globalV.pre_input_decoded = command;
break;
case 10:
selectorObj.set_SELx_bit(probeV.bank_5_set_bit_array); // Imposta i relè della bank 5
globalV.pre_input_decoded = command;
break;
case 11:
selectorObj.set_SELx_bit(probeV.bank_5_reset_bit_array); // Resetta i relè della bank 5
globalV.pre_input_decoded = command;
break;
default:
break; // Non fare nulla per comandi non validi
}
digitalWrite(PIN_COMMAND_OK, HIGH); // Comando eseguito
while (input_decode() == globalV.pre_input_decoded) // Evita l'esecuzione ripetuta del comando finché l'ingresso non cambia
{
}
}
... nel senso che, normalmente ed in modo più affidabile, NON si fa una lettura analogica, con tutto ciò che esso comporta, ma una semplice lettura digitale (digitalRead()) di un pin, magari tenuto alto da una pull-up così da rilevare quando va LOW
Se il valore letto scende sotto la soglia per forza di cose il relè ha chiuso a GND, nel mio contesto la lettura è affidabile. Ho dovuto usare questi pin in quanto tutti gli altri digitali sono utilizzati. Se parliamo di lentezza in quanto uso l'ADC ok, ma non credo sia questo la causa del problema.
void SelectorProbe::set_SELx_bit(uint8_t pb[])
{
uint8_t i = 0; // Variabile indice per iterare sull'array `pb`.
// Cicla finché non trova il valore terminatore 0xff nell'array `pb[]`.
while (pb[i] != 0xff)
{
// Imposta i pin `pinIO` in base ai bit del valore corrente di `pb[i]`.
digitalWrite(pinIO[0], ((pb[i] & (1 << 0)) != 0)); // Controlla il bit 0 di `pb[i]`.
digitalWrite(pinIO[1], ((pb[i] & (1 << 1)) != 0)); // Controlla il bit 1 di `pb[i]`.
digitalWrite(pinIO[2], ((pb[i] & (1 << 2)) != 0)); // Controlla il bit 2 di `pb[i]`.
digitalWrite(pinIO[3], ((pb[i] & (1 << 3)) != 0)); // Controlla il bit 3 di `pb[i]`.
digitalWrite(pinIO[4], ((pb[i] & (1 << 4)) != 0)); // Controlla il bit 4 di `pb[i]`.
// Se la modalità debug è attivata, stampa i valori dei bit sui pin.
if (debug_on)
{
Serial.print(((pb[i] & (1 << 0)) != 0)); // Stampa il valore del bit 0.
Serial.print(((pb[i] & (1 << 1)) != 0)); // Stampa il valore del bit 1.
Serial.print(((pb[i] & (1 << 2)) != 0)); // Stampa il valore del bit 2.
Serial.print(((pb[i] & (1 << 3)) != 0)); // Stampa il valore del bit 3.
Serial.println(((pb[i] & (1 << 4)) != 0)); // Stampa il valore del bit 4.
}
i++; // Passa al valore successivo nell'array `pb`.
delay(clk); // Attende un intervallo di tempo pari al valore del clock `clk`.
}
// Alla fine del ciclo, se debug è attivo, stampa "End".
if (debug_on)
Serial.println("End");
}
Hai ragione pienamente ragione sul fatto che uno dovrebbe ignorare, ma non si può certo sostenere che il suo sia un atteggiamento corretto che si dovrebbe avere su una pagina come questa, dove si dovrebbe cercare di aiutare il prossimo non elargire giudizi sprezzanti, detto ciò ribadisco che hai ragione sul fatto che uno dovrebbe ignorare e via.
Tu sai vero che su Arduino NANO V3 i pin da A0 ad A5 sono anche digitali e sono identificati dai numero da 14 a 19 (... e che quindi hai 6 pin digitali in più)?
Si, però da alcune prove con digitalRead(14) mi dava risultati inaspettati, probabilmente errore mio ma non ho approfondito è ho usato analogRead(), comunque dubito sia qui il problema.
while (pb[i] != 0xff) esegue fino che non trova il byte di fine array
mentre while (input_decode() == globalV.pre_input_decoded) blocca nel ciclo l'esecuzione fino che il comando non cambia rispetto all'ultimo rilevato, per evitare che l'azione venga ripetuta più volte per lo stesso command
Esatto, infatti non mi spiego perché mi dava risultati strani con digitalRead(14), in altre situazioni (mega ad esempio) ho usato tranquillamente tutti i pin analogici come digitali, approfondirò.
Si può accadere che nonostante ti compaia Input decoded: 3 sul terminale, quando la funzione ritorna al chiamante command ha valore diverso da 3. Se si è sicuri che ciò accade l'unica spiegazione
è legata alla memoria, in particolare alla memoria riservata allo stack. In sostanza stai usando troppa memoria. In tal caso darebbe lo stesso problema se al posto di delay chiami un'altra funzione che usa lo stack. Però dici che se il delay lo riduci non hai il problema, si dovrebbe analizzare la delay() per vedere se c'è legame.
Per ipotesi diciamo che non si tratta di memoria, quindi il problema è da qualche altra parte, si ma
dove?
Di sicuro non può accadere che nella stessa chiamata visualizza 3 e restituisce diverso da 3, allora potremmo ipotizzare che ciò accade tra due chiamate, dove la prima restituisce 3 e lo stampa, la successiva restituisce zero. Due chiamate ad intervallo di 10ms.
Hai considerato che i contatti dei relay rimbalzano? Può influire?
Il pin CS è sempre sotto relay?
Se al posto di analogRead usi digitalRead sicuramente ti serve una routine di anti rimbalzo e magari
anche un filtro rc su ogni pin o ancora meglio un chip 7414 (o simile) trigger schmitt.
Il pin CS è sempre sotto relay. La macchina lato relay funziona così: si settano i vari relay che determinano i bit, attendo 500 ms per far sì che si stabilizzino ed evitare rimbalzi, dopo attivo lo strobe CS. Da quel momento in arduino viene eseguita la lettura dei pin
Ottimo, chi se lo ricorda che c'è già per giunta dove, io no.
Quindi reti RC che dovrebbero esserci comunque anche leggendo con analogRead(). Il fatto che legge ogni 10ms mi fa pensare che lo stato dei relay può variare ogni 10ms. Non riesco ad immaginare dei relay che cambiano stato ogni 10ms, manco il tempo per fare contatto stabile.
Ti ringrazio,
ma siccome sono stato tirato in causa vorrei spezzare una lancia in favore di zorkk
non mi sono per nulla offeso, peraltro ho considerato che la persona frustrata dal non riuscire a risolvere il suo problema è lui, non io, posso tranquillamente lasciare che si sfoghi
pertanto io non mi offendo di certo
Che la forza sia con lui
Anzi, a dimostrare la mia buona volontà:
se mette le specifiche complete e chiare di quello che deve fare con che materiale ha a disposizione lo aiuto volentieri (beninteso senza violare la regola del non dare la pappa fatta)
