Libreria Keypad che forse aziona PULLUP interno su pin estranei alla funzione?

Buon giorno,

Arduno mega 2560: ho implementato nello stesso sketch un tastierino con la libreria Keypad ed un ponte H; separatamente funzionano perfettamente, invece quando assieme la lettura del potenziometro per il ponte H da' risultati errati, ovvero legge zero fino a quasi fine corsa quando comincia a leggere la tensione per fermarsi a circa 500.

Sembra che nella libreria il PULLUP interno della matrice del tastierino si estenda anche ai pin analogici.

Ho provato a cambiare in Keypad.ccp le dimensioni righe colonne impostate a 10 senza ottenere risultati. Ho cercato di individuare Keypad.h la funzione che li attiva, ma non mi è chiaro.

Nello sketch, sezione gestione ponte H, c'è pure la riga "digitalWrite(pinLetturaPotenziometro, LOW)" che ho messo prima della lettura che dovrebbe "staccare il PULLUP interno (se ci fosse), ma legge sempre errato.

Nello sketch non ci sono altre librerie utilizzate.

Ch ne pensate?

Pino_

Penso che se non metti il codice è difficile che qualcuno ti possa aiutare

fratt:
Penso che se non metti il codice è difficile che qualcuno ti possa aiutare

Giustissimo:
questo è la definizione dei pin:

int uno_a=22; int uno_b=23;
int due_a=24; int due_b=25;
int tre_a=26; int tre_b=27;
int quattro_a=28; int quattro_b=29;
int cinque_a=30; int cinque_b=31;
int sei_a=32; int sei_b=33;
int sette_a=34; int sette_b=35;
int otto_a=36; int otto_b=37;
int nove_a=38; int nove_b=39;

int led_uno_a=40; int led_uno_b=41;
int led_due_a=42; int led_due_b=43;
int led_tre_a=44; int led_tre_b=45;
int led_quattro_a=46; int led_quattro_b=47;
int led_cinque_a=48; int led_cinque_b=49;
int led_sei_a=50; int led_sei_b=51;
int led_sette_a=52; int led_sette_b=53;
int led_otto_a=54; int led_otto_b=55;
int led_nove_a=56; int led_nove_b=57

questo è il setup dei pin:

  pinMode(uno_a, OUTPUT);pinMode(uno_b, OUTPUT);pinMode(due_a, OUTPUT);pinMode(due_b, OUTPUT);pinMode(tre_a, OUTPUT);
  pinMode(tre_a, OUTPUT);pinMode(tre_b, OUTPUT);pinMode(quattro_a, OUTPUT);pinMode(quattro_b, OUTPUT);pinMode(cinque_a, OUTPUT);
  pinMode(sei_a, OUTPUT);pinMode(sei_b, OUTPUT);pinMode(sette_a, OUTPUT);pinMode(sette_b, OUTPUT);pinMode(otto_a, OUTPUT);
  pinMode(otto_b, OUTPUT);pinMode(nove_a, OUTPUT);pinMode(nove_b, OUTPUT);

digitalWrite(uno_a, LOW);digitalWrite(uno_b, LOW);digitalWrite(due_a, LOW);digitalWrite(due_b, LOW);digitalWrite(tre_a, LOW);
digitalWrite(tre_b, LOW);digitalWrite(quattro_a, LOW);digitalWrite(quattro_b, LOW);digitalWrite(cinque_a, LOW);
digitalWrite(cinque_b, LOW);digitalWrite(sei_a, LOW);digitalWrite(sei_b, LOW);digitalWrite(sette_a, LOW);digitalWrite(sette_b, LOW);
digitalWrite(otto_a, LOW);digitalWrite(otto_b, LOW);digitalWrite(nove_a, LOW);digitalWrite(nove_b, LOW);

************************************************************

  pinMode(led_uno_a, OUTPUT);pinMode(led_uno_b, OUTPUT);pinMode(led_due_a, OUTPUT);pinMode(led_due_b, OUTPUT);
  pinMode(led_tre_a, OUTPUT);pinMode(led_tre_b, OUTPUT);pinMode(led_quattro_a, OUTPUT);pinMode(led_quattro_b, OUTPUT);
  pinMode(led_cinque_a, OUTPUT);pinMode(led_cinque_b, OUTPUT);pinMode(led_sei_a, OUTPUT);pinMode(led_sei_b, OUTPUT);
  pinMode(led_sette_a, OUTPUT);pinMode(led_sette_b, OUTPUT);  pinMode(led_otto_a, OUTPUT);  pinMode(led_otto_b, OUTPUT);

digitalWrite(led_uno_a, LOW);digitalWrite(led_uno_b, LOW);digitalWrite(led_due_a, LOW);digitalWrite(led_due_b, LOW);
digitalWrite(led_tre_a, LOW);digitalWrite(led_tre_b, LOW);digitalWrite(led_quattro_a, LOW);digitalWrite(led_quattro_b, LOW);
digitalWrite(led_cinque_a, LOW);digitalWrite(led_cinque_b, LOW);digitalWrite(led_sei_a, LOW);digitalWrite(led_sei_b, LOW);
digitalWrite(led_sette_a, LOW);digitalWrite(led_sette_b, LOW);digitalWrite(led_otto_a, LOW);digitalWrite(led_otto_b, LOW);
digitalWrite(led_nove_a, LOW);digitalWrite(led_nove_b, LOW);digitalWrite(led_nove_a, LOW);
 
**********************************

nel frattempo ho notato che se tolgo la parte relativa al gruppo di pin "led_uno_a" ecc., che ho racchiuso tra le due righe di astersischi (solo qui!), la funzione int x = analogRead(A0); da' risultati corretti, se la inserisco non funziona più correttamente.

Ho provato senza successo anche ad assegnare i pin con #define

il pin analogico è definito con: static int pinDirezioneMarcia = A0;

Spero che basti ... il codice è abbastanza lungo e disordinato.

Pino_

Stai usando come digitali pure gli analogici

Non te ne sei accorto durante il cablaggio?

Ma cosa stai facendo per aver così tanta fame di pin?

Standardoil:
Stai usando come digitali pure gli analogici

Non te ne sei accorto durante il cablaggio?

Ma cosa stai facendo per aver così tanta fame di pin?

Esatto non dovevo usare dal 54 al 57 ... appena visto un momento fa' ...

I pin non li ho cablati tutti, per prova ne ho cablato sulla breaddboard una decina!

Comunque siccome devono solo accendere alcuni led e mandare impulsi da 10 msec, vanno bene anche gli analogici.

La fame di pin? Beh, è semplice: comandare un piccolo plastico ferromodellistico con 9 scambi e alimentare i binari con un ponte H in PWM; lo faccio per un amico che però non vuol sentir parlare di digitale e tantomeno di wifi blutooth e company, quando gli ho fatto vedere che il tutto sarebbe comandabile da smartphone a momenti vomitava. :slight_smile:

Un tastierino comanda gli cambi; toggli il tasto 1, per dire, e un led bicolore si accende verde o rosso a seconda della direzione e contemporaneamente invia un robusto impulso a 12/14 Volt lungo 10 msec che aziona lo scambio 1; in tutto quindi 4 pin per scambio x 9 in uscita, poi i sette del tastierino in antrata ed i quattro del ponte H.

Pensavo di recuperare un mega che forse non è deceduto completamente causa averlo alimentato a 12 V sul pin dell'uscita dei 5 Volt, ci spero (mi pare che un po' di fumo si alzò dalla zona della presa USB, chiaramente non si connette ed è in stato comato-luminoso di immobile rassegnazione, magari si lascierà programmare dall'altro lato). Le prove le sto facendo con un mega sano. Fare lo stampato sarà una bellezza.

Pino_

Capisco

Ma secondo me puoi semplificare

I led ad esempio, non richiedono 2 uscite per scambio, ma solo una, alta accende un led al meno, bassa accende un led al più

Anche il comando fisico dello scambio forse si può semplificare
L'impulso da dare è sempre nello stesso verso?

Inoltre, data la complessità e l'importanza del lavoro, io penserei a passare ad una programmazione più strutturata
Almeno degli array di pin per i led e degli array di pin per gli scambi e uno per gli ingressi
Ma possibilmente un array di struct descrittive dello scambio nella sua interezza: ingressi e uscite

Sicuramente posso semplificare:

LED:
i led bicolore che ho nel cassetto hanno catodo comune, lo scambio tra 9 piste a fronte di 9 transistors e 9 resistenze nel mio caso è vataggioso in quanto avevo già previsto uno circuito stampato separato dedicato ai led per la migliore collocazione sul pannellino sinottico e li ci stanno comodi 9 transistor e 36 resistenze, quindi ti ringrazio del suggerimento a cui non avevo pensato prima di scoprire che avevo toppato i pin (sono tanti mi ero detto e una volta che il Mega è dentro il box che me me faccio di pin inutilizzati?).

BOBINE DEGLI SCAMBI:
le bobine degli scambi sono a risucchio di una piccola massa, quindi non polarizzate, con tre fili: un comune e due per le bobine; leggendo sul web questo tipo di motore per gli scambi è fatto per funzionare con una scarica di un condensatore; l'amico pensava di utilizzare un deviatore meccanico però se avesse il ritorno al centro automatico sarebbe stato meglio per evitare sicure fumate in caso di dimenticanza su una posizione, ed allora mi ha chiesto consiglio per trovare il deviatore migliore tra costo e funzionalità.
la mia soluzione è quella che ho già descritto e funziona benissimo, certo comporta 18 mosfet smd tipo FDD5690 e la soluzione con Arduino permette di regolare esattamente il tempo dell'impulso (nella fatispecie 5 ms lo scambio si muove appena, con 8 ms funziano con una certa pigrizia, con 10 ms è secco senza se e senza ma, inoltre poi se la resistenza del cablaggio definitivo sale si può sempre aumentare o decidere di utilizzare la tensione prevista per questi scambi che non è 12 Volt, ma 14.
Inoltre si possono azionare in automatico coppie di scambi per in "controfase" tra due binari (uno verde e l'altro rosso o viceversa.

PROGRAMMAZIONE STRUTTURATA ED ARRAY:
Sacrosanto ma se io volessi farlo farei volentieri la grossa fatica di superare il mio livello di programmatore che è del tipo "programmo (=mangio) come parlo" però così, a parte il tempo scarso che ho, voglio che il mio amico, di comprendonio certificato tutt'altro che scarso, sebbene molto distante da queste problematiche, capisca come funziona la cosa leggendo il programma, quindi un programma lineare e pedissequamente banale, forse lo porterà sulla mia strada di riempire i cassetti di Arduini oltre agli enne accessori del ferromodellismo.

Grazie! :slight_smile:

Pino_

Aspetta che sono al mare

Sulla strada per il ritorno al lago
Sono sempre in ferie perché...
Troppo complicato, non lo vuoi sapere...

Ma le bobine vanno anche in ac?

OK, a casa

domandona: ma le bobine vanno anche in AC?

domandona due e mezzo, la vendetta: hai un esempio di comando a scarica di condensatore?

altra cosa: anche se non ti serviranno mai più, è sempre bene studiare come ridurre il consumo di memoria, pin e altre risorse: fa esperienza per il futuro.

capisco la questione della programmazione strutturata, specialmente in rapporto con terzi che non conoscono il C, ma credimi che a parte il risparmiarci tempo e fatica a scriverla strutturata invece che Idiot-Friendly

(non me ne vogliate con questa nuova definizione, non è un giudizio sulle persone)

dicevo, al costo di una leggera complicazione comporta talmente tanti vantaggi in scrittura, debug e modifica di un programma che nemmeno si pone la questione: "ora e sempre strutturata"

ok, rileggendo bene le tue parole, è abbastanza chiaro che le bobine non vanno in AC, comunque fai un controllo, sarebbe cosa ghiotta se andassero in AC

io credo che il tutto si possa facilmente ridurre a un pin per scambio, intendo sia la segnalazione che il comando (anche temporizzato se servisse) serve solo di sapere le caratteristiche delle bobine dei deviatoi
senza nemmeno tanti mosfet; a proposito, hai previsto il diodo in antiparallelo, vero? che le bobine sono molto induttive

poi vedi tu, anche l'approccio del tipo "a me funziona, a me mi basta e squadra che vince non si cambia" ha la sua valenza, in linea di principio io dico sempre che su 10 persone ci sono almeno 11 differenti idee; perché uno che cambia idea lo troviamo di certo, quindi accetterei la cosa

Non vedo impedimenti al funzionamento AC.

Non ero riuscito a trovare schemi specifici per il comando a scarica capacitiva degli scambi, ma avevo pensato come fare: un circuitino con un oscillatore minimo tipo quello dei flash delle fotocamere, che carica una consensatore a bassa perdita proporzionato, tipo poliestere o meglio; raggiunta la carica a tot Volt l’oscillatore si blocca ma la tensione è presente su un “common rail” positivo; il comando dal micro fa scattare un scr, o un mosfet che scarica la capacità sulla linea dello scambio che ne fa richiesta; l’oscillatore ricomincia a funzionare, ecc.

Mi hai messo una pulce nell’orecchio circa la ghiottoneria per il funzionamento in AC degli scambi …

Su tutto il resto sono molto interessato, ma non ora, dopo fine settembre ho in mente di realizzare un progetto veramente impegnativo per me.

Naturale che ho messo il diodo di protezione …

Pino_

>Pino_: Quando si quota un post, NON è necessario riportarlo (inutilmente) tutto; bastano poche righe per far capire di cosa si parla ed a cosa ci si riferisce, inoltre, se si risponde al post immediatamente precedente, normalmente NON è necessario alcun "quote" dato che è sottinteso. :slight_smile:

Gli utenti da device "mobile" (piccoli schermi) ringrazieranno per la cortesia :wink:

Guglielmo

P.S.: Ho eliminato io il "quote" dal tuo post qui sopra :wink:

col pestifero nipote, in auto

(non è lo stesso mare dove sono stato settimana scorsa in treno, nemmeno il lago dove andrò domani è lo stesso dove abito, ma non serve di capire la mia complicata vita, non ci riesco nemmeno io)

dicevo, in auto col pestifero nipote ne abbiamo parlato

e abbiamo trovato la maniera per comandare un deviatoio e i suoi led con un solo pin di arduino
[ EDIT ]
Per quanto avere almeno nove led alimentati da arduino forse è un po' troppo
Serve calcolare bene le correnti

O come alternativa usare uno shift register

Che permetterebbe di usare anche solo una UNO invece di una MEGA
[ /EDIT]
ma adesso attacca montalbano e sono stanco morto

domani lo descrivo bene bene e ne faccio anche uno schizzo

spero che non ti spiaccia se lo cito nel mio
la pappa è fatta

credo possa essere utile

gpb01:
>Pino_: Quando si quota un post

Non lo sapessi, ma lo so, l'ho letto decine di volte ... mi è fuggito!

Credo che il robot che ti scova i quote esagerati si chiami "Santa pazienza" ...

Pino_

Standardoil:
credo possa essere utile

Senz'altro, tutto è utile, ma:

al cospetto di un Attiny85 è bello sapere che 6 pin sono invero tanti :slight_smile:
al cospetto di un Mega non è bello sapere così tanti pin tracurati con pervicacia :slight_smile:

Al massimo il consumo led peggiore è tutti i nove sul verde e lì per ogni verde serve quasi 10 mA (per avere la luminosità simile col rosso bastano circa 5 mA; al massimo quindi 90 mA + pochi altri mA per il micro e gli altri carichi peraltro ad alta impedenza (c'è un picco di corrente di qualche ns per "riempire" la capacità d'ingresso di qualche mosfet quando commuta in accensione, circa 1000 pF, poca roba).

Gli shift register li avevo scartati a priori, ho solo shift trentennali della serie 74xxx di recupero, dovrei farmeli arrivare ...

Quando ho pensato questa cosa vedevo lo sviluppo futuro con un sistema dove i binari sono CA costante e tutto il resto a bordo delle locomotive compreso il raddrizzamento e in locale per gli scambi. Ma è prematuro.

Pino_

Il mio "credo possa essere utile" non era riferito direttamente a te

Intendevo che sarà utile averlo nel mio "la pappa è fatta"
Per future consultazioni di (futuri) membri

come promesso ieri vediamo un po' come si potrebbe comandare un modellino di deviatoio (scambio ferroviario), di quelli a due bobine per AC (15 o 24V ac, per fugare ogni dubbio sulla sicurezza)
il tutto con solo un pin di arduino, settato come uscita:

se il pin è alto si accende un led (chesso', rosso) e per un breve tempo si ha passaggio di corrente in una delle due bobine: sottinteso che si tratterà della bobina che aziona il deviatoio nella direzione coerente con la luce del led

altrimenti, per pin basso si accende un altro led (chesso' verde) e per un breve periodo si aziona la bobina corrispondente

premessa: io non ho plasici del trenino, e non ho nemmeno molto HW, pur se almeno una NodeMCU e una UNO me li farò "regalare indietro" da chi si è impossessato di tutto il mio materiale durante il mio "tragisloco" (tragico trasloco)

quindi non posso provare, ma ho buone speranze che il tutto vada bene, una volta creato

cominciamo da una situazione standard, per accendere alternativamente due led da un pin

semidevio1.jpg

se il pin di uscita fosse alto esso fornirebbe corrente a 5V e si accenderebbe il led in basso, con una luminosità regolata dalla sua resistenza
se invece il pin di uscita fosse basso esso si comporterebbe come un "lavandino di corrente" (current sink in inglese), ovvero assorbirebbe a massa la corrente che dal + passa per il led superiore, regolata dalla sua resistenza

da qui possiamo vedere che essendo lo scambio sempre o da una parte o dall'altra (mi sembra si dica ramo tracciato o ramo deviato)
dicevo, essendo sempre o in T o in D uno dei due led deve essere sempre acceso, si tratterà quindi di cablare i led in maniera "congrua" con il tracciato

rimane da vedere come dare un (breve) impulso alla bobina per far intervenire il meccanismo del deviatoio

mi risulta che esiste una tipologia di deviatoi che hanno due bobine comandabili in AC (e vedremo che questo è cruciale) che si azionano dando corrente ad una o all'altra delle bobine che effettueranno il movimento, dopo un poco (alcuni decimi di secondo) si potrà interrompere l'alimentazione, sia per risparmare corrente sia perché le bobine non sono adatte ad usi continuativi

la maniera migliore per avere un impulso di breve durata al "cambio" di una condizione è usare la corrente di carica di un condensatore
che alimenterà un opto-qualcosa
fortunatamente essendo le bobine in AC potremo utilizzare un opto-triac, che con poco spazio e poca spesa permette di comandare anche forti correnti
ecco quindi la prima idea di circuito:
semidevio2.jpg

il problema rimane all'azionamento inverso, a quel punto la corrente di "scarica" del condensatore non passerebbe per il led del opto-triac (che sarebbe polarizzato inversamente) e basta, giochetto finito: non va più nulla, e anche se andasse sarebbe la bobina sbagliata a lavorare

ecco quindi il circuito completo


dove le due correnti: di carica o di scarica del condensatore, percorrono due differenti led interni a due differenti opto-triac, che comandano ciascuno la sua bobina
e quindi all'azionamento per esempio uscita alta si accende un led e fino alla completa carica del condensatore una corrente attiva l'opto-triac corrispondente
allo scambio con uscita bassa abbiamo che si spegne un led, se ne accende un altro e il condensatore si scarica con una corrente che interessa un altro opto-triac, che fino alla completa scarica del condensatore tiene attiva la sua bobina

e con questo rimane da calcolare un po' di valori: condensatore e resistenza in serie tipicamente

e qui sono sicuro che chi sarà interessato alla realizzazione avrà occasione di dimostrare la sua buona volontà

semidevio1.jpg

semidevio2.jpg

Quanta corrente può dare in uscita il microcontrollore del Mega?...
Uhmm... 20mA continui, 40mA massimi assoluti, 200mA massimi assoluti in totale. Con LED sensibili (anche cinesi) già 2mA dovrebbero dare una luce notevole.

Metterei due transistor (o mosfet logic level) in push-pull, che pilotano i LED come negli schemi sopra e un bel condensatore elettrolitico che pilota le due bobine attraverso due diodi collegati in versi opposti.

Datman:
Metterei due transistor ....

per bobine in DC concordo, anche se la vedo più semplice mettere un relay a scambio, regge correnti certamente superiori, ma qui ricadiamo nei circuiti già citati per le elettrovalvole bistabili un mesetto fa

per una singola bobina in DC polarizzata si eliminano i due diodi
per bobine in AC invece rimangono gli opto-triac

domanda, ma tu hai un laboratorietto e voglia di provare?

perché io no laboratorio, ma un paio di idee "strane" da provare le avrei...

Pino_:
questo è la definizione dei pin:

int uno_a=22; int uno_b=23;

...

Quale vantaggio porta "sprecare" RAM per definire dei PIN che rimarranno invariati per tutta l'esecuzione dello sketch?