Arduino hexadecimale data over serial.

[jctjepkema]

Beste,

Ik ben momenteel bezig met een apparaat wat over uart word aangestuurt doormiddel van hexadecimale commando's. Hiermee zit ik met het volgende probleem, ik ontvang een aantal seriele commando;s, om te beginnen 26 75. De bedoeling is dat de arduino dan met 00(0x00) antwoord.
Ik krijg dit echter niet voor elkaar, ik kwam zo ver dat hij op een gegeven moment de data wel ontvangt, maar ik krijg het niet verwerkt.
Op google word ik ook niet veel wijzer, waarmee ik zoek kom ik veel al op ascii tabellen uit en dergelijke, terwijl het naar mijn idee helemaal niet nodig zou moeten zijn om om te zetten naar ascii.

Mijn vraag aan jullie is, hoe kan ik de data ontvangen en hoe kan ik het vervolgens het beste verwerken?
Ik dacht zelf ik ontvang het plaats het in een array vergelijk byte voor byte en wanneer dat klopt wis ik de array en stuur ik het juiste antwoord terug.
Ik kom er alleen bij het begin niet uit en dat is hoe moet ik het verwerken naar een array, weten jullie misschien een linkje waar dat duidelijk word uitgelegd?

Handig om te weten, het apparaat stuurt pas weer een commando tot hij antwoord heeft gehad op zijn vorige.

M.v.g. jctjepkema

[Pizza_Boom]

Jij ziet het als hexadecimaal, feitelijk wordt er gewoon een binaire code verstuurd.

Hoe wil je dit uitlezen? En hoe weet je zo zeker dat de Arduino het ook daadwerkelijk binnen krijgt? Welke aanwijzingen heb je daarvoor?

[Fusioxan]

In de Arduino IDE zit bij de examples genoeg voorbeelden voor seriële communicatie. Je kan er een switch inzetten die de juiste waarde terug stuurt. Althans, ik maak dat op vanuit je verhaal.

En zoals Pizza_Boom het ook al zegt: het is gewoon een getal, maar dan in een andere notatie.

[ Voor 36% gewijzigd door Fusioxan op 18-09-2015 22:33 ]

[jctjepkema]

Ik weet dat ik ze binnen krijg aangezien de arduino ide ze weergeeft als een ascii letter, en termite ze in hexview weergeeft als een hexadecimaal getal. In eerste instantie wil ik deze hexadecimale waarde opslaan in een array, alleen dat krijg ik niet voor elkaar aangezien bijna ieder voorbeeld een ascii waarde gebruikt. Maar een 0x00 word weergegeven in ascii als een . Maar wanneer ik deze . Stuur vanuit de arduino stuurt deze een hexadecimaal getal dat niet gelijk is aan 0x00.

Uit eindelijk wil ik een reeks bytes plaatsen in een array, deze array vergelijken en wanneer het "klopt" het juiste antwoord versturen, maar de eerste stap het plaatsen van de bytes in de array krijg ik niet voor elkaar! Hebben jullie een idee/link?

[craio]

char vervangen door byte?
Mogelijks kan je huidige code tonen helpen.

[Vuikie]

Ik denk dat je 2 dingen door elkaar haalt

C:

char CharArray[] = "0x00";

is niet 4 maar 5 chars groot, nl: 0, x, 0, 0, \0 (Dit wordt in C zero termination genoemd)

C:

byte ReturnByte = 0x00;

is 1 byte groot en bevat de waarde 0

In c moet je heel goed opletten tussen chars en 'gewone' waarden. Misschien gebruik je een functie die chars omzet naar een hexadecimale waarde. Daarom sluit ik mij aan bij craio, laat je code eens zien, dan kunnen we pas goed beoordelen wat er mis gaat.

[ Voor 7% gewijzigd door Vuikie op 19-09-2015 14:28 . Reden: LOL s /s werkt niet op een 4, streep valt weg in char. ]

[Sissors]

Bijna: Die eerste is 5 bytes groot: 0, x, 0, 0 en \0. (om duidelijk te maken dat dat de laatste byte is).

[ Voor 4% gewijzigd door Sissors op 19-09-2015 11:58 ]

[Vuikie]

Sissors schreef op zaterdag 19 september 2015 @ 11:58:
Bijna: Die eerste is 5 bytes groot: 0, x, 0, 0 en \0. (om duidelijk te maken dat dat de laatste byte is).

idd, zero temination hoort er ook bij, maar dat zie je eigenlijk niet terug.

Nu ik er zo aan denk, zou dat niet het probleem kunnen zijn? Als er een byte met waarde 0 terug gestuurd moet worden(Wat ik sowieso al een beetje vreemd vind, maar dat is persoonlijk) dat een functie als Serial.write(val) dit verkeerd ziet als 'einde string' en je daarom eigenlijk Serial.write(buf, len) zou moeten gebruiken. Het zou eigenlijk niet moeten, dat weet ik, want je geeft een (val) op en geen (str), dus de overload zou goed moeten gaan. Maar dit zou een bug kunnen zijn.

Hmm, maar even afwachten wat jctjepkema als code gebruikt en kijken of dat niet het probleem is.

[ Voor 10% gewijzigd door Vuikie op 19-09-2015 14:32 ]

[jctjepkema]

Beste iedereen, bedankt alvast voor de snelle antwoorden!
Ik moest overdag werken, dus vandaar dat ik nu pas mijn code post:
Het begint eigenlijk vrij snel, ik kom er volgens mij bij een hele simpele functie niet uit!

C: arduino code

int commandStartIn[]   = {0x26, 0x75};
int commandStartOut[]  = {0x00}
int command1In[]      = {0x70,0xf0,0xf1,0xf3,0xf2,0xf4,0xf6,0xfa,0xfb,0x71,0x01};
int command1Out[]     = {0x70,0xf0,0x01,0xf1,0xf2d,0x22,0xf3,0x00,0xf2,0xd3,0xf4,0x80,0xf6,0x05,0xfa,0x62,0xfb,0x80,0x71,0x01};
int command2In[]      = {0x65,0x00,0xfa,0xfb};
int command2Out[]     = {0x65,0x00,0x01,0xfa,0x62,0xfb,0x80};
int command3In[]      = {0xf4,0x69};
int command4Out[]     = {0xf4,0x80,0x69,0x80};
int serialBuffer[];

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  //kijken of er seriele data beschikbaar is,
  if(Serial.available() > 0){
  for(int i=0,i<12,i++)
  {
    //wat moet ik hier nou doen? dit is het punt waar ik vast loop.
    //Ik weet niet welke functie ik moet gebruiken om de juiste byte op te halen uit de buffer. 
    // want ik moet hem dus eerst vergelijken met commandStartIn[] als dat waar is moet commandStartOut[] er uit. 
    //
    serialBuffer[i] = Serial.read();
  }
  //het vergelijken kom ik later wel uit, tot nu loop ik vast op het punt van het juiste byte in de buffer zetten.
  //wanneer deze byte er instaat moet ik hem vergelijken met een van de 4 "in" commando's.
}

ik weet dat ik nu de verkeerde functie gebruik van de Serial functie, ik zou eigenlijk weten hoe ik de "oudste" byte uit die buffer kan lezen, wanneer ik dat weet kan ik die plaatsen in de buffer en vergelijken.
Ik moet eerlijk zijn, meest simpele dingen lukt mij wel, maar dit is echt wat ingewikkelder en op google kom ik er dus niet echt, ik krijg over het algemeen wel dingen met hexadecimale dingen, maar niet het plaatsen in een array! Ik weet overigens ook niet of het wel slim is om die array te gebruiken, het enige wat er moet gebeuren is de ingekomen seriele berichten vergelijken met een van de "in" array's die boven in de code staan, wanneer dat waar is moet hij het juiste "out" commando versturen!

Hopelijk hebben jullie ideeen, linkjes, of uitleg! Alvast hartstikke bedankt!

[craio]

Hoe is de flow juist?
Ontvang: commandstartin
Antwoord: commandstartout
Ontvang: commandxin
Antwoord: commandxout
Zoiets?

Wel vreemd dat commando's verschillende lengtes hebben en niet altijd op zelfde teken eindigt...
Kun je die serial.read niet vervangen door:

code:

int bytesRead = Serial.readBytes( serialBuffer, Serial.available() );

Ik heb wel 0,0 ervaring met code schrijven voor arduino, tot op heden enkel met PIC's gewerkt...
Bovenstaande code is gebruik makende van dit.

[ Voor 101% gewijzigd door craio op 20-09-2015 12:49 ]

[aaitje]

Volgens mij staat hier precies wat je zoekt: http://forum.arduino.cc/index.php?topic=46652.0

Het bericht va Joghurt in die thread is het meest simpele voorbeeld hoe je een aantal bytes kan inlezen in een array.

[jctjepkema]

@craio ja zo is de flow inderdaad, je moet 0x26, 0x75 als een commando zien, maar 0xf4 en 0x69 als 2 die allebei een apart commando krijgen!

@aaitje, hartelijk dank ik ga dat even door lezen! En kijken hoe ver ik kom!

[craio]

jctjepkema schreef op zondag 20 september 2015 @ 17:19:
@craio ja zo is de flow inderdaad, je moet 0x26, 0x75 als een commando zien, maar 0xf4 en 0x69 als 2 die allebei een apart commando krijgen!

Dat maakt het er voor mij niet duidelijker op
Wat bedoel je juist met het vetgedrukte?

[MrDoodoo]

Ik zou beginnen met je serialBuffer te veranderen naar char[] ipv int[].
Zie ook https://www.arduino.cc/en/Serial/ReadBytes
(Als je readBytes gebruikt uiteraard....)

[ Voor 40% gewijzigd door MrDoodoo op 20-09-2015 20:03 . Reden: niet goed gelezen ]

[craio]

MrDoodoo schreef op zondag 20 september 2015 @ 19:57:
Ik zou beginnen met je serialBuffer te veranderen naar char[] ipv int[].
Zie ook https://www.arduino.cc/en/Serial/ReadBytes
(Als je readBytes gebruikt uiteraard....)

Hm, op quote gedrukt op het moment van de edit blijkbaar... en kan post niet verwijderen.
Maar code zou nog steeds werken, je 'verliest' gewoon een byte ram per array element.

[ Voor 28% gewijzigd door craio op 20-09-2015 20:10 . Reden: timing... ]

[MrDoodoo]

craio schreef op zondag 20 september 2015 @ 20:07:
[...]

Volgens dit is daar niets mis mee.

Dat zag ik later ook, vandaar toevoeging "(als je readBytes gebruikt..."

Wat ik echter wel mis is geheugen allocatie van serialBuffer[].
Verder zou ik ivm geheugen gebruik geen int maar char gebruiken.

[craio]

MrDoodoo schreef op zondag 20 september 2015 @ 20:12:
[...]

Dat zag ik later ook, vandaar toevoeging "(als je readBytes gebruikt..."

Wat ik echter wel mis is geheugen allocatie van serialBuffer[].
Verder zou ik ivm geheugen gebruik geen int maar char gebruiken.

Maar gezien de ontvangen data van 0x00 tot 0xFF gaat is char niet geschikt want is signed. Dus kan je voor die bytes te sparen beter byte gebruiken.
Dus dan gewoon in getoonde code

code:

int serialBuffer[];

vervangen door

code:

byte serialBuffer[32]; //Max lengte dat je verwacht + wat marge

[ Voor 12% gewijzigd door craio op 20-09-2015 20:17 ]

[jctjepkema]

@craio,

Hij krijgt het volgende commando binnen om aan te gaan. (hex view op termite)

device 26 75 // volgens mij word hier de apparatuur aan gezet.
answer 00 //bevestiging dat hij aan is,
device 70 f0 f1 f3 f2 f4 f6 fa fb 71 01 geen idee wat hier gebeurt
answer 70 f0 01 f1 f2 22 f3 00 f2 d3 f4 80 f6 05 fa 62 fb 80 71 01 antwoord daar op.
device 65 00 fa fb ook geen idee waar dit voor is.
answer 65 00 01 fa 62 fb 80
device f4 69 de vraag naar de status
answer f4 80 69 80 status.
device f4 69
answer f4 80 69 80
device f4 69
answer f4 80 69 80
device f4 69
answer f4 80 69 80
als laatste sluit hij weer af met 26 75 om af te sluiten.

ik zal nu even kijken hoe ver ik kom!

[Vuikie]

Je zou de memcmp(), de strstr() of de strcmp() functies kunnen gebruiken. C heeft een legio aan compare functies in zich zitten(Die ook op een arduino werken). Ik heb zoiets wat jij nu zoekt met de memcmp() functie weten op te lossen, maar ik zou je eerst even goed inlezen in de functie en hoe die werkt(Google de functie even), want dit is wel lastig.
Anders zou je een ringbuffer kunnen maken die je continue doorzoekt op de juiste waardes, maar ook dat een lastig dingetje als je net begint met C/C++

*edit*
Ik zit nu niet achter mijn PC, maar ik zal kijken of ik wat voorbeeld code hier neer kan zetten.

[ Voor 9% gewijzigd door Vuikie op 20-09-2015 20:48 ]

[Sleurhutje]

Zit er een vertraging tussen het versturen van het commando en het verkrijgen van een antwoord? In dat geval kun je een grotere ontvangstbuffer maken. Als de wachttijd verstreken is, controleer je de buffer op inhoud en of daar bruikbare codes in staan. Vervolgens wis je de hele buffer weer en ga je weer wacht op nieuwe input.

[jctjepkema]

@sleurhutje, hij antwoord vrijwel direct. als dat redelijk vlot gaat moet dat denk ik geen probleem zijn. Kan het altijd proberen volgens mij.

Ik heb helaas pas donderdag weer tijd om verder te programmeren, ik heb me al wel redelijk ingelezen. Ik ga donderdag wat in elkaar "flansen" en dan post ik het wel weer hier! Alvast bedankt!

EDIT:

vanavond toch ff tijd gevonden:

C: arduino code

int commandStartIn[]   = {0x26, 0x75};
int commandStartOut[]  = {0x00};
int command1In[]      = {0x70,0xf0,0xf1,0xf3,0xf2,0xf4,0xf6,0xfa,0xfb,0x71,0x01};
int command1Out[]     = {0x70,0xf0,0x01,0xf1,0xf2d,0x22,0xf3,0x00,0xf2,0xd3,0xf4,0x80,0xf6,0x05,0xfa,0x62,0xfb,0x80,0x71,0x01};
int command2In[]      = {0x65,0x00,0xfa,0xfb};
int command2Out[]     = {0x65,0x00,0x01,0xfa,0x62,0xfb,0x80};
int command3In[]      = {0xf4,0x69};
int command4Out[]     = {0xf4,0x80,0x69,0x80};
char serialBuffer;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  serialBuffer=0x00;
}

void loop() 
{
  while(Serial.available())
  {
    serialBuffer = Serial.read();
    Serial.write(serialBuffer);
    if(serialBuffer == 0x26)
    {
      delay(2);
      Serial.write(commandStartOut[0]); 
    }
  }
}

Ik heb er dus even een Serial.write tussen geplaatst om te kijken of ie iets binnen krijgt, en hij verstuurt hem dus niet terug, dat is dan weer jammer.
Ik dacht ik kijk naar het aller eerste getal van het commando, in dit geval 0x26, is het die dan doe ik een delay van ongeveer 2ms, 2 bytes over serial zou ongeveer 3.33ms moeten duren volgens mij(uitgaande dat het op ongeveer 9600Hz zou gaan).
En dan verstuur ik het juiste commando terug, alleen het ontvangen van het eerste commando gaat dus niet goed. Ik denk dat ik hele domme fouten maak hierzo, maar ja dat is dan maar zo.

[ Voor 86% gewijzigd door jctjepkema op 22-09-2015 20:21 . Reden: bedenkingen. ]

[jctjepkema]

Oke! ik heb de code nu iets bij gewerkt, maar op een of andere manier doet de arduino er niks mee.
Ik weet 123 niet waar de fout zit, maar ik ga nog even lekker door klooien vandaag! Misschien dat jullie de fout zien? volgens mij maak ik namelijk een hele domme fout.

code:

#define STATE_START1  0 //wachten op start commando 1 
#define STATE_START2  1 //wachten op start commando 2
#define STATE_START3  2 //wachten op start commando 3
#define STATE_STATUS  3 //wachten op status commando

byte commandStart1In[]     = {0x26, 0x75};
byte commandStart1Out[]    = {0x00};
byte commandStart2In[]     = {0x70,0xf0,0xf1,0xf3,0xf2,0xf4,0xf6,0xfa,0xfb,0x71,0x01};
byte commandStart2Out[]    = {0x70,0xf0,0x01,0xf1,0xf2d,0x22,0xf3,0x00,0xf2,0xd3,0xf4,0x80,0xf6,0x05,0xfa,0x62,0xfb,0x80,0x71,0x01};
byte commandStart3In[]     = {0x65,0x00,0xfa,0xfb};
byte commandStart3Out[]   = {0x65,0x00,0x01,0xfa,0x62,0xfb,0x80};
byte commandStatusIn[]     = {0xf4,0x69};
byte commandStatusOut[]    = {0xf4,0x80,0x69,0x80};
byte serialBuffer;

byte state = STATE_START1;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  serialBuffer=0x00;
  state = STATE_START1;
}

void loop() 
{
  switch(state){
    case STATE_START1:
      if(Serial.available() > 1) {
        for(int i=0;i<2;i++){
           if(commandStart1In[i]=Serial.read())
           {
             Serial.write(commandStart1Out,sizeof(commandStart1Out));
             state = STATE_START2;
             break; 
           }
        }
      }
    case STATE_START2:
      if(Serial.available() > 10) {
        for(int i=0;i<11;i++){
           if(commandStart2In[i]=Serial.read())
           {
             Serial.write(commandStart2Out,sizeof(commandStart2Out));
             state = STATE_START3;
             break; 
           }
        }
      }
    case STATE_START3:
      if(Serial.available() > 3) {
        for(int i=0;i<4;i++){
           if(commandStart3In[i]=Serial.read())
           {
             Serial.write(commandStart3Out,sizeof(commandStart3Out));
             state = STATE_STATUS;
             break; 
           }
        }
      }
    case STATE_STATUS:
    if(Serial.available() > 1) {
        for(int i=0;i<2;i++){
           if(commandStatusIn[i]=Serial.read())
           {
             Serial.write(commandStatusOut,sizeof(commandStatusOut));
             state = STATE_STATUS;
             break; 
           }
           if(commandStatusIn[i]=Serial.read())
           {
             Serial.write(0x00);
           }
        }
      }
  }
}

Dit is de steriele data die ik binnen krijg via hexview op termite:

code:

26 75                                            &u              
26 75                                            &u              
70 f0 f1 f3 f2 f4 f6 fa fb 71 01                 pðñóòôöúûq.     
65 00 fa fb f4 69                                e.úûôi          
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
f4 69                                            ôi              
26 75                                           &u

hij eindigt weer met 26 75 om aan te tonen dat hij word afgesloten en dat hij uit moet. Dit is in mijn optiek nog niet eens de grootste zorg. In eerste instantie is het gewoon het makkelijkste als hij het bericht binnen krijgt, hij ook weer keurig het juiste antwoord stuurt!

[MrDoodoo]

Eerste wat mij opvalt is dat je hier

code:

if(commandStart1In[i]=Serial.read())

nog een gelijkteken mist.
Je vergelijkt nu niet de twee waarden maar zet de waarde van serial.read() in commandStart1In[i]
Is dat de bedoeling?

[MrDoodoo]

- dubbel -

[ Voor 99% gewijzigd door MrDoodoo op 24-09-2015 13:05 . Reden: dubbel gepost ? ]

[MrDoodoo]

Verder snap ik niet helemaal wat je hier wilt doen:

code:

    case STATE_START1:
      if(Serial.available() > 1) {
        for(int i=0;i<2;i++){
           if(commandStart1In[i]=Serial.read())
           {
             Serial.write(commandStart1Out,sizeof(commandStart1Out));
             state = STATE_START2;
             break; 
           }
        }
      }

Ik denk dat je bedoeling is dat indien de ontvangen bytes overeenkomen met commandStart1In je overgaat naar STATE_START2, maar dat is nu niet wat er gebeurt.
Bij het uitlezen van de eerste byte stuur je nu direct commandStart1Out terug en ga je over naar STATE_START2. De tweede byte blijft nog in de buffer staan.
Ik denk dat je zoiets wil:

code:

    case STATE_START1:
      if(Serial.available() > 1) 
      {     
           boolean commandReceived =  commandStart1In[0]==Serial.read();
          commandReceived = commandReceived && commandStart1In[1]==Serial.read();
          if (commandReceived)
          {
             Serial.write(commandStart1Out,sizeof(commandStart1Out));
             state = STATE_START2;
          }
      }
      break;

[jctjepkema]

kijk hartstikke bedankt, ik ga er meteen mee aan de gang!

en het moet inderdaad twee == zijn, het moet vergeleken worden. Dat is gewoon een stomme snelle typefout van mij!