magari per qualcuno è una cosa elementare, ma non avendolo mai fatto e trovando di tutto a parte quello che ho bisogno in internet, domando qui.
come posso far convertire un dec in hex a 16 bit ad arduino? esempio:
x = 3000 <------> 0BB8
La domanda così esposta non ha senso, per la MCU un numero è un numero la notazione che si usa è in base a cosa occorre fare.
Cosa devi fare? Stampare su monitor seriale? Su LCD? Salvare in EEPROM? Inviare all'esterno?
in sostanza, ho un integrato da controllare
i registri che ha, sono limitati
quindi lui vuole la divisione di 8 bit per ciascuno e il primo bit è 0
io volevo far un indice in dec che si incrementa di +1, poi da dec ogni valore, in hex a 16bit e poi con lowbyte e highbyte mandarlo all’integrato in i2c
quindi, il risultato finale è: 3000 0x0BB8
3000
0x0B low byte
0xB8 high byte
3001
0x0B low byte
0xB9 high byte
Non ho molto capito l'esigenza comunque puoi provare così:
byte buffer[2];
buffer[0] = valueToSend >> 8;
buffer[1] = valueToSend & 0xff;
Wire.write(buffer,2);
che poi corrisponde a
byte buffer[2];
buffer[0] = lowbyte(valueToSend);
buffer[1] = highBytevalueToSend);
Wire.write(buffer,2);
fabpolli:
Non ho molto capito l'esigenza comunque puoi provare così:
Nemmeno io, ma se si parla di traferimenti tipo Wire non servono nemmeno tutti questi passaggi.
Ma infatti secondo me se invia 3000, 3001 ecc. è eqivalente ma non conoscendo l'integrato da controllare magari c'è necessità di inviare due byte distinti. Bho?
No intendevo che se deve usare il metodo write() di Wire, o una classe qualsiasi derivata da Stream può semplicemente fare.
xxx_stream.write((byte*) value, byte_len_of_value);
Ma senza ulteriori chiarimenti stiamo solo speculando 8)
non sono sicuro che cosi funzioni, ti spiego meglio che io chiedo le cose ma non espongo il tutto
praticamente io ho un integrato che fa da radio
il numero in decimale corrisponderebbe alla frequenza, facciamo finta che sia da 2000 fino a 3000
ottimo
integrato ha 16 celle totali divise per 2 (8+8), di cui la prima deve essere 0, se abbiamo 2000
in hex corisponde 0x7D0 a 16 bit 0x07D0<<<<< Quello che mi interessa
poi la prima trasmissione sarà: 0x07
la seconda sarà: 0xD0
e ma mano deve cambiare quei due valori
per dividerli ho visto questo:
https://forum.arduino.cc/index.php?topic=70192.0
per questo domandavo come posso da un dec convertirlo a 16 bit, se vuoi poi dirmi solo come faccio stamparlo su porta seriale del resto mi arrangio io
Ma non facciamo prima se ci dici che integrato è?
gabe_matteo:
per questo domandavo come posso da un dec convertirlo a 16 bit, se vuoi poi dirmi solo come faccio stamparlo su porta seriale del resto mi arrangio io
Continui a non capire. Una variabile int x può contenere una cifra a 16 bit.
Che tu scrivi
int x=3000; // decimale
int y=0x0BB8; // esadecimale
per la macchina è uguale, sempre quella cifra hai scritto. ANZI, per la macchina c'e' scritto 101110111000 in binario
SOLO come rappresentazione a video o parlando tra programmatori si usa poi l'hex per avere la comodità di vedere 4 caratteri dove 2 sono il primo byte e 2 il secondo.
Poi se fai x=x+1; oppure y=y+1; sempre di 1 hai aumentato il valore
Controprova, if(x==y) Serial.println("x è uguale a y");
In generale per inviare dati a byte spezzi la cifra in due come ti hanno detto sopra
certo, ho corretto la parte sopra, 16 tot ma divise per 2 quindi 8 a ciascuna
integrato è TDA6503A
si sapevo che è tutto in binario, ma la mia preoccupazione era per indice, dopo il dividerli era un altro discorso
se un indice va anche con hex, ben venga, il problema non sussiste ed evito passaggi in più
e poi se voglio stamparli a video la frequenza come posso fare inverso eventualmente?
Presumo che i due byte li devi inviare su bus i2c e quindi l'ipotesi di fabpolli sull'uso di Wire era corretta.
Nel link che hai messo tu stesso c'è già la definizione delle macro per l'"estrazione" del low byte e dell'high byte
#define highByte(x) ( (x) >> (8) ) // keep upper 8 bits
#define lowByte(x) ( (x) & (0xff) ) // keep lower 8 bits
int test = 0xABCD; // 16 bits
byte hi, lo; // 8 bits each
hi = HighByte(test); //in case you're wondering this should be 0xAB
lo = LowByte(test); // and this should be 0xCD.
Wire.write(hi);
Wire.write(lo);
si infatti e quello che voglio fare per quello ho messo il link, la mia unica preoccupazione era che non andasse indice con gli hex, voglio far cosi, metto un esempio:
se invece va con incremento di x+, mettero un if che a fine corsa ritorni il valore iniziale, forse più semplice a sto punto
typedef struct
{
uint16_t minimumFreq;
uint16_t maximumFreq;
uint16_t currentFreq;
uint16_t currentStep;
uint8_t currentSSB;
} Band;
Band band[] = {
{520, 2000, 810, 1, LSB},
{3500, 4000, 3700, 1, LSB},
{7000, 7500, 7100, 1, LSB},
{11700, 12000, 11940, 1, USB},
{14000, 14300, 14200, 1, USB},
{18000, 18300, 18100, 1, USB},
{21000, 21400, 21200, 1, USB},
{24890, 25000, 24940, 1, USB},
{27000, 27700, 27300, 1, USB},
{28000, 28500, 28400, 1, USB}};
const int lastBand = (sizeof band / sizeof(Band)) - 1;
// int currentFreqIdx = 9;
int currentFreqIdx = 0;
so benissimo che il compilatore poi e tutto un binario, poco importa a lui
ma dopo se voglio stamparmi a video dove sono con la frequenza? quindi oltre al indice una conversione mi serve lo stesso purtroppo
magari cosi "Controprova, if(x==y) Serial.println("x è uguale a y");" ma quanti if escono per tutti? adesso che mi viene in mente su wire c'è un esempio di conversione anche se in caratteri ci sarà anche per numeri, grazie a tutti per aiuto
gabe_matteo:
si infatti e quello che voglio fare per quello ho messo il link, la mia unica preoccupazione era che non andasse indice con gli hex,
Non importa come tu lo chiami. Per te quello è un indice. Ma currentFreqIdx è pur sempre una variabile int
quindi quello che ti ho scritto sopra vale per QUALSIASI variabile numerica.
nid69ita, ottimo allora, ora che lo so posso star tranquillo e usare gli hex
grazie a te e anche a tutti gli altri
Quando puoi edita il primo post del topic e metti [RISOLTO] nel titolo, così siuti chi in futuro dovesse trovare il post.
Mi viene in mente la divisione in blocchi di 8 bit per la trasmissione dei dati al DDS AD9850 e al ricevitore GPS per impostare la frequenza in uscita (PPS nel caso del GPS)...
for (int n=0; n<4; n++, fCode>>=8) {tx_byte (fCode & 0xFF);}
void invia_freq()
{
freq_free_block4=(freq_free & 0xFF000000)>>24;
freq_free_block3=(freq_free & 0x00FF0000)>>16;
freq_free_block2=(freq_free & 0x0000FF00)>>8;
freq_free_block1= freq_free & 0x000000FF;
...
}
uint16_t HighThreshold = 2400;
byte LoByte = (HighThreshold & 0x00FF);
byte HiByte = ((HighThreshold & 0xFF00) >>8);
void setup() {
Serial.begin(9600);
}
void loop() {
delay(2000);
Serial.println( HiByte);
Serial.println( LoByte);
delay(2000);
}
si è simile Datman, ma credo ci siano delle differenze, dopo non sono esperto, per questo scrivo qui.
non voglio andar contro alla decisione di non convertire il Dec a Hex ecc, ma ho provato esempio nel link, e non andava, ora ho provato cosi, ed neanche farlo apposta e uscito quello che volevo far dall'inizio, che sia hex dec o altro ancora a me interessa spostarmi di frequenza con pulsanti o seriale e sapere dove sono ecc, per il resto non importa come sia il programma anche perché non fa alcuna differenza, metto come risolto allora
grazie ancora a tutti per la disponibilità e accetto pur consigli se ce ne sono, son più che contento di riceverne
Infatti non devi convertire nulla: il numero è quello, scritto in binario all'interno del microcontrollore o visualizzato in decimale con Serial.print o altro. Il punto è che tu devi prendere il numero scritto in binario e dividerlo in byte di 8 bit. Questo si fa applicando una maschera che seleziona solo gli 8 bit che ti interessano di volta in volta.