Consigli per il mio controllore 10ingressi e 10uscite

[dadduni]

Lo stato dell'arte ad oggi è proprio l'opposto, ossia snellire il più possibile l' hardware per delegare il più possibile al software, questo per più ragioni:

- se non c'è non si può rompere: avere meno componenti può statisticametne significare avere meno guasti

- riprogrammabilità: se punti all'HW e ti accorgi di un errore devi dissaldare, ordinare, risaldare. Se fai tutto in SW e ti accorgi di un errore basta cambiare una riga e ricompilare.

- manutenibilità: tra 5 anni chi lo sa se il componente che hai usato è ancora prodotto, invece finché esisterà il codice C quello che hai scritto rimarrà valido

- scalabilità: se ti accorgi che il micro non è sufficientemente potente da gestire tutto il tuo progetto non bisogna ricominciare da capo, ma basta cambiare micro con uno più potente


Come già detto, l'uso di 3 processori può rivelarsi una complicazione assurda dal punto di vista dello sbroglio del PCB, della gestione dei codici, della manutenzione (ogni volta devi ricaricare 3 progetti diversi uno su ogni scheda, non ti auguro mai di debbuggare qualcosa tra 3 mesi) ecc, quando in alternativa puoi avere un solo micro con tutto a bordo.

Pensala così: il tempo che risparmi a disegnare la PCB con 3 processori lo puoi investire nella gestione del codice di uno solo.

Davide

[mariofoll83]

Se si hanno problemi di spazio c'è anche la scheda Arduino compatibile Arduino Mega 2560 Pro della RobotDyn (38 x 55 mm), di cui si trovano i cloni ovunque.

si, ma dovrei inserire la scheda della mega più la meccanica per isolare le uscite e gli ingressi mentre così riesco a stare in un case grosso due terzi di una scheda Mega e che posso montare su guida din, senza avere shield nude con cavi a vista.

La comunicazione tra le schede sarà I2C e ridotta al minimo, le uscite riceveranno solamente il comando di attivare le uscite, e gli ingressi riceveranno la richiesta degli ingressi attivi che hanno registrato e la trasmetteranno.

Non ho capito come semplificheresti il codice in questo modo, l'intelligenza rimarrebbe tutta nel master.

Per il softwere delle uscite poca roba, mentre mi evita di dover usare gli espander per risparmiare pin che non ho e che non ci starebbero nello spazio a disposizione.

Per gli ingressi mi evita di dover interrogare a ogni ciclo i pin dal master che avrà già il suo bel da fare e inoltre mi evita di dover usare gli espander che non ci starebbero (questa avrei anche potuto evitarle ma ho tenuto la stessa linea seguita per le uscite).

E' stata solamente una scelta dettata dalla situazione, avrei potuto scegliere altre strade ma questa mi è sembrata la più conveniente in base alla situazione globale del progetto.

Inizialmente volevo separare addirittura i tre case, ma poi mi sono ricordato di averne uno un po' capiente in casa e per non buttarlo ho cercato di usarlo.

[mariofoll83]

Lo stato dell'arte ad oggi è proprio l'opposto, ossia snellire il più possibile l' hardware per delegare il più possibile al software, questo per più ragioni:

- se non c'è non si può rompere: avere meno componenti può statisticametne significare avere meno guasti

- riprogrammabilità: se punti all'HW e ti accorgi di un errore devi dissaldare, ordinare, risaldare. Se fai tutto in SW e ti accorgi di un errore basta cambiare una riga e ricompilare.

- manutenibilità: tra 5 anni chi lo sa se il componente che hai usato è ancora prodotto, invece finché esisterà il codice C quello che hai scritto rimarrà valido

- scalabilità: se ti accorgi che il micro non è sufficientemente potente da gestire tutto il tuo progetto non bisogna ricominciare da capo, ma basta cambiare micro con uno più potente


Come già detto, l'uso di 3 processori può rivelarsi una complicazione assurda dal punto di vista dello sbroglio del PCB, della gestione dei codici, della manutenzione (ogni volta devi ricaricare 3 progetti diversi uno su ogni scheda, non ti auguro mai di debbuggare qualcosa tra 3 mesi) ecc, quando in alternativa puoi avere un solo micro con tutto a bordo.

Pensala così: il tempo che risparmi a disegnare la PCB con 3 processori lo puoi investire nella gestione del codice di uno solo.

Davide

Mi avete quasi convinto

Infatti lo sbroglio sarà un casino.

Solo, qualcuno ha un link abbastanza chiaro per realizzare un atmega2560 standalone?
Quello che ho trovato non era molto chiaro.

Potrei farmi arrivare assieme alla PCB anche quella del 2560 con i componenti già assemblati quando farò realizzare il tutto.

[GioCosco]

Hai pensato ad utilizzare gli expander MCP23017 e simili ?
Secondo me sono esattamente quello che serve a te senza avere 3 CPU da gestire...
8 ingressi e 8 uscite pilotati direttamente in I2C o SPI
Io li ho usati con successo proprio per una applicazione come la tua: master intelligente, e alcuni slave stupidi a 8 in e 8 out con optoisolatori in ingresso e ULNxxx e rele in uscita
Giorgio

[Jackd]

Mi permetto anche io di sconsigliarti tutti quei pro mini, a meno che tu non abbia esigenze particolari non descritte, in ogni caso per gestire gli ingressi/uscite puo' essere comodamente sostituito con un Expander.

Nel tuo progetto userei l'integrato MCP23S17 che è un Expander da 16 I/0 che funziona in "SPI" .
Lo preferisco alla sua versione "i2c"(MCP23017) sia perché è più veloce e sia perché per ogni linea "SlaveSelect" puo' portare fino ad 8 expander e considerando il numero di pin che vai a liberare sul micro, di possibili linee "SS" ne hai un bel po...

inoltre vista la modularità da guida din che cerchi credo sia la cosa più comoda, anche perché se progetti bene una scheda I/O ti permette con la semplice connessione di 5 fili poter aggiungere altre schede I/O, da alloggiare in altri case da din affiancabili.

L'integrato MCP23X17, sia la versione i2c che spi, ha i 16 piedini divisi in 2 porte, ogni porta fa capo ad un pin Interrupt (volendo si puo' configurare ed usare un solo pin interrupt per entrambe le porte).

Se tu colleghi questo pin "INT" ad un pin con funzione di interrupt del microproccessore (pin 2 e 3 su arduino), tu avrai il vantaggio di non dover stare ad interrogare ad ogni ciclo i valori in ingresso dell'integrato, ma sarà lui stesso ad avvisarti che qualche ingresso è cambiato di stato, per cui è arrivato il momento giusto per leggerlo. Ovviamente dipende dal tipo di comando che hai in ingresso. Se non hai tempistiche critiche puoi farne a meno.

La libreria per gestire questo integrato è molto semplice.
Di seguito un estratto di codice senza interrupt che ho usato in precedenza, dove ho usato un mcp per comodità di sbroglio impostato come:
Porta A tutti gli 8 pin come ingressi
porta B 8 uscite:

Codice: Seleziona tutto

//includo librerie
#include <SPI.h>
#include <MCP23S17.h>

//address valore dei pin 17-16-15
//connesso 17 e 16 a gnd, 15 a vcc, per cui = 001 = 1
MCP inputchip(1, 10); // (addres, SSpin);

void setup(){
inputchip.begin();
 
//numero binario per definire se i pin sono ingressi o uscite
//primo bit (LSB tutto a dx) = GPA0 ovvero primo i/o porta A ; 
//ultimo bit (MSB tutto sx) = GPB7 ovvero ultimo i/o porta B
//1 = ingresso; 0 = uscita
inputchip.pinMode(0B0000000011111111); //1-8 in - 9-16 out

//numero binario per definire se i pin hanno resistenze di Pull-Up,  stessa ratio di pinMode.
//1= resistenza pull-up; 0 = NO resistenza 
inputchip.pullupMode(0B0000000011111111); //1-8 pullup

// comoda impostazione OPZIONALE che si puo' attivare pin per pin, usata quando hai le pullup (interne o esterne)
// forza a restituire il valore "1" quando hai portato a massa il pin al posto del corretto "0" e ovviamente "0" quando dovrebbe essere "1".
// serve solo "lato uomo" per fare meno confusione con i ragionamenti.... (opinabile ma comunque metto per conoscenza) 
inputchip.inputInvert(0B0000000011111111); // 1-8 invert = da 1 quando premo verso massa al posto di 0

//comando le uscite, ad essere a 0.
inputchip.digitalWrite(0B0000000000000000); //forzo tutte uscite a 0

}// fine setup

void loop(){
//leggo mcp23s17
//la variabile ingressi conterrà la lettura di tutti gli ingressi come numero binario
//ingressi = 0bxxxxxxxxxxxxxxxx = B7-B0 A7-A0 

ingressi = inputchip.digitalRead();

//con bitRead estraggo il valore del singolo ingresso
        ingresso1 = bitRead(ingressi, 0);
        ingresso2 = bitRead(ingressi, 1);
        ingresso3 = bitRead(ingressi, 2);
        ingresso4 = bitRead(ingressi, 3);
        ingresso5 = bitRead(ingressi, 4);
        ingresso6 = bitRead(ingressi, 5);
//codice per fare qualcosa in base agli ingressi...
//....
//....

// preparo una variabile, "outBuffer" con lo stato delle uscite che poi andremo ad attivare o spegnere
// per cui scrivo bit per bit, se voglio accendere (1) o spegnere (0) una determinata uscita
// in questo estratto il bit 8 corrisponde fisicamente a GPB0, ovvero la prima uscita della porta B
if (statoUscita1 == true) { 
//se statouscita == true, scrivo sul bit N° 8 di outBuffer il valore 1 ... penso che sia chiaro. 
    bitWrite(outBuffer, 8, 1);
} else {
    bitWrite(outBuffer, 8, 0);
}

if (statoUscita2 == true) {bitWrite(outBuffer, 9, 1);} else {bitWrite(outBuffer, 9, 0);}
//....
if (statoUscita6 == true) {bitWrite(outBuffer, 13, 1);} else {bitWrite(outBuffer, 13, 0);} 
//...

//una volta preparate tutte le uscite controllo se
//se il valore del buffer attuale di uscita è diverso dal buffer vecchio
//per evitare di perdere tempo a scrivere sull'integrato se il buffer non è cambiato
if (outBuffer != outBufferOld){
    //se il buffer attuale è diverso dal vecchio, qualcosa è cambiato, per cui comando la scrittura delle uscite sull'integrato
        inputchip.digitalWrite(outBuffer);
   //e salvo il buffer attuale come vecchio per evitare di riscrivere le uscite se effettivamente non c'è un cambio di stato
        outBufferOld=outBuffer;   
    }
}//fine loop



spero ti possa servire come spunto.

[brabus]

Mi sa che in giro c'è già qualcosa:

https://www.controllino.com/

[MarcoD]

Dal punto di vista estetico e meccanico " controllino " sembra un prodotto allineato con il Mercato.
Dal punto di vista economico, se del tuo controllore prevedi di costruirne e utilizzarne/venderne almeno una decina di esemplari , ti conviene continuare nello sviluppo, altrimenti potresti ridurre i rischi del progetto e comprare "controllino" e concentrarti sui tuoi specifici programmi applicativi.

Però a scopo di diletto e studio, procedi come intendi.
Buono sviluppo

[GioArca67]

Anch'io concordo sull'expander citato e non sui 3 micro.
Perché poi gestirne la comunicazione non sarà una passeggiata.
Inoltre non mi dire che 2 Arduini occupano più spazio di un expander...

[mariofoll83]

Ho già usato gli sn74hc595n come espander, come ingombro con la pro mini sono più compatti, di contro sei vincolato dalla piedinatura nello sbroglio.

Inoltre passa 4mA per canale, devo vedere se poi riesco ad attivare l'optoisolatore sulle uscite.
In passato l'ho usato per attivare la base di un transistor NPN che poi abilitava il 24 V dei relè, ma avevo disturbi sui canali e a volte dava problemi.

Questa volta in ogni caso voglio tenere separate logica e potenza senza dovermi perdere troppo in filtri e altro.

Dovrei provare a comandare l'espander per attivare l'ULN che abilita l'optoisolatore, devo rivedere i datasheet.

[stefanopc]

Nel prototipo precedente dove avevi disturbi e malfunzionamenti cosa comandavi coi rele?
Era realmente montato su una macchina elettrica o il malfunzionamento si verificava anche senza che i relè comandassero qualche carico?
Perché non provi a rendere funzionale il vecchio e dopo aver verificato che tutto va come si deve progetti il nuovo sistema?
Hai lo schema del vecchio prototipo?
Ciao