[C] Seriele verbinding naar owa21a

[Gehakt]

Om via rs232 vanaf de owa21a characters te versturen heeft de fabrikant al een api gemaakt waarmee je de module aan kan slingeren etc.
Dit werkt allemaal en ik ben al zover dat ik op de terminal tekst weg kan schrijven.

Nu is mijn vraag is het met deze functie ook mogelijk om structures weg te schrijven?
Ik zal de beschrijving uit de datasheet geven:

Syntax

C:

INT Serial_SendRS232Buffer (BYTE wCOMPort, UCHAR *wOutBuffer, UINT *wOutBufferLength)

Parameters
BYTE wCOMPort
Number of port[0, 1]

UCHAR *wOutBuffer
Buffer to write

UINT *wOutBufferLength
Contains the number of bytes to write

Return Codes
NO_ERROR
ERROR_SERIAL_IN_PARAMETER
etc

Nu is het mij al gelukt om de module te initialiseren. Ik stuur daarna op de volgende manier wat characters.

C:

strcpy( Buffer, "test\n\r");
BufferLength = strlen (Buffer);
ReturnCode = ( *FncSerial_SendRS232Buffer)( 0, (* UCHAR) Buffer, &BufferLength);

Nu is mijn vraag hoe ik structures weg ga schrijven. Ik moet namelijk communiceren met pc die diagnose info gaat terugspugen (ook in structure vorm) als je de juiste structures stuurt. Deze binaire data is daarna wel weer om te zetten in tekst zodat je er wat aan heb maar dat laat ik verder even buiten beschouwing.

Verder heb ik nog een laatste vraag en dat is hoe ik in linux kan kijken wat er daadwerkelijk binnenkomt op de terminal. Bijvoorbeeld binair of in hex.
Ik gebruik nu MiniCom om te communiceren met de shell van de owa2x via rs232.

* Gehakt wacht rustig op .oisyn

[igmar]

Ja, maar een zijn wel een aantal dingen waar je rekening mee moet houden :

1) Pointers zijn een no-go. Je moet zorgen dat je alles in de struct kwijt kan, desnoods met unions.
2) Je zit met padding. Die moet aan beide kanten overeen komen. Verder varieert de paddding per platform en per compiler. Dit is een punt wat regelmatig de oorzaak is van vage problemen.

Ik zou zelf opteren voor een serialise : Je maakt een beschrijving van een stucture, en een functie de de beschrijving + struct omzet in ASCII data. Op de andere kant kun je dan het omgekeerde doen. De overhead is wel iets groter, maar je hebt geen last van alignment problemen.

[Gehakt]

igmar schreef op donderdag 30 november 2006 @ 12:59:
Ik zou zelf opteren voor een serialise : Je maakt een beschrijving van een stucture, en een functie de de beschrijving + struct omzet in ASCII data. Op de andere kant kun je dan het omgekeerde doen. De overhead is wel iets groter, maar je hebt geen last van alignment problemen.

Ik kan in ieder geval al vertellen dat ik aan de andere kant niets mag / kan aanpassen. Ik heb alleen een beschrijving van welke structures ik moet sturen en in welk formaat ik dan data terug krijg.
En om het nog even moeilijker te maken kan ik ook niet even heen en weer lopen om het aan te sluiten en te testen.

[farlane]

[edit]
Owh je wilt graag op .oisyn wachten zie ik

[ Voor 90% gewijzigd door farlane op 30-11-2006 15:08 ]

[H!GHGuY]

dan moet je nog 1 ding weten. De endian-ness van je doelplatform.

code:

ostringstream oss;
oss << myStructure;
int rc = Serial_SendRS232Buffer (0, oss.str().c_str() , oss.str().size())

helemaal te customizen.
In het ergste geval kun je't zelfs nog met een vector doen of zo.

[Gehakt]

farlane schreef op donderdag 30 november 2006 @ 15:04:
[edit]
Owh je wilt graag op .oisyn wachten zie ik

Of farlane natuurlijk. Misschien had ik er een achter moeten zetten.

Dat je op de endian-ness moet letten snap ik. Deze code is alleen voor c++?

code:

ostringstream oss;
oss << myStructure;
int rc = Serial_SendRS232Buffer (0, oss.str().c_str() , oss.str().size())

Ik zal hier morgen even verder naar kijken.

[farlane]

H!GHGuY schreef op donderdag 30 november 2006 @ 19:46:
dan moet je nog 1 ding weten. De endian-ness van je doelplatform.

code:

ostringstream oss;
oss << myStructure;
int rc = Serial_SendRS232Buffer (0, oss.str().c_str() , oss.str().size())

helemaal te customizen.
In het ergste geval kun je't zelfs nog met een vector doen of zo.

't Is alleen niet echt geldige C code

[Gehakt]

Ik heb vandaag even een gesprek gehad met een programmeur van een ander bedrijf (ingehuurd) die al wat ervaring had met het systeem.

Die zei dat ik beter geen gebruik kon maken van structures.
Zijn oplossing was om het buffer gewoon met hexadecimale te vullen en ipv strcopy() memcopy() gebruiken.

Om de verbinding uit te lezen moest ik read() gebruiken die voor linux beschikbaar is.

[H!GHGuY]

OK, op request in C-code:

C:

struct eenStruct
{
  int32 a, b,c;
  char d,e,f;
}

char* append(char* buf, size_t& len, int32 a)
{
   if (len < sizeof(int32))
      return 0;
   else
   {
      int* intBuf = (int*)buf;
      *intBuf = htonl(a);
      len -= sizeof(int32);
   }
   return buf + sizeof(int32);
}
// etc voor de andere.

char* append(char* buf, size_t& len, struct eenStruct& str)
{
    if (len < 3*sizeof(int32) + 3*sizeof(char))
       return NULL;
    else
    {
       buf = append(buf, len, str.a);
       buf = append(buf, len, str.b);
       buf = append(buf, len, str.c);
       buf = append(buf, len, str.d);
       buf = append(buf, len, str.e);
       buf = append(buf, len, str.f);
    }
    return buf;
}

struct eenStruct myStruct;
char buf[1024+1]; int len = 1024;
char* lastBufLocation = append(buf, len, myStruct);

Dingen waar je rekening mee moet houden:
- lengte van je datatypes. Niet op elk platform zijn int en long 32bit.
- Endian-ness (little/big endian)
- sommige datatypes converteren nu eenmaal niet gemakkelijk: double is nogal irritant om te serializen op deze manier, en het is nog moeilijker om exact dezelfde double te hebben voor en na serializatie. (Je kan het meestal wel door radix en mantissa als integere types door te zenden)
- en misschien nog wel dingen die ik nu vergeet.

[farlane]

Meestal bestaat een frame uit een frame header en een payload. Als je een struct maakt die een frame voorstelt, en een functie die een frame kan versturen en ontvangen heb je een redelijke abstractie van de lowlevel dingen.

Je moet dan nog wel een methode bedenken waarmee je de payload in het frame zet, maar deze zal per frame type / commando verschillen.

[farlane]

H!GHGuY schreef op vrijdag 01 december 2006 @ 21:23:
OK, op request in C-code:

NIet om te nitpicken maar ook dit is geen geldige c code.