Invio Byte per configurare OUTPUT sul server

lollo1100:
perchè comando è Serial.read(); non dovrebbe essere client.read(); i miei 2 Arduino comunicano attraverso l'Ethernet Shield...

Ok. La logica è comunque la stessa, inviare cioè un byte.

cmq non capisco il codice non è che mi puoi dare qualche delucidazione xfavore ? ...leggo intanto i comandi della classe bit almeno provo a capire. Grazie
Stavo rivedendo quello che mi hai scritto solo che in pratica io ho delle maschere fatte così byte maskA[] = {1,0,0,1,0,1,0,1}; ad esempio quindi dovrei per forza inviare gli otto byte che compongono l'array maskA no ? mi sbaglio ? a meno che non modifico il codice sul lato client. Grazie ancora

Scusami, vedo che la gestione dei bit, vedo che non ti è chiara.
Ma che livello hai di conoscenze informatiche? I bit sono la base base dell'informatica :sweat_smile:
Prosegui

Si so cosa è un bit...tranquillo sono un ingegnere Elettronico...io intendo in questo caso specifico ti chiedevo lumi...
poi volevo chiederti una cosa...c'è un metodo di qualche classe che dato un byte maskA = { 0, 1, 0, 1, 1, 1, 0, 0 } mi restituisca il valore esadecimale corrispondente ovvero in questo caso 0x5C grazie ...se esiste un metodo come si chiama io adesso faccio una cosa un pò strana guarda :

byte maskA[] = { 
  0, 0, 0, 0, 0, 1, 0, 0 };    

int maskAA1 = 0;
int maskAA2 = 0;

    for (int i = 0; i < 4; i++){ 
    if ( maskA[i] == 1 )
      maskAA1 += pow( 2, i );
  }
  for (int i = 0; i < 4; i++){ 
    if ( maskA[i] == 1 )
      maskAA2 += pow( 2, i );
  }
  switch (maskAA1){
  case 10 : 
    maskAA1 = 'A'; 
    break;
  case 11 : 
    maskAA1 = 'B'; 
    break;
  case 12 : 
    maskAA1 = 'C'; 
    break;
  case 13 : 
    maskAA1 = 'D'; 
    break;
  case 14 : 
    maskAA1 = 'E'; 
    break;
  case 15 : 
    maskAA1 = 'F'; 
    break;
  }
  switch (maskAA2){
  case 10 : 
    maskAA2 = 'A'; 
    break;
  case 11 : 
    maskAA2 = 'B'; 
    break;
  case 12 : 
    maskAA2 = 'C'; 
    break;
  case 13 : 
    maskAA2 = 'D'; 
    break;
  case 14 : 
    maskAA2 = 'E'; 
    break;
  case 15 : 
    maskAA2 = 'F'; 
    break;
  }

Non che io sappia.

Però continuo a ribadire che non capisco il motivo per cui vuoi perseverare questa strada.
Vediamo se ho capito: vuoi comporre da 8 byte con valore 0/1 2 byte che siano in notazione esadecimale.

Ti chiedo: ma c'è un motivo? Perché complicarsi così tanto la vita? Non riesco a capire questa cosa.
Stai facendo comunicare 2 Arduino, giusto? Quindi il protocollo te lo stabilisci tu. Oppure gli Arduino sono il mezzo di trasmissione di un'informazione che ti arriva in quel formato?

Scusami se rompo ma io tendo solitamente a semplificarmi la vita, non a complicarmela :sweat_smile:

anche io solo che volevo mandare 2 BYTE da 0 a F x ogni Byte... in modo di non mandare gli 8 Byte che compongono quel comando ...tu cosa mi consigli di fare io all'inizo avevo mandato tutta la maskA 8 byte di 0 o 1 e li facevo leggere nel lato server...se oltre alla mask ricevevo un 1 accendevo il led se ricevevo 0 spegnevo il led...però mo tocca farlo in esadecimale fare la conversione lato client e riconvertire nel lato server...tu cosa mi consigli è + veloce la comunicazione mandando solo 2 Byte??? Grazie Leo

No, è più veloce la comunicazione mandando 1 solo byte... te lo sto dicendo fin dall'inizio :wink:

Assegni il bit 0 al pin 2, il bit 1 al pin 3.... il bit 7 al pin 9.
Se ora viene premuto il pulsante sul pin 2, tu assegni il valore 1 al pin 0 del tuo byte:

bitSet(comando, 0);

Adesso il tuo byte comando ha il seguente valore:
0b00000001
Se viene premuto il pulsante sul pin 5, assegni il valore 1 al pin 3 del tuo byte:

bitSet(comando, 3);

Adesso il tuo byte comando vale:
0b00001001

Lo spedisci e dall'altra parte imposti i pin con il codice che ti ho già scritto.
Non è più facile così?

cioè...è quello che faccio io ...io sul lato server ho una maschera sono 8 bit che sono 1 o 0 io gli mando quella poi faccio corrispondenza biunivoca tra i led 2 a 9 e i bit facendo un nuovo byte di led in cui lo 0 sarebbe il led 2 e il 7 il led 9 ...come dovrei scrivere mandando un solo byte sul lato server scusa?...

Dovrebbe fare un client.write e mandare un carattere ascii per fare quello che dici tu Leo.
Il client.print converte tutto in caratteri, quindi spedire 255 per avere dall'altra parte un 11111111 spedisce comunque 3 byte + \n.

io ad esempio spedisco al client

      client.print((String)PINA + "," + (String)PINB + ",");
      client.print((String)PINC + "," + (String)PIND + ",");
      client.print((String)PINE + "," + (String)PING + ",");
      client.print((String)PINH + "," + (String)PINJ + ",");
      client.print((String)PINL + "," + (String)PINF + ",");
      client.print((String)PINK);

per avere lo stato di 70 pin spedisco da minimo 21 a massimo 40 byte dipende dai valori

se volessi usare solo 11 byte dovrei spedire 11 char con client.write e poi fare le conversioni varie (char to byte to bit) ma diventa un delirio.

Spiegati meglio Leo come useresti un client.print o un serial.print

ciao

pablos questa differenza tra client.print e client.write...l'ho colta il mio problema è il seguente ho un maschera 8 byte ...quindi sono 8 0/1...questi dovrebbero essere convertiti in esadecimale quindi da 0 ad F e inviati al server. Quest'ultimo deve leggere o 0 o F e riconvertirlo in binario x capire quali di 8 led come dice Leo i pin da 2 a 9 sono effettivamente output il byte corrispondete è 1, se è 0 il corrispondente pin non è attivo. a quel punto dovrei contemporaneamente a quanto detto inviare ulteriori 2 byte da 00 a FF x determinare il comportamento del LED in questione se è attivo (in base alla maschera precedente). Per la convezione da binario a HEX mi sono avvalso di una conversione binario - decimale a quel punto se il valore è 10 con un case switch attribuivo il carattere A ... se era 11 il B ecct in ricezione (lato server) dovrò fare la cosa opposta ovvero da 0 o F (Ah ovviamente) x fare la conversione ho spedito due mini array da 4 byte l'una quindi un singolo carattere esadecimale alla volta...tornando al discorso server dovrei a partire dal carattere esadecimale ricevuto riempire due mini array da 4 x impostare lo stato dei pin da 2 a 9 ...e poi leggere ulteriori 2 byte x il comportamento dei pin. Grazie a tutti coloro che mi vogliano aiutare

Scusa ma non riesco a capire. Aiutami per favore...

lollo1100:
pablos questa differenza tra client.print e client.write...l'ho colta il mio problema è il seguente ho un maschera 8 byte ...quindi sono 8 0/1...

Hai 1 byte, mi pare di capire.

questi dovrebbero essere convertiti in esadecimale quindi da 0 ad F e inviati al server.

Perché devi convertirli in esadecimale?

Quest'ultimo deve leggere o 0 o F e riconvertirlo in binario x capire quali di 8 led

Perciò se devi riportarli a binario, non puoi spedire direttamente il byte originario?

dice x essere più elastico se volessi controllare il server da un hyper terminal hai qualche suggerimento ? a riguardo

Hai 1 byte, mi pare di capire.

si ho 1 byte la maschera è 1 byte

scusa se volessi convertire da binario a decimale

int maskA1;

byte maskA[] = { 
  0, 0, 0, 0, 0, 1, 0, 0 };                       //  MASK A DEFAULT

  for(int i = 0; i < 8 ; i++){
      if ( maskA[i] == 1 )
      maskA1 += pow( 2, i );
  }

lollo1100:
dice x essere più elastico se volessi controllare il server da un hyper terminal hai qualche suggerimento ? a riguardo

Ecco, ora la cosa mi può anche tornare. Fino ad ora infatti era una conversione senza senso :sweat_smile:

Ecco, ora la cosa mi può anche tornare. Fino ad ora infatti era una conversione senza senso :sweat_smile:

Ha qualche suggerimento? Grazie

Hai 1 byte, mi pare di capire.

si ho 1 byte la maschera è 1 byte

scusa se volessi convertire da binario a decimale

int maskA1;

byte maskA[] = { 
  0, 0, 0, 0, 0, 1, 0, 0 };                       //  MASK A DEFAULT

  for(int i = 0; i < 8 ; i++){
      if ( maskA[i] == 1 )
      maskA1 += pow( 2, i );
  }

// Se tipo qui faccio

if (client.connect(serverA, 23)){
client.write(maskA1);
}

mi dovrebbe inviare il numero decimale associato alla maskA ? o ho detto una stupidaggine? Grazie

Dovrebbe funzionare.

Sull'altra cosa, se vuoi poter inserire la gestione tramite remoto prosegui con la tua idea. Non mi vengono in mente alternative.

secondo me dovresti solo scrivere

client.write(4); // che corrisponde a 00000100, così si che mandi 1 byte

ciao pablos il fatto è che la maschera nel corso del tempo potrebbe cambiare mentre adesso vale 4 in decimale potrebbe valere dopo qualche giorno da configurazione telnet anche 255 quindi deve essere variabile in funzione della maskA espressa in binario...:slight_smile:

volevo chiedere un metodo semplice e veloce x convertire da binario a HEX
io ho trovato questo

sia data byte maskA [8] = { 0,1,1,0,1,1,0,1}
int maskA11;
int maskA12;
char maskA1;
char maskA2;
for (int i = 0; i<4; i++){
if (mask[i]== 1) 
maskA11 = pow (2, i);
}
maskA1 = switchCase(maskA11);
for (int i = 4; i<8; i++){
if (mask[i]== 1) 
maskA12 = pow (2, (i-4));
}
maskA2 = switchCase(maskA12);

dove switchCase è un metodo che accetta come parametro un intero e restituisce il carattere secondo lo switch case dei 16 casi del codice HEX esempio se l'intero è 10 restituisce 'A'.

solo che quando stampo da Telnet quando sono tutti 0 ok quando c'è l'1 mi stampa una cosa variabile è sbagliata pow della libreria math.h oppure l'1 del byte maskA è un char e non è effettivamente l'intero 1? Grazie a tutti coloro che mi vogliano aiutare

lollo1100:
ciao pablos il fatto è che la maschera nel corso del tempo potrebbe cambiare mentre adesso vale 4 in decimale potrebbe valere dopo qualche giorno da configurazione telnet anche 255 quindi deve essere variabile in funzione della maskA espressa in binario...:slight_smile:

volevo chiedere un metodo semplice e veloce x convertire da binario a HEX
io ho trovato questo

sia data byte maskA [8] = { 0,1,1,0,1,1,0,1}

int maskA11;
int maskA12;
char maskA1;
char maskA2;
for (int i = 0; i<4; i++){
if (mask[i]== 1)
maskA11 = pow (2, i);
}
maskA1 = switchCase(maskA11);
for (int i = 4; i<8; i++){
if (mask[i]== 1)
maskA12 = pow (2, (i-4));
}
maskA2 = switchCase(maskA12);




dove switchCase è un metodo che accetta come parametro un intero e restituisce il carattere secondo lo switch case dei 16 casi del codice HEX esempio se l'intero è 10 restituisce 'A'.

solo che quando stampo da Telnet quando sono tutti 0 ok quando c'è l'1 mi stampa una cosa variabile è sbagliata pow della libreria math.h oppure l'1 del byte maskA è un char e non è effettivamente l'intero 1? Grazie a tutti coloro che mi vogliano aiutare

Ho notato che un primo errore può essere qui
if (mask*== 1)*
l'ho sostituito con
if (mask*== '1')*

Un byte è un unsigned char.
Stai attento al confronto che fai perché gli if sono differenti:

if (mask[i]== 1)

Questo controllo dice: se il valore del byte contenuto nella cella "i" dell'array mask è uguale a 1 allora...
Questo controllo invece:

if (mask[i]== '1)

Dice: se il valore del byte contenuto nella cella "i" dell'array mask è uguale al valore del carattere '1' allora...

Sono 2 confronti con 2 valori differenti.
Nel primo caso il test è vero quando il valore è pari a 1, nel secondo quando il valore è pari a 49, che è il codice ASCII di '1'.

PS.
mi son dimenticato una cosa.
La funzione pow() mi pare restituisca un float. Attenzione agli arrotondamenti di questo tipo di dati.

Se vuoi, usa questa funzioncina che mi sono scritto per le potenze con interi:

unsigned long power (unsigned long tempNum, byte tempMul) {
    if (tempMul == 0) {
        return 1; //N^0=1
    }
    unsigned long tempRes = 1;
    while (tempMul) {
        tempRes *= tempNum;
        tempMul--;
    }
    return tempRes;
}

la chiami così:

risultato = power(base, esponente);