-
Thread
AT90S8535 <-- Daten --> PC
); if (fd < 0){perror (MODEMDEVICE); exit(-1)} tcgetattr(fd, &oldtio); bzero(&newtio, sizeof(newtio)); newtio.c_cflag = CS8 | CLOCAL | CREAD; newtio.c_iflag = IGNPAR; newtio.c_lflag = 0; newtio.c_cc[VTIME] = 1; // 1/10 s auf Zeichen warten newtio.c_cc[VMIN] = 0; cfsetospeed
B50); // Fehlerfreier Empfang mit 50 Baud tcsetattr(fd, TCSANOW, &newtio); write(fd, buf1, sizeof(buf1)); for (k=0; k<30 k++) { res = read(fd, buf, sizeof(buf1)); buf[res] = 0; printf ("%s\n, buf"); } tcsetattr(fd, TCSANOW, &oldtio); close(fd); } //--------
-
Thread
C - Casting Verständniss Problem
entwickelst du? 32 oder 64 bit? Kannst du mal ausgeben was die Größe des void Pointers ist? [c]sizeof(void*)[/c] Evtl. liegt da der Hund begraben.
entwickelst du? 32 oder 64 bit? > > Kannst du mal ausgeben was die Größe des void Pointers ist? > sizeof(void*) > Evtl. liegt da der Hund begraben. Das ist für nen XMEGA, schreibe den Source in C. Kann die Größe jetzt leider nicht ausgeben. Mein Rechner ist jedoch ein 64 Bit. Aber das sollte damit
-
Thread
Verständnisfrage
es daher die 1 zu casten. Die ist ein int. Wenn du ((long)1<<4) schreibst klappt das auch wenn sizeof(long) != sizeof(int) ist.
-
Thread
Verständnissfrage Serielles Senden - UDR Register
UBRR_VAL & 0xFF; ISR( TIMER1_OVF_vect ) { for(uint8_t Send=0;Send<sizeof(Serial);Send++) { UDR=Serial[Send]; UDR_DBG=Serial[Send]; } } [/c] Eigentlich
>for(uint8_t Send=0;Send<sizeof(Serial);Send++) >{ >UDR=Serial[Send]; >UDR_DBG=Serial[Send]; >} Jo, immer schön in UDR reinballern und bloss nicht warten bis das Byte auch gesendet werden konnte. Kein Wunder das das nicht
-
Thread
AVR führt Programm nach flashen und Reset aus, nicht aber nach Powercycle
Sowas gehört sich einfach nicht, da macht man einen Guard drumherum, d.h. Schreibzugriffe außerhalb sizeof(array) werden abgewiesen. Will man es gut machen, gibt man noch einen Errorlevel zurück, der dann ausgegeben wird.
gehört sich einfach nicht, da macht man einen Guard drumherum, > d.h. Schreibzugriffe außerhalb sizeof(array) werden abgewiesen. > Will man es gut machen, gibt man noch einen Errorlevel zurück, der dann > ausgegeben wird. ASM unterster Level - was willst Du da abfangen, wenn der Fehler dort drin
-
Thread
memory von uint8_t werten in einer Struktur
zusätzliche Füllbytes > erweitert werden. Was auch passiert. Die Struktur wäre 12 Byte groß, was mit sizeof verifiziert werden kann. Je nach Compiler-Options kann die Struktur auch 6 oder 8 Byte groß sein.
Füllbytes >> erweitert werden. > > Was auch passiert. Die Struktur wäre 12 Byte groß, was mit sizeof > verifiziert werden kann. > > Je nach Compiler-Options kann die Struktur auch 6 oder 8 Byte groß sein. Es ist schön, wenn jetzt alles gesagt worden ist, und sogar von jedem ;-)
-
Thread
R8C/NC30 externes SIZEOF?
void ARRMULT(void); int arr1[]={10,20,30,40}; int arr2[]={45,35,25,15}; unsigned int arrsize=sizeof(arr1)/sizeof(int); void main(void) { ARRMULT(); } Assembler: .GLB _ARRMULT .GLB _arr1 .GLB _arr2 .GLB _arrsize .SECTION program _ARRMULT:
Renesasdokumentation zu Compiler und Assembler ist da auch nicht besonders hilfreich. Ein mov.w # SIZEOF _arr1 , r3 wird mit: Error (asp30): Section name is missing '_arr1' angemeckert. Die diversen Sections hab ich auch schon mal durchprobiert. Als Workaround tut ein: mov.w #(_arr2-_arr1)/
-
Thread
Kommastelle einfügen bei sprintf Befehl
Ergebnis char Variable[16]; spintf(Variable,"Ergebnis: %d",i); pts_lcd((char*) &Winkel[0], sizeof[Winkel)-1); //Ausgabe auf LCD, Ergebnis: 12648 Das geht soweit alles ganz gut. Jetzt hab ich nur das Problem das die 2 hinteren Stellen meiner Integer Zahl die Komastellen darstellen und ich
[16]; float h; h=i; sprintf(Variable,"Ergebnis: %5.2f",h); pts_lcd((char*) &Winkel[0], sizeof[Winkel)-1); [/c]
-
Thread
Wemos D1 mini RS232
(device_id == 2) { Serial.println("AN"); //Beamer Serial.write(BeamerAN, sizeof(BeamerAN)); //das ist die Asuführung Beamer an delay(20000); //Sollte die Pause sein die nicht Funktioniert Serial.write(Video3, sizeof(Video3)); //soll auf Video3 schalten } [/code] das was jetzt noch nicht klappt ist die Pause zwischen "BeamerAN" und "Video3". Der Beamer Soll jedesmal
-
Thread
Datenübertragung über TCP Socket von c auf java
< 0) BailOut("SOCKET: Opening socket error!"); bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(g_port); if (bind(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) BailOut("SOCKET: binding error! Maybe the port is used by an other application!"); fprintf(stderr,"TCP-Socket configured! Program is listening on port = %d
-
Thread
while( ) >>> mit Bedingungen
stdio.h> int main(){ int gesucht = 2; int list[] = {1,2,3}; int*const list_end = list + sizeof(list) / sizeof(*list); int* it; for( it=list; it<list_end; it++ ) if( *it == gesucht ) break; if( it == list_end ){ printf("Not found\n"); }else{ printf("Found
-
Thread
ESP8266 sendet Daten nach Initialisierung
packetSize = UDP.parsePacket(); if (packetSize > 0) { memset(packetBuffer, 0, sizeof(packetBuffer)); inCome = UDP.read(packetBuffer, sizeof(packetBuffer)); Serial.write(packetBuffer, inCome); } while (Serial.available() > 0) { processIncomingByte
-
Thread
Hellsichtige Funktionsausführung?
with 0s message[i] = byte(0x00); } Serial.println("2"); for(int x = 0; x < (sizeof(message) / sizeof(message[0])); x++){ Serial.print(message[x]); Serial.print(","); } Serial.println("ended"); } [/code] Leider sehe Ich im seriellen Monitor wenn das Programm läuft
-
Thread
Adresse eines Pointers sichern in C
> printf("%d",&x); > > nun wird die adresse von x dezimal ausgegeben. Aber nur dann, wenn sizeof(int) == sizeof(int*) Was zwar auf einem 16-Bit System sehr oft der Fall ist, du aber keine Garantie dafür hast. Bei printf lautet der Formatspezifier für Adressen %p. Den sollte man dann auch benutzen
-
Thread
Python-STM32 serielle Schnitstelle
UART2_Temp_Buffer[0], 1);/* Blocking */ 35 memcpy(&Python_22_B.UARTRx, &UART2_Temp_Buffer[0], 1*sizeof(uint8_T));/* D0 [1] */ 36 37 /* RelationalOperator: '<S1>/Compare' incorporates: 38 * Constant: '<S1>/Constant' 39 */ 40 Python_22_B.Compare = (Python_22_B.UARTRx > 0); 41
57 58 /* block I/O */ 59 (void) memset(((void *) &Python_22_B), 0, 60 sizeof(B_Python_22_T)); 61 62 /* Level2 S-Function Block: '<Root>/UART Rx' (stm32f4_usart) */ 63 enable_UARTRx(); 64 65 /* Level2 S-Function Block: '<Root>/Digital Output' (stm32f4_digital_output
-
Thread
Senden und empfangen über serielle Schnittstelle
ist Als Grundschleife: [C] int PrintReceivedData (void) { while( ( res = read( fd, buf, sizeof(buf) ) ) { buf[res] = '\0'; printf( buf ); } } [/C] Fragen an dich: Belässt der read das \n im Datenstrom? Woran erkennst du eigentlich, dass keine Daten mehr kommen? (Timeout
nicht angezeigt(kein printf), int PrintReceivedData (void) { while ( res = read( fd, buf, sizeof(buf) ) ) { buf[res] = '\0'; printf("%i\n",res); //if (buf[res]==0) if (res==0) { printf("res:%i\n",res); } printf( buf ); } }
-
Thread
Arduino: NRF24L01 2.4Ghz maniacbug Library
ACK kam? Da steht nur was von write, writeStart, WriteBlocking usw. also radio.write(&data, sizeof(data),0); Und nun? Warten? Was abfragen? Hat da mal jemand Code? PS: Ab und zu hängt sich der Empfänger auf, behauptet dass Datenpakete da wären, obwohl keine mehr kommen. Seltsam, da
RF24_CRC_8); radio.openWritingPipe(TXADDRESS); radio.powerUp(); if (radio.write(&data,sizeof(data))) { digitalWrite(LED_GLB,1); data.nr++; } else { digitalWrite(LED_ROT,1); data.errors++; } radio.powerDown(); [/c]
-
Thread
Speicherort Variabeln
im EEPROM ..... // Vom EEProm in den Speicher eeprom_read_block( &Motor1, &EE_Motor, sizeof( Motor1 ) ); ... // Vom Speicher ins EEPROM eeprom_write_block( &Motor1, &EE_Motor, sizeof( Motor1 ) ); [/c] Pascal schrieb > Bin mir nicht sicher, ob ich das soll. Doch. Genau das
-
Thread
V-USB: HIDKeys ignoriert ersten Tastendruck
Eure Hilfe. Ich habs jetzt so gelöst: [c]buildReport(lastKey); usbSetInterrupt(reportBuffer, sizeof(reportBuffer)); for(;;){ /* main event loop */[/c] Vor der Endlosschleife sende ich gleich, dass kein Taster gedrückt ist. Damit funktioniert es bei mir. Vielleicht hilft das den anderen auch
in key status. */ buildReport(lastKey); usbSetInterrupt(reportBuffer, sizeof(reportBuffer)); }[/c] Da lastKey am Anfang 0 ist, wird auch hier ein "keine Tasten gedrückt" gesendet. Ich hab das noch nicht ausprobiert, aber es müsste eigentlich funktionieren.
-
Thread
Cast von [Menge an Bytes] in [Klasse] erzwingen
::ABC(void *data) { testvar1 = *((unsigned char*)data); testvar2 = *((unsigned char*)data+1*sizeof(char)); testvar3 = *((unsigned int*)data+2*sizeof(char)); } [/c] Der Konstruktor bietet die Möglichkeit, einen Pointer zu übergeben. Somit kann ich quasi eine beliebige Speicheradresse in die
-
Thread
implicit declaration lo8
newcrc[]={0x00}; while(1) { newcrc[0]=_crc_ccitt_update(crc[0],*data); usart_puts(newcrc , sizeof(newcrc)); }; ich programmier einen atmega32 damit und schau es über den COM-Port an einem Terminal-Programm an.
mach da mal ganz schnell > while(1) > { > uint16_t crc={0x0}; > > for (i=0;i<sizeof(data);i++){ > crc=_crc_xmodem_update(crc,data[i]); > } char buffer[20]; sprintf( buffer, "%x", crc ); usart_puts( buffer, strlen( buffer ) ); draus. Du kannst doch nicht einfach
-
Thread
Zeiger auf struktur?
du sowas? [c] struct mystruct ** fkt() { int size = 5; struct mystruct ** ptr = malloc( sizeof(struct mystruct *) * size ); for ( int i = 0; i < size; ++i ) { ptr[i] = malloc( sizeof(struct mystruct) ); // ptr[i] füllen } return ptr; } [/c] Ist aber keine verkettete Liste
-
Thread
Nochmal Winapi und RS232
unsigned char output[] = {STX, 0x0E, Pointer, '1', ETX, CHK}; int laenge = sizeof(output); char *Buf; Buf = (char*)malloc(laenge * 5 + 1); memset(&o, 0, sizeof(OVERLAPPED)); o.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if(!(hCom = CreateFile
MB_ICONINFORMATION); LocalFree(lpMsgBuf); return 0; // no action } dcb.DCBlength = sizeof(DCB); GetCommState(hCom, &dcb); dcb.BaudRate = 9600; dcb.ByteSize = 8; dcb.Parity = NOPARITY; dcb.StopBits = TWOSTOPBITS; SetCommState(hCom, &dcb); GetCommTimeouts
-
Thread
Algorithmus zum Durchsuchen großer Felder
} nb[9]; mods = 0; // Neue Generation initialisieren memset(feld.next,DEAD,sizeof(feld.next)); // Durchlaufe die Hash Tabelle lebender Zellen for (count=0;count<feld.n_cells_old;count++) { // Hole Koordinaten lebender Zelle x = lcell_pos[count
feld.n_cells_old = count; // Altes Feld = Neues Feld memcpy(feld.last,feld.next,sizeof(feld.next)); // Anzahl Veränderungen zurück return (mods); }
-
Thread
Warum sind Com1..4: immer da ?
(pi) free (pi); return 0; } // Allocate structured memory pi = calloc (numPrt, sizeof (PORT_INFO_2)); memcpy (pi, z, numPrt * sizeof (PORT_INFO_2)); for (i = 0; i < numPrt; i++) { if ( pi[i].pPortName != NULL ) { if (strstr(pi[i].pPortName, COMPort))
-
Thread
ser, viele daten zum µc senden
{ String filename = line.substring(line.lastIndexOf("=") + 1); char c_filename[sizeof(filename)]; filename.toCharArray(c_filename,sizeof(filename)); wFile = SD.open(c_filename, FILE_WRITE); while(COM.available() > 0) { wFile.write(COM.read());
-
Thread
Unsigned Variablen vermeiden
Ähnlich sieht es aus, wenn du 1L auf "unsigned" addierst. Das Ergebnis ist "unsigned long" wenn sizeof(unsigned) == sizeof(long) (wie Win64), andernfalls "long" (wie Linux64).
-
Thread
Unbekannte Warnung
Ja, wurde ja oben auch schon genannt. Also: [C] memcpy(&SCD30_CO2_Concentration, &CO2_Temp, sizeof SCD30_CO2_Concentration); [/C]
#6625468: > Ja, wurde ja oben auch schon genannt. > Also:memcpy(&SCD30_CO2_Concentration, &CO2_Temp, sizeof > SCD30_CO2_Concentration); Und das sollte doch eigentlich schon daran scheitern, dass SCD30_CO2_Concentration volatile ist und der (implizite) Cast nach (void *) das wegwirft.
-
Thread
C embedded: Float zu uint32_t aus multidimensionalem Pointer funktioniert nicht
einfach memcpy und gut ist. [c] FLOAT32*fourB[2][6]; uint32_t tmp; memcopy( &tmp, &fourB[1][2], sizeof( uint32_t ) ); [/c]
schrieb im Beitrag #4474170: > FLOAT32*fourB[2][6]; > uint32_t tmp; > memcopy( &tmp, &fourB[1][2], sizeof( uint32_t ) ); Das & bei fourB gehört da aber nicht hin.
-
Thread
fwrite Probleme
printf("Fehler beim oeffnen der Datei"); else{ //Schreibe fwrite(liste, sizeof(EINKAUFSLISTE), 10, datei); fclose(datei); printf("\nsaved!\n"); } } void read(EINKAUFSLISTE *liste){ FILE *datei; if((datei = fopen("einkaufsliste.bin", "r"))
printf("Fehler beim oeffnen der Datei"); else{ //Lese fread(liste, sizeof(EINKAUFSLISTE), 10, datei); fclose(datei); printf("\nread!\n"); printList(liste); } } [/c] fwrite schreibt richtige Werte in das File, jedoch fread ließt nur das
-
Thread
Größe des reservierten Speichers bestimmen
Mittel um im Nachhinein die Größe des reservierten Speichers zu bestimmen? Ich denke da an eine Art "sizeof()"? MfG Markus
um im Nachhinein die Größe des reservierten >Speichers zu bestimmen? >Ich denke da an eine Art "sizeof()"? ??? Bei festen Strukturen/Variablen nimmt man sizeof(). Bei variablen Strukturgrössen legt der Programmierer während des Programmablaufs diese fest. In deinem Beispiel temp Bytes. MFG
-
Thread
NRF24L01 | Arduino | Problem
// print and increment the counter digitalWrite(2, HIGH); delay(500); radio.write(data, sizeof(uint16_t)+1); Serial.print(" | Temperature sent: "); Serial.println(sensorValue); // pause a second digitalWrite(2, LOW); delay(500); }[/c] RX [c]#include <SPI.h> #include <RF24
{ // fetch the payload, and see if this was the last one done = radio.read(data, sizeof(uint16_t)+1); } // print the payload if (data[0] == 'T') { //put the uint16_t back together uint16_t sensorValue = data[2] | data[1] << 8; Serial.print(count);
-
Thread
Arduino: Initialisierung eines array funktioniert nicht.
feld2[5]; void set_feld2 (void) { memcpy (feld2, (const int[]) { 18, 39, 42, 25, 69 }, sizeof (feld2)); }[/c] Und ja, das geht auch mit avr-gcc / avr-g++.
Johann L. schrieb im Beitrag #5853142: > memcpy (feld2, (const int[]) { 18, 39, 42, 25, 69 }, sizeof (feld2)); Das Compound-Literal gibt es strenggenommen nur in C, nicht aber in C++, wo es lediglich als GCC-spezifische Spracherweiterung verfügbar ist. In der Arduino-Welt spielt das aber vermutlich
-
Thread
Addressen
eine struct XXX mit mehreren Variablen unterschiedlichen Typen. uInt32 test; //sizeof of config_v void* test1; //Start Address void* test2;//End Address void* test3; //OFFSET test = sizeof(config_v); test1 = &config_v; test2 = &config_v + sizeof(config_v) ; test3 = &config_v.1Eintrag - &config_v: Das Problem trifft schön bei der Berrechnung von test2 und test3, warum? Danke an Alle Oscar
-
Thread
Atmega8 Encoder + USB HID spinnt manchmal
report type, so don't look at wValue */ buildReport(keyPressed()); return sizeof(reportBuffer); }else if(rq->bRequest == USBRQ_HID_GET_IDLE){ usbMsgPtr = &idleRate; return 1; }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
keyDidChange = 2; buildReport(lastKey); usbSetInterrupt(reportBuffer, sizeof(reportBuffer)); } if((keyDidChange == 2) && usbInterruptIsReady()) { keyDidChange = 0; buildReport(0); usbSetInterrupt(reportBuffer, sizeof(reportBuffer
-
Thread
Pointer in AVRGCC
ich gerne folgendes machen: eth_hdr = (struct eth_hdr*) buf; ip_hdr = (struct ip_hdr*) eth_hdr+sizeof(struct eth_hdr); Wobei aus der zweiten Zeile wird: +0000007A: 918001EC LDS R24,0x01EC Load direct from data space +0000007C: 919001ED LDS R25,0x01ED Load direct from
ip_hdr = (struct ip_hdr*) eth_hdr+1; * ip_hdr = (struct ip_hdr*) ((unsigned char*)eth_hdr)+sizeof(struct eth_hdr);
-
Thread
Wann Tastaturpuffer mit fflush(stdin); löschen?
kann sowas nicht passieren: [c]#include <stdio.h> int main(void){ char Str[16]; fgets(Str,sizeof(Str),stdin); return 0; }[/c] Der Benutzer kann zwar immernoch mehr als 15 Zeichen eingeben, aber dein Speicher wird dabei nicht zerschossen, da fgets eine Längenangabe erhalten hat. fgets liest
sicheren Seite. Bis du irgendwann die Grösse des Buffers änderst. Da arbeite ich lieber mit dem sizeof Operator. Dirk B. schrieb im Beitrag #3661427: > Aber so einfach kann man fgets und scanf (mit %s) auch nicht > vergleichen. > Die haben da unterschiedliches Verhalten, was durchaus erwünscht
-
Thread
Auf Strukturen in Funktion zugreifen
0; x < 10; x++) { p[x].u16_Age = x; p[x].u16_pow = x*x; } print_structs(p, sizeof(p)/sizeof(Person_t)); } [/c]
-
Thread
Probleme beim Kompilieren von wxWidgets
Versuchst Du das als 64-Bit-Code zu übersetzen? Das würde die Fehlermeldung erklären, denn nur dann ist sizeof (int) < sizeof (void *). Lass' das mit den 64 Bit mal sein.
-
Thread
Arduino Funkverbindung mit mehren clients
Serial.begin(9600); } void loop() { const char text[] = "Hallo"; bool ok = radio.write(&text, sizeof(text)); if(ok) Serial.println("gesendet"); else Serial.println("Fehler"); delay(1000); } [/c] Empfänger: [c] #include <SPI.h> #include <nRF24L01.h> #include <RF24.
void loop() { if (radio.available()) { char text[32] = {0}; radio.read(&text, sizeof(text)); Serial.println(text); } } [/c] Ich hatte es einmal geschafft "Hallo" ein oder zweimal zu übertragen, aber eigentlich funktioniert es nicht. Es wird auf der Sender Seite auch
-
Thread
Seriellport im PC lesen/ schreiben
Overlapped-Struct erstellt und mit einem Event verknüpft. [c] OVERLAPPED o; memset (&o, 0, sizeof (OVERLAPPED)); // Struktur mit 0en füllen o.hEvent = CreateEvent (NULL, FALSE, FALSE, NULL); // einen Event setzten [/c] dann eine Maske mit den Events, af die man warten möchte und eine, die
dwEvtMask & EV_RXCHAR) // Zeichen an RxD empfangen: { bRet = ReadFile (hCom, &InString, sizeof (InString), &dwRead, NULL); ... if (dwEvtMask & EV_ERR) // Zeichen an RxD empfangen: { ... [/c] Naja, das Übliche mit DCB, Fehlerauswerten, Sende- und Empfangspuffer setzen
-
Thread
Segmentation fault
Student; struct bestenote *NOTE; void Einlesen() { Student = (struct Studenten *) malloc(sizeof(struct Studenten)); printf("Wieviele Studierende sind es?\n"); scanf("%d", &Anzahl); for(N=0; N<Anzahl; N++) { printf("\nWie lautet der Name des %d. Studierenden?\n", N+1
Student; struct bestenote *NOTE; void Einlesen() { Student = (struct Studenten *) malloc(sizeof(struct Studenten)); printf("Wieviele Studierende sind es?\n"); scanf("%d", &Anzahl); for(N=0; N<Anzahl; N++) { printf("\nWie lautet der Name des %d. Studierenden?\n", N+1
-
Thread
Keil C166, xhuge, huge
endif // #ifdef _KEIL err_t hwinfo_get_dload(uint16_t *data) { memcpy(data, &hwinfo.dload, sizeof(uint16_t)); return(ERROR_OK); } [/c] Wenn ich jezt das xhuge oben weglasse dann bekomme ich beim aufruf von hwinfo_get_dload nichts richtiges in data zurück. Aber wieso ich jetzt ein xhuge
clonephone82 schrieb im Beitrag #3997506: > memcpy(data, &hwinfo.dload, sizeof(uint16_t)); memcpy() arbeitet meiner Erinnerung nach im aktuellen Memory Modell. Kommt aber evtl. drauf an, was Du linkst. Schau mal, ob Dir xmemcpy() weiterhilft.
-
Thread
Wörter parsen
"Wort2", "Wort3", "Ende" }; #define NR_WORDS (sizeof(Words)/sizeof(*Words)) int Find( char* Word ) { uint8_t i; for( i = 0; i < NR_WORDS; ++i ) { if( strcmp( Word, Words[i] ) == 0 ) return i; } return -1; } Kriegst
-
Thread
optimierung und itoa
0,nix. Hier mal ein Beispiel für einen Puffer für eine 32Bit-Zahl: [c] static uint8_t buff[sizeof("-2147483648")]; // maximum number length [/c] Peter
int-Wandlung zu wenig ist. Ist es ja auch. Du brauchst für 16Bit genau: [c] static uint8_t buff[sizeof("-32768")]; // maximum number length [/c] Peter