Ho surfato un po' su google per farmi una cultura, però mi chiedo: con tre celle di carico conviene collegarle tutte ad un solo Hx711 oppure è meglio avere tre amplificatori e leggere su tre ingressi?
Grazie in anticipo.
Il HX711 ha 2 entrate ma con diversi amplificazioni. Non sono equivalenti.
Cosa vorresti misurare? La somma delle forze esercitate sulle 3 celle? Dovresti poter mettere le 3 celle in paralello e misurare la somma delle forze.
Ciao Uwe
Ho visto che si possono mettere in parallelo ma non sapevo se più di due celle diminuissero troppo la resistenza, quindi non ho provato, anche perché ne ho solo due in casa.
Domani provo con due e, se funziona, mi aspetto che con tre sia la stessa cosa, a parte la formula che dovrò ottenere.
Effettivamente 2 celle di carico in parallelo funzionano egregiamente. @uwefed preferivo avere l'amplificazione massima, per cui non posso usare il secondo ingresso che mi limiterebbe.
Adesso mi rimane da convertire il valore float peso in 24 bit singoli e poi spedirli su due uscite di arduino (una di CLK e una di DATA, simulando il protocollo HX711) ad un PLC...
E qui ho bisogno delle grandi menti perché io non ci arrivo : come converto il dato (peso) in 24 singoli bit?
Poi come lo spedisco, bit per bit, ad una uscita col ciclo for è praticamente fatto.
Pensavo ad un array, però è il float che devo spezzattare in 24 bit che mi frena...
Mah, molto banalmente, usa una "union" e mappa nei stessi quattro bytes sia il float che un unsigned long, sul quale, poi, con una semplice for, recuperi un bit per volta 
Guglielmo
Ti ringrazio molto, Guglielmo, ma, banalmente, non ho la minima idea di cosa sia union, anche se sono andato in giro a vedere cos'è. Come sai, non sono un "profondo" conoscitore del C.....
Giusto per capirci, così non faccio la figura di quello che vuole la pappa pronta, ho provato a leggere una cella di carico con HX711 attraverso un PLC che, come sai, non sono dei "fulmini di guerra".
Quindi leggo la HX711 e, dopo aver letto come funziona il suo semplicissimo protocollo, ritrasmetto i dati al PLC.
void setup() {
pinMode(0, OUTPUT); /* SCK */
pinMode(1, INPUT); /* DATA */
pinMode(2, OUTPUT); /* To PLC X000 clk */
pinMode(3, OUTPUT); /* To PLC X001 data
PLC side with NEGATIVE input (led ON with 0 volt) -
With POSITIVE input, replace 3 (!data) with (data) and (2, LOW) with (2, HIGH).... */
digitalWrite (0, LOW);
}
void loop() {
if (digitalRead (1) == LOW) {
for (int i = 0; i <= 23; i++) {
digitalWrite (0, HIGH); /* SCK */
int data = digitalRead (1); /* DATA */
digitalWrite (0, LOW); /* SCK */
digitalWrite (3, bool (!data));/* To PLC X001 data */
digitalWrite (2, LOW);/* To PLC X000 clk */
delay (11);
digitalWrite (2, HIGH);/* To PLC X000 clk */
delay (11);
}
digitalWrite (0, HIGH); /*IMPULSO SU SCK */
digitalWrite (0, LOW);
delay (25);
}
}
Semplicissimo, a parte che devo giocare con le temporizzazioni:se troppo corte il PLC perde i bit, se troppo lunghe la schedina HX711 va in Shut Down....
Così funziona, ma ogni venti o venticinque letture mi esce un numero "strano" che mi falsa il programma. Lo so, potrei fare una media delle letture ma se sono in "carico" è normale che il peso si muova verso l'alto e se sono in "scarico" il peso si muove verso il basso. Quindi, a meno di fare qualche riga che mi scarti i valori fuori da un certo "range" intorno alla lettura attuale, diciamo che la cosa non mi piace.
Se leggo da Arduino, invece, la lettura è perfetta sempre.
Allora pensavo: leggo il valore peso da Arduino...
void loop() {
scale.set_scale(calibration_factor); //Adjust to this calibration factor
Serial.print("Reading: ");
Serial.print(scale.get_units(), 3);
Serial.print(" kg"); //Change this to kg and re-adjust the calibration factor if you follow SI units like a sane person
Serial.print(" calibration_factor: ");
Serial.print(calibration_factor);
Serial.println();
poi lo scompongo e poi lo ritrasmetto al PLC bit per bit e da li lo ricompongo.
E adesso mi viene pure in mente che i 24 bit li sto già leggendo col programma precedente quindi, magari, li leggo tutti in fila e poi, con calma, li ritrasmetto...
La "union" è un modo di definire la stessa area di memoria condivisa da variabili diverse (... ovvero, vedere un certo spazio in modi diversi) ...
union miaUnion {
float mioFloat;
unsigned long mioLong;
} mieiValori;
... in questo modo hai creato una "union" dicendo che è di tipo "miaUnion" e hai definito uno spazio di memoria di nome "mieiValori" in cui la variabile di tipo float (4 bytes) "mioFloat" condivide la memoria con la variabile di tipo unsigned long (sempre 4 bytes) "mioLong".
Per scrivere in "mioFloat" devi specificare che è dentro la union di nome "mieiValori" e lo fai con la sintassi:
mieiValori.mioFloat = 1.5;
... in questo modo hai si scritto in "mioFloat" il valore float 1.5, ma dato che lo spazio è lo stesso che occupa "mioLong", in "mioLong" hai i bit impostati esattamente come sono in mioFloat e quindi puoi accedere a tutti i bit. 
Più chiaro così ?
Guglielmo
Chiarissimo, sempre esaustivo !
Nel frattempo mi è scappato l'occhio sul programma di prima e, fidandomi della velocità di Arduino, credevo che la variabile 'data' fosse già pronta per la trasmissione quando comunicavo al PLC di leggerla...
digitalWrite (3, bool (!data));// To PLC X001 data
digitalWrite (2, LOW);// To PLC X000 clk
delay (11);
digitalWrite (2, HIGH);// To PLC X000 clk
delay (11);
E INVECE MI SBAGLIAVO !!!
digitalWrite (3, bool (!data));// To PLC X001 data
delay (1);
digitalWrite (2, LOW);// To PLC X000 clk
delay (11);
digitalWrite (2, HIGH);// To PLC X000 clk
delay (11);
bastava un MILLISECONDO. Praticamente ALCUNE VOLTE il PLC leggeva un dato sull'uscita di Arduino che non era ancora pronto! Ma sembra che il PLC fosse più "pronto" di lui !
Tanto è vero che leggo correttamente anche con queste temporizzazioni:
digitalWrite (3, bool (!data));// To PLC X001 data
delay (1);
digitalWrite (2, LOW);// To PLC X000 clk
delay (2);
digitalWrite (2, HIGH);// To PLC X000 clk
delay (2);
E la cosa, onestamente, mi sorprende e mi esalta. Anche perchè è un CLONE Mitsubishi, modello FX3u, però realizzato con un processore ARM e questa velocità di lettura non l'avevo raggiunta con l'originale...
P.S. il tutto, naturalmente, passa da una schedina da me realizzata per innalzare i livelli TTL ai livelli PLC (24Vcc) e viceversa.