Ringrazio pippo72 e gpb01 per il loro chiarimento e cerco di rispondere a Standardoil.
Inizialmente, descritto il funzionamento del “protocollo”, chiedevo se esistesse già qualcosa di simile già fatto, testato e funzionante da poter acquistare ( a pochi soldi ) ed utilizzare. Non avendo ricevuto risposte chiare in merito ho cercato di esplicitare meglio cosa volevo ottenere e come io l’ottenevo.
Nel mio ultimo intervento faccio riferimento in modo particolare al “protocollo” di trasmissione/ricezione ( quello che ho chiamato PID ). Non mi sono soffermato tanto sull'hardware ed il software perché sono strettamente legati al protocollo e se questo ha dei possibili problemi che lo rendono inutilizzabile anche l’hardware ed il software divengono inutili. Come già detto Il progetto l’ho realizzato e testato su breadboard e funziona. Purtroppo però questo non basta per dire che è realizzabile e sfruttabile su “larga” scala.
Aspettavo e temevo che qualcuno mi riportasse una o più delle seguenti obiezioni:
- Il sistema è troppo sensibile ai disturbi non essendo i dati tramessi in forma differenziale come ad esempio nella RS-485.
- I picchi di corrente per la carica dei condensatori negli slave porta a notevoli dispersioni di energia su linee di una certa lunghezza e piccola sezione.
- Gli impulsi di alimentazione possono portare a disturbi di tipo elettromagnetico dannosi per appartati di tipo a,b,c. ( lettere casuali )
- La componente continua in linea porta , col passare del tempo, ad ossidazione e riduzione della linea in rame con possibile interruzione dei collegamenti.
Ecc. ecc.
Per quanto riguarda il software non ho problemi a pubblicarlo anche se non ancora giunto ad una versione definitiva. Certo è che come ho descritto questo era pensato per la gestione di una scheda per la remotizzazione di ingressi/uscite per una centrale antiintrusione. Risulta quindi un argomento specifico che non interessa a molti. L’analisi del protocollo si presta invece ad applicazione di uso più generale.
Riporto comunque di seguito alcune funzioni su cui si basa il progetto per quanto riguarda il Master. Come si può vedere il codice risulta banale e si basa in ricezione sulla funzione pulsein.
Master -> Blocco2, Slave -> Blocco3.
unsigned int BaseTempi = 4; // Microsecondi riferimento
unsigned int BaseTempiMax = 100;
unsigned int T_Power = 1000; // Tempo per ricarica condensatore alimentazione blocco 3
unsigned int T_0 = 10 * BaseTempi;
unsigned int T_1 = 20 * BaseTempi;
unsigned int T_2 = 30 * BaseTempi;
unsigned int T_3 = 40 * BaseTempi;
void TX_ImpulsoLibero(int Pin , unsigned int T_Impulso)
{
digitalWrite(Pin, HIGH);
if (T_Impulso<16000)
delayMicroseconds(T_Impulso);
else
delay(T_Impulso/1000);
digitalWrite(Pin, LOW);
}
void TX_ImpulsoPredefinito( int Pin, byte Valore)
{
unsigned int usImpulso;
if (Valore==0)
usImpulso=T_0;
else if (Valore==1)
usImpulso=T_1;
else if (Valore==2)
usImpulso=T_2;
else if (Valore==3)
usImpulso=T_3;
TX_ImpulsoLibero(Pin, usImpulso);
delayMicroseconds(T_Pause);
}
void TX(int Pin ,unsigned int *s, byte N_Bit_Write)
{
unsigned int Dato = *s;
for(int n=0; n < N_Bit_Write; n+=2)
{
byte Valore = bitRead(Dato, n) + 2 * bitRead(Dato, n+1);
TX_ImpulsoPredefinito(Pin,Valore);
}
}
byte TX_Doppio(int Pin ,unsigned int DatoTX, byte N_Bit_Write, bool AttesaEsitoLettura)
{
unsigned int EsitoScrittura = Scrittura_OK;
DatoTX += (DatoTX << 8); // Copia il LSB sul MSB per permettere a blocco 3 di controllare eventuali errori di trasmissione
TX(UscitaDati, &DatoTX, N_Bit_Write); // Trasmette N_Bit_Write bit
if (AttesaEsitoLettura) EsitoLettura = RX(IngressoDati,&EsitoScrittura, 2); //resta in attesa di un segnale in ricezione da Blocco 3
return EsitoScrittura + EsitoLettura << 1 ;
}
byte RX( int Pin, unsigned int *s, byte N_Bit_Read) // Ritorna 0 se riesce a leggere correttamenti i dati
{
boolean EsitoLettura = Lettura_OK;
unsigned int T_Imp=0;
unsigned int DatoRX = 0;
for(byte n=0; n < N_Bit_Read; n+=2)
{
T_Imp = pulseIn(Pin, HIGH, T_Max_Wait);
if (T_Imp == 0)
EsitoLettura = Lettura_KO;
else if (T_Imp > (T_0 - T_Delta_Neg) && T_Imp < (T_0 + T_Delta_Pos))
{
bitWrite(DatoRX, n, 0);
bitWrite(DatoRX, n+1, 0);
}
else if (T_Imp > (T_1 - T_Delta_Neg) && T_Imp < (T_1 + T_Delta_Pos))
{
bitWrite(DatoRX, n, 1);
bitWrite(DatoRX, n+1, 0);
}
else if (T_Imp > (T_2 - T_Delta_Neg) && T_Imp < (T_2 + T_Delta_Pos))
{
bitWrite(DatoRX, n, 0);
bitWrite(DatoRX, n+1, 1);
}
else if (T_Imp > (T_3 - T_Delta_Neg) && T_Imp < (T_3 + T_Delta_Pos))
{
bitWrite(DatoRX, n, 1);
bitWrite(DatoRX, n+1, 1);
}
else
EsitoLettura = Lettura_KO;
}
*s = DatoRX;
DatoRX = 0;
return EsitoLettura;
}
void TX_Power(int Pin)
{
TX_ImpulsoLibero(Pin,T_Power); // Trasmette impulso per alimentazione
delayMicroseconds(T_Pause_Power);
}