-
Thread
Linux: Server-Anwendung
childpid; char mesg[1000]; listenfd=socket(AF_INET,SOCK_STREAM,0); bzero(&servaddr,sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr=htonl(INADDR_ANY); servaddr.sin_port=htons(32000); bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)); listen(listenfd,1024); for(;;) { clilen=sizeof(cliaddr); connfd = accept(listenfd,(struct sockaddr *)&cliaddr,&clilen); if ((childpid = fork()) == 0) { close (listenfd); for(;;) {
-
Thread
Grosse Daten Konstanten definieren in C18 Pic Compiler
von den constanten ein Array mit welchem ich wie folgt zugreifen kann: v = (&Data[1])[3]; i = sizeof((&Data[1])[3]); oder char s[] = Data[1]; i = sizeof(s); v = s[3]; etwas kompliziert mit diesem MCC18 Kompiler.
> v = (&Data[1])[3]; kommt darauf an, wie v definiert ist > i = sizeof((&Data[1])[3]); wahrschinlich ist die funktion so definiert: int sizeof(unsigned char *RAMData); müsste für ROM-zugriff so heissen: int sizeof(rom unsigned char *RAMData); > char s[] = Data[
-
Thread
GPIB unter WIn xp mit ibrd
etwas noch mehr Quelltext folgt: char* gpibreceive(int i) { int e; memset(&gpibreadbuf,0,sizeof(gpibreadbuf)); Try { //die Try funktion ibrd(device[i],(void*)gpibreadbuf,sizeof(gpibreadbuf)-1);//Auslesen! } Catch (e) return (char*) "Error
Schnittstelle kein Absturz mehr kommt. void gpibreceive(int index) { memset(&gpibreadbuf,0,sizeof(gpibreadbuf)); // Clear buffer ibrd(device[index],(void*)gpibreadbuf,sizeof(gpibreadbuf)-1); // Try to read if (ibsta & ERR) { returnvalues(GPIBIBRDERROR, (DWORD) iberr); return;
-
Thread
struct und eeprom Auslesen Prob
eeprom_read_block(anzeige,anzeige_eemem,sizeof(anzeige)); //Ganze struct auslesen //Wenn gültiger Wert im EEMEM if(eeprom_read_byte(&pfeil.aktiv) < 2) eeprom_read_block(&pfeil,&pfeil_eemem,sizeof(pfeil)); //Ganze struct auslesen
] if(eeprom_read_byte(&anzeige[0].aktiv) < 2) eeprom_read_block(anzeige,anzeige_eemem,sizeof(anzeige)); [/c] vielleicht [c] if(eeprom_read_byte(&anzeige_eemem[0].aktiv) < 2) eeprom_read_block(anzeige,anzeige_eemem,sizeof(anzeige)); [/c] ?
-
Thread
GCC cleanup-Funktion / longjmp
#_t* ac); \ void ac_ ## N ## _func(ac_ ## N ##_t* ac){ \ memcpy(&ac_next_jmp,&ac->ac_jmp,sizeof(ac->ac_jmp)); \ ac_ ## N ## _func_sub(ac); \ } \ static inline void ac_ ## N ## _func_sub(ac_ ## N ##_t* ac) #define AUTOCLEANUP(N,ID) \ __attribute__((cleanup(ac_ ## N ## _func))) ac_ ## N ##_t ID; \ memset(&ID, 0, sizeof(ID)); \ if(memcmp(&ac_next_jmp, &ac_unset_jmp, sizeof(ac_unset_jmp))){ \ memcpy(&ID.ac_jmp, &ac_next_jmp, sizeof(ac_next_jmp)); \ if(setjmp(ac_next_jmp)){ \ ac_ ## N ## _func(&ID
-
Thread
Problem mit C struct auf ARM
size_t length, struct bla* res ){ if( !res || !res->data && res->buffer_max || length < sizeof(struct bla_serialized) ) return false; struct bla_serialized* s = buffer; long data_len = ntoh(s->len); if( s->buffer_max < data_len || length < data_len + sizeof(struct bla_serialized
res->len = data_len; res->a = s->a; res->b = ntoh(s->b); memcpy(res->name,s->name,sizeof(res->name)); memcpy(res->data,s->data,res->len); return true; } [/c]
-
Thread
Programmierung von Strukturen in C
Anfang vom Union aligned sind. Ein Zugriff auf ein Element vom Typ Foo in dem Union nimmt die ersten sizeof(Foo) Bytes aus dem Union und interpretiert sie als Instanz von Foo. Solange Du also -> den internen Aufbau der Typen in dem Union (z.B. Endianness) -> und sizeof() der Typen als fest gegeben voraussetzt
> Solange Du also > -> den internen Aufbau der Typen in dem Union (z.B. Endianness) > -> und sizeof() der Typen > als fest gegeben voraussetzt, kannst Du mit dem Standard vorhersagen, > was passieren wird. Fundstelle im C-Standard bitte zitieren.
-
Thread
*Tempor abspeichern
Funktion erstellt void datenspeicherntempo::init (const char * x) { memset(m_arr,0,ARRSIZE * sizeof(int)); char *tmp = char *x; while ( *tmp != '\0' ) { setdatenspeicher(*tmp); tmp++; } } lässt sich aber nicht übersetzen
das schon. [C] void datenspeicherntempo::init (const char * x) { memset(m_arr,0,ARRSIZE * sizeof(int)); while ( *x != '\0' ) { setdatenspeicher(*x); x++; } } [/C]
-
Thread
PCs über WOL mit Arduino einschalten
0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; char i; Udp.beginPacket(bc, 7); Udp.write(preamble, sizeof preamble); for (i=0; i<16; i++) Udp.write(mac, 6); Udp.endPacket(); } void loop() { if (! WOL_done) WOL(pc_mac); WOL(pc_mac_2); WOL_done = 1; }
0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; char i; Udp.beginPacket(bc, 7); Udp.write(preamble, sizeof preamble); for (i=0; i<16; i++) Udp.write(mac, 6); Udp.endPacket(); } void loop() { if (! WOL_done) { WOL(pc_mac); WOL(pc_mac_2); WOL_done = 1;
-
Thread
[C] Größe einer Struktur checken
sizeof() und die Zuweisung werden erst zur Compilierzeit ausgewertet, den Präprozessor interessiert das nicht.
Praktisch ist das fast immer richtig, aber aufpassen! Seit C99 kann sizeof nicht mehr alles zur Compilezeit machen. Diese einfachen Dinge, die seit Jahrzehnten gehen, laufen natürlich weiterhin in jeder relevanten Implementierung zur Compilezeit.
-
Thread
[C] uint8_t und spriftf()
macht sinn. Wie würdest du dann casten? char s[] ="Hallo \r\n"; tx_com( (uint8_t*)s, sizeof(s)); so ?
sinn. > Wie würdest du dann casten? > char s[] ="Hallo \r\n"; > tx_com( (uint8_t*)s, sizeof(s)); > > so ? Der cast ist richtig, statt sizeof() aber strlen() oder sizeof()-1 wenn die Größe zur Compilezeit bekannt ist. Das Nullbyte wirst du im Allgemeinen nicht mitübertragen wollen.
-
Thread
Strings wollen nicht verbunden werden
); //uint8_t address[sizeof(RS_485ADDRESS)+1); //itoa(RS_485ADDRESS, address, 10); //strcat(packet, address); strcat(packet, data); //uint16_t crc; //uint8_t crc_str[6]; //crc = crc16(packet); //itoa
); //uint8_t address[sizeof(RS_485ADDRESS)+1); //itoa(RS_485ADDRESS, address, 10); //strcat(packet, address); strcat(packet, data); //uint16_t crc; //uint8_t crc_str[6]; //crc = crc16(packet); //itoa
-
Thread
SPI Probleme mit ATMega644
{ Cnt++; if (Cnt > 250) Cnt = 100; ptr2SPIFrame = CLR_VAL_AM_2; SPIFrame_len = sizeof(CLR_VAL_AM_2); SPI_SendFrame(); _delay_ms(500); ptr2SPIFrame = SET_CURSOR_AM_1; SPIFrame_len = sizeof(SET_CURSOR_AM_1); SPI_SendFrame(); _delay_ms(500); ptr2SPIFrame = SET_CURSOR_AM_2; SPIFrame_len = sizeof(SET_CURSOR_AM_2); SPI_SendFrame(); _delay_ms(500); ptr2SPIFrame = SET_CURSOR_AM_3; SPIFrame_len = sizeof(SET_CURSOR_AM_3); SPI_SendFrame(); } return 0; } [\c] Wie gesagt
-
Thread
C-codezeile interpretieren
aus nem Code-Generator rauskommen oder nach Makro-Expansion entstanden sein. Zudem ist nicht über sizeof(int) gesagt.
immer signed. Ich bin jetzt zu faul, im Standard nachzuschlagen, aber der AVR-GCC behauptet: sizeof 32768 ist 4 sizeof 32768u ist 2 sizeof 65536u ist 4 Also scheinen Werte ab 32768 tatsächlich long zu sein, entsprechend sind Werte ab 65536u unsigned long.
-
Thread
Überlauf von character variable abfangen
explizit so definiert, daß das Ergebnis in deinem Fall überrollt. Nein. Zumindest nicht solange sizeof(char) < sizeof(int), da das Zwischenergebnis vom Typ int ist. Erst durch eine anschliessende Truncation zu unsigned char geschieht dies.
INT_MIN = 0x800... ? return x < 0 ? INT_MAX : x; // Ebenso aussichtslos: (x & (1 << (8 * sizeof (int) -1))) } int abs2 (int x2) { unsigned x = x2; if ((int) x < 0) x = -x; // Überlauf wegen -INT_MIN = INT_MIN = 0x800... ? return (int) x < 0 ?
-
Thread
Integer -> Char -> USART -> Char -> Integer (Übertragungsprotokoll)
dir angeschaut? Wir reden hier mindestens vom ein paar 100. uint16_t zahl; uc: send( Zahl, sizeof(Zahl) ); pc: Read( Zahl, sizeof(Zahl) ); bei bedarf kann man noch ein LittleEdian/Bigendian swap einbauen. > Es ist programmiertechnisch die einfachste. Außerdem läßt es sich viel > einfacher
darauf zu warten, daß der nächste Programmzyklus losgeht. > uint16_t zahl; > > uc: send( Zahl, sizeof(Zahl) ); > pc: Read( Zahl, sizeof(Zahl) ); > > > bei bedarf kann man noch ein LittleEdian/Bigendian swap einbauen. Um sowas braucht man sich bei Text nicht kümmern. Auch nicht um ein Protokoll
-
Thread
Mehr UB erkennen (C++)
because of std::memcpy (use std::bit_cast) to_type r; // begin-of-life std::memcpy(&r, &d, (sizeof(from_type) > sizeof(to_type) ? sizeof(to_type): sizeof(from_type))); // copy-state (must be trivially-copyable) return r; } [/c] Natürlich ist std::memcpy() genauso effizient (noop) wie der
-
Thread
C - String-array dynamisch erweitern
while(fgets(buf, 255, (FILE*)fp)) { interprets = (char**) realloc(interprets, (songcount+1)*sizeof(char*)); *interprets = (char*) malloc(255*sizeof(char)); strcpy(interprets[songcount], buf); songcount++; } return songcount; } [/c]
[c] *interprets = (char*) malloc(255*sizeof(char)); strcpy(interprets[songcount], buf); [/c] ist falsch müsste so sein: [c] interprets[songcount] = (char*) malloc(255*sizeof(char)); strcpy(interprets[songcount], buf); [/c]
-
Thread
Wertebereich einer Variable ermitteln
Blöcke in folgenden Code bei eingechalter Optimierung eigtl. entfernen (ungetestet) [c] if(sizeof(my_size_t) == 8) // init with maxval von uint8_t else if (sizeof(my_size_t) == 16) // init with maxval of uint16_t [/c] und so weiter
universelles gibt, wo ich nicht jeden speziellen Einzelfall bearbeiten muss. Im übrigen liefert sizeof() die Größe in Bytes nicht in Bits. Jetzt habe ich geschrieben: buffer_init((1 << (sizeof(my_size_t) * 8)) - 1); habe aber keineAhnung, ob das bei 16bit auf dem Atmel auch noch funktioniert
-
Thread
Ladekurve Kondensator, Analog Comparator, ACI
_t tifr; uart_putc(0xFF); while(1) { for (actual_value = 0; actual_value < sizeof(average); actual_value++) { // discharge C discharge_c(); // wait until C is discharged if (actual_value == sizeof(average) - 1) _delay_ms
actual_value] = ICR1; PORTD &= ~( 1 << PD5 ); if (actual_value == sizeof(average) - 1) { uint32_t sum = 0; for (int loop = 0; loop < sizeof(average); loop++) sum = sum + average[loop]; sum /= sizeof(average
-
Thread
Funktion mit mehreren Rückgabewerten
~~ Unterfunktion: testfunktion(unsigned char * ArrayX) { int Integerzahl; Integerzahl = sizeof(ArrayX); return; } Warum kommt bei Sizeof immer nur "2" als Ergebnis in der Unterfunktion raus, egal wie groß das Array in der Hauptfunktion ist? Hat sicherlich mit dem "Zeiger-Zeugs" zu tun
Schau mal genau sizeof was du machst. Hier wohl ein Zeiger.
-
Thread
Initialisierung: pointer array
ohne das ich immer nachzählen muss? :D z.b. sowas: {.buffer = (unsigned char*)"abcdefz", .len = sizeof(.buffer)}
struct schrieb im Beitrag #6420442: > z.b. sowas: > {.buffer = (unsigned char*)"abcdefz", .len = sizeof(.buffer)} Das sizeof bezöge sich hier die Größe des Zeigers auf den Buffer, also z.B. 4 Bytes auf einer Plattform mit 32 Bit, oder 8 Bytes auf 64 Bit - und nicht auf die Größe des Buffers selber
-
Thread
UART Kommandos elegant und schön auswerten, Beispiele?
", cmd_help,"? [command]\n"}, {"exit .. exit\n", cmd_exit, "x\n"} }; #define NO_COMMANDS (sizeof(f)/sizeof(debug_command_t)) #define COMMAND_BUFFER 80 /* Eingabepuffer */ int exit_debug = 0; /* Wird durch cmd_exit auf 1 gesetzt */ /* Hauptfunktion, wird verlassen wenn exit_debug
Leerzeichen überspringen */ #ifdef DYN_ARGS argv = realloc(argv, (argc+1)*sizeof(char **)); #else if(argc > 9){ printf("\nToo many arguments!\n"); return; } #endif argv[argc++] = cmdptr; } else if(*cmdptr == '\0'){
-
Thread
Verständnissfehler oder ist ein Fehler im Tutorial
Variablen' festgelegt wird. Zb.: [c] #define EE_DUMMY 0x000 #define EE_WERT ( 0x000 + sizeof( uint8_t ) ) #define EE_ANZAHL ( EE_WERT + sizeof( uint8_t ) ) #define EE_NAME ( EE_ANZAHL + sizeof( uint16_t ) ) #define EE_WERTIGKEIT ( EE_NAME + 10 * sizeof( uint8_t ) ) #define EE_PROZENT
Frage müsste das nicht statt [c] #define EE_LAST ( EE_WERTIGKEIT + sizeof( double ) ) [/c] so heißen ? [c] #define EE_LAST ( EE_PROZENT + sizeof( double ) ) [/c] Gruß ErgoProxy
-
Thread
Serielle Kommunikation / Modbus Format - wie implementieren?
z.B. [code] void bmsReset() { uint8_t req[] = { 0xAA, 0x02, 0x05}; _sendBMSRequest(req, sizeof(req) / sizeof(uint8_t) ); } void main() { ... bmsReset(); } [/code] Nach etwas Recherche habe ich schon aufgenommen, dass die Verwendung von dynamischen Arrays eher nicht so schlau
voltage = 0.0f; uint8_t req[] = { 0xAA, 0x03, 0x00, 0x37, 0x00, 0x02 }; _sendBMSRequest(req, sizeof(req) / sizeof(uint8_t)); // Response lesen // Auf Startzeichen 0xAA warten // Empfangens Byte No. 3 = 0x00 (dann Error, sonst Payload-Length) // CRC prüfen
-
Thread
USB -> RS232
BOOL OpenPort(aPort *port) { TCHAR szName[15]; DCB dcb; FillMemory(&dcb, sizeof(dcb),0); if(port->bOpened) return(TRUE); //Gibts schon, also Abbruch wsprintf(szName,"USB_1090"); if( !(port->hCom = FT_W32_CreateFile(szName, READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING
DCB korrekt initialisiert ? memset(&dcb,0,sizeof(dcb)); ganz wichtig : dcb.DCBlength = sizeof(DCB); und dann halt die entsprechenden einstellungen für den "virtuellen" COM-Port wie Baudrate Stopbits Parität etc. Gruss
-
Thread
Zweidimensionales Array im EEprom ablegen
eeFooByteArray1[20][5] EEMEM ; .... eeprom_busy_wait (); eeprom_write_block (IO_Feld, &eeFooByteArray1, sizeof(IO_Feld));[/c] So scheint es nicht zu gehen! habt Ihr einen Tip? gruß Matthias
(j = 0; j <= max_y; j++) { // Pseudocode: ADDR = EEPROM_ADDRESS + (i * max_x + j) * sizeof(type); write(ADDR, feld[i][j]); } } [/c] Gruß Jens
-
Thread
Array mit Benutzerdefinierter Größe
printf("%2u ", arr[x][y]); printf("\n"); } printf("size = %d\n", sizeof(arr)); printf("height = %d\n", sizeof(arr[0])); printf("width = %d\n", sizeof(arr) / sizeof(arr[0])); return 0; } [/c] edit: mit [code]gcc -std=c99 foo.c[/code] compilieren
-
Thread
volatile -- Anwendung auf Arrays
]; txr = (txr + 1) % sizeof(txbuf); wakeup("uart_tx"); } else UCSR0B &= ~B(UDRIE0); } u8 uart_getc(void) { sleep_while (rxr == rxw); // sleep while rxbuf empty u8 c = rxbuf[rxr]; barrier("read rxbuf before changing rxr"); rxr = (rxr + 1) % sizeof(rxbuf); return c; } void uart_putc(u8 c) { u8 w = (txw + 1) % sizeof(txbuf); sleep_while (w == txr); // sleep while txbuf full txbuf[txw] = c; barrier("write txbuf
-
Thread
SD Karte mit FatFs über SPI an Atmega, wie kann man die Schreibgeschwindigkeit maximieren?
(&file1)); xprintf(PSTR("1. f_tell nach fopen %lu\n"),f_tell(&file1)); f_write(&file1, &day, sizeof(day),&written); //uint8_t day = 97 f_write(&file1,"Test Text",9,&written); // <+^ Zusammen 10 Byte unsigned char charArray[256]; for(int i=0;i<(sizeof(charArray)/sizeof(char));i++){ charArray
f_tell nach eof %lu\n"),f_tell(&file1)); for(int j=0;j<500;j++){ f_write(&file1, charArray, (sizeof(charArray)/sizeof(char)), &written); // Schreibe 500*256 = 128000 byte } xprintf(PSTR("5. f_size vor truncate %lu\n"),f_size(&file1)); xprintf(PSTR("5. f_tell vor truncate %lu\n"),f_tell(&file1
-
Thread
UART übergabe eines #defines
USART_TRANSMIT(val);[/c] Funktion [c]void USART_TRANSMIT(char* adr) { for(int i=0; i<sizeof(adr);i++) { while ( !( UCSR0A & (1<<UDRE0)) ); UDR0 = adr[i]; } }[/c] Am PC gibt er mir aber leider nur die ersten beiden Characters aus. Was is falsch?
Was kommt denn bei "sizeof(adr)" raus?
-
Thread
Probleme mit Code-Portierung von AVR nach ARM--> Zeigerumwandlung
Wortbreiten > 8 Bit erforderlich, um ein bitgenaues Abbild Deiner Struktur zu erhalten. Lass Dir mal sizeof (struct IP_header) ausgeben.
Bit erforderlich, um ein > bitgenaues Abbild Deiner Struktur zu erhalten. > > Lass Dir mal sizeof (struct IP_header) ausgeben. Vielen Dank. Das scheint das Problem ersteinmal gelöst zu haben. Btw: [code] printf("IP Header size: %d \n", sizeof(struct IP_header)); //<-- gibt 28 aus [/code
-
Thread
struct Vergleich
poolShutter[index" kopieren. Geht zum Beispiel so: memcyp (poolShutter[index], new_shutter_device, sizeof (shutter_t)); Wichtig: Bei sizeof unbedingt den typedef angeben, nicht die Struktur ansich, da du sonst nur die Länge des Pointers kopieren würdest. Gruß Alex
nicht gezeigt hat. > Geht zum Beispiel so: > > memcyp (poolShutter[index], new_shutter_device, sizeof (shutter_t)); Genau das macht die Zuweisung ganz von alleine
-
Thread
Daten in einer Datei Schreiben und lesen
binary); if(!idatei){cout <<"Fehler beim Öffnen neuer Datei"<<endl;} idatei.read(Vp, sizeof(Vp)/sizeof(Vp[0])); idatei.close() } std::vector<XYpair> Saveload:: load(){ int n; cout<<"von welchem Pfad soll ausgelesen werden"<< endl; cin>>pfad; odatei.open(pfad
binary); if(!idatei){cout <<"Fehler beim Öffnen neuer Datei"<<endl;} idatei.read(Vp, sizeof(Vp)/sizeof(Vp[0])); [/C] ist ja schön, wenn du deinem Benutzer mitteilst, dass du die Datei nicht öffnen konntest. Nur: Auf eine nicht geöffnete Datei kann man auch nicht schreiben/lesen. D.h
-
Thread
Präprozessorproblem Stringumwandlung
define STR L"Hallo" typedef struct STest { unsigned int iNumber1; unsigned short sBuffer[sizeof(STR)/sizeof(STR[0])-1]; unsigned int iNumber2; }STest; struct STest stest = { 1, {'H','a','l','l','o'}, 2, }; int _tmain(int argc, _TCHAR* argv[]) { return 0; } [/c] Nur
L"Hallo" > > typedef struct STest > { > unsigned int iNumber1; > unsigned short sBuffer[sizeof(STR)/sizeof(STR[0])-1]; ^^^^^ ^^^^^^^^^^^^^ der type ist wchar_t denn solltest du auch nutzen ausserdem brauchst du hier ein Pointer um das so zu intitialiesieren wie
-
Thread
Verkettete Listen in Ansi C
Pliste *akt; akt=first; while(akt->next!=NULL) { akt=akt->; new (Pliste*)malloc(sizeof struct(Pliste); } akt->next=new; new->next=NULL; } [/c]
/ !!! // Listenanfang = Leeres Element vom Typ struct Liste anlegen p = (Pliste) malloc(sizeof(struct Liste)); [/C]
-
Thread
I2C Repeated Start klappt nicht
} Pressure; Pressure.m_HL.m_uc = 0; if (!I2cRead(I2C_ADDR_PRESS, STATUS, &ucStatus, sizeof(ucStatus)) || !(ucStatus & 0x20)) // Data ready? return FALSE; if (!I2cRead(I2C_ADDR_PRESS, TEMPOUT, &sTemperature, sizeof(sTemperature)) || !I2cRead(I2C_ADDR_PRESS, DATARD8, &Pressure.m_HL.m_ucMSB, sizeof(Pressure.m_HL.m_ucMSB)) || !I2cRead(I2C_ADDR_PRESS, DATARD16, &Pressure.m_HL.m_usLSB, sizeof(Pressure.m_HL.m_usLSB)) || (ucStatus & 0x10)) // Real time error return FALSE; *pfTemperature
-
Thread
EEprom Routine
natürlich so viel speichern, wie groß die Zahl ist. eeprom_write_block(&zahl, (void *)eeprom_offset, sizeof zahl); Wenn "zahl" vom Typ double ist, dann ist sizeof zahl == 4.
noch nicht zu kären vermochte warum kann ich mit eeprom_write_block(&interval,(void *)0x0060,sizeof interval); und eeprom_read_block(&speicher,(void *)0x0060,sizeof interval ); meine variable ganz gervorragend im EEprom sicher und und wieder auslesen, wenn "interval" vom Typ float ist und habe
-
Thread
char zeiger auf int zeiger
Je nach C-Standard: Einfach casten: [c] uint32_t array[10]; send(socket, (char *) array, 10 * sizeof(uint32_t)); [/c] Oder einfach übergeben: [c] uint32_t array[10]; send(socket, array, 10 * sizeof(uint32_t)); [/c] Als es noch kein void gab, war char der 'Alles'-Typ, daher gehts mitunter
den die send Funktion haben will. [C] int array[10]; ... send( socket, (char*)test, sizeof(test) ); [/C]
-
Thread
Problem mit malloc
du den Fehler auch gleich gemacht. So schaut's gut aus: [c](double *)malloc(WIDTH*HEIGHT*sizeof(double));[/c] Ein double hat übrigens 8 Byte...
... oder sauberer: [c] double (*workarray)[HEIGHT] = (double (*)[HEIGHT])malloc(WIDTH*sizeof(double [HEIGHT])); [/c]
-
Thread
uint32_t ist nur uint16_t
Falls das ganze auf einem System mit sizeof(int)=2 (16bit) läuft, dann sollte sprintf(buffer, "%6li", memtemp); das richtige Ergebnis liefern.
erwarten. Somit wird der übergebene 32-Bit-Wert als 16-Bit-Wert interpretiert (mal angenommen, daß sizeof (int) auf Deinem System 2 ist).
-
Thread
Hex zu String Zuweisung: Funktion in C?
das so machen: [c] unsigned char string[] = { 0x20, 0x00, 0x80, 0xFF }; #define ARRAY_SIZE(x) ( sizeof(x) / sizeof(*x)) ... crc_wert = crcbitbybit( string, ARRAY_SIZE(string) ); [/C] und nenn die Variable nicht 'string'. Das ist maximal einfach nur irreführend. Denn da ist kein String
allgemein 'Daten'. [c] unsigned char data[] = { 0x20, 0x00, 0x80, 0xFF }; #define ARRAY_SIZE(x) ( sizeof(x) / sizeof(*x)) ... crc_wert = crcbitbybit( data, ARRAY_SIZE(data) ); [/C] (und caste nicht, wenn du nicht musst. Damit versteckst du nur mögliche Fehler, weil du dem Compiler auf freundliche
-
Thread
Variablen im EEProm ablegen
[c] // ein Struct was das und das macht #define PLACE_STRUCT_1 0 #define SIZE_STRUCT_1 (sizeof(struct1)) // noch so ein tolles #define PLACE_STRUCT_2 (PLACE_STRUCT_1 + SIZE_STRUCT_1) #define SIZE_STRUCT_2 (sizeof(struct2)) //mal ein Array #define PLACE_ARRAY_1 (PLACE_STRUCT_
minute uint8_t sekunde }ST_UHRZEIT #define POS_UHRZEIT_START 0 #define SIZE_UHRZEIT_START sizeof(ST_UHRZEIT) #define POS_UHRZEIT_ENDE (POS_UHRZEIT_START + SIZE_UHRZEIT_START) #define SIZE_UHRZEIT_ENDE sizeof(ST_UHRZEIT) ST_UHRZEIT aktuelle_uhrzeit; get_time(&aktuelle_uhrzeit); ..
-
Thread
struct mit printf ausgeben
eine Variable an putmem 'verfüttern'. [C] struct irgendwas myVar; .. putmem( myVar, sizeof( myVar ) ); [/C]
> Quasi etwas wie WriteFile(hFile, &struct, sizeof(struct), ...); fwrite(&struct, sizeof(struct), 1, stdout);
-
Thread
EEPROM avr
include <avr/eeprom.h> eeprom_busy_wait(); eeprom_read_block(&Temp_Variable,(uint16_t*)0,sizeof(int)); if (!(Variable == Temp_Variable)) { eeprom_busy_wait(); eeprom_write_block(&Variable,(uint16_t*)0,sizeof(int)); } wobei 'Variable' die zu Schreibende /lesende Variable ist und
nicht neu geschrieben zu werden. In diesem Fall wird ab Startadresse '0' geschrieben (gelesen). Mit sizeof wird die anzahl Bytes abgefragt, die geschrieben werden soll (abhängig von der Variablen). Ist aber in den Examples im WinAVR gut beschrieben.
-
Thread
Hilfe bei qsort
int main() { int i; for( i = 0; i < 4; ++i ) Index[i] = i; qsort( Index, 4, sizeof *Index, Compare ); for( i = 0; i < 4; ++i ) printf( "%s\n", Strings[Index[i]] ); return 0; } [/C] Entscheidend ist, dass du dir in der Compare Funktion den übergebenen Pointer
],WayPoint.name,8); } for( i = 0; i < number; ++i )Index[i] = i; qsort( Index, number, sizeof *Index, Compare ); //Daten sortiert ausgeben readwp(Index[pos]); [/c]
-
Thread
MQTT Publish mit ESP8266 implementieren
topic[0] = 'a'; topic[1] = '/'; topic[2] = 'b'; const uint8_t topicStrLen = sizeof(topic) / sizeof(topic[0]); self->var_header_size = 1 + 1 + topicStrLen; os_free(self->var_header); self->var_header = os_zalloc(sizeof(uint8_t) * self->var_header_size); self
ICACHE_FLASH_ATTR user_send_data(struct espconn *pespconn) { char *pbuf = (char*)os_zalloc(sizeof(uint8_t) * mqttSize); mqtt.fillPacket(&mqtt, pbuf); espconn_send(pespconn, (uint8_t*)pbuf, mqttSize); os_free(pbuf); } [/c] Die Variable *mqttSize* ist hierbei der Rückgabewert
-
Thread
Erklärung C-Code
Dennis [c] static int GetSystemEndianness(void) { union { short s; char c[sizeof(short)]; } un; un.s = 0x0102; if(sizeof(short) == 2) { if(un.c[0] == 1 && un.c[1] == 2) return ENDIAN_BIG; else if(un.c[0] == 2 && un.c[1] ==
void) { unsigned short s = 0x0102; unsigned char c[2]; memcpy(c, &s, 2); if(sizeof(s) == 2) { if(c[0] == 1 && c[1] == 2) return ENDIAN_BIG; else if(c[0] == 2 && c[1] == 1) return ENDIAN_LITTLE; else return ENDIAN_UNKNOWN
-
Thread
C - Fehler bei realloc - Verkettetestruktur erstellen
Childnode-Array um 1 vergroessern : */ aktunode->childnodes = (NODE **) realloc(aktunode->childnodes,sizeof(NODEPTR)*(aktunode->index+1));
Childnode-Array um 1 vergroessern : */ > aktunode->childnodes = (NODE **) > realloc(aktunode->childnodes,sizeof(NODEPTR)*(aktunode->index+1)); der Fehler liegt in dem Teil welchen du uns nicht zeigst.
-
Thread
ADC über SPI
) << 6, 0x00}; uint8_t answer[3] = {0x00, 0x00, 0x00}; spiTransferMessage(message, answer, sizeof(message)/sizeof(uint8_t), &mcp3208); return (uint16_t)(((answer[1] & 0x0f) << 8)|answer[2]); }[/c] Sollte (zusammen mit dem Datasheet des MCP) selbsterklärend sein. Eigentlich mega einfach.
6, 0x00}; > uint8_t answer[3] = {0x00, 0x00, 0x00}; > spiTransferMessage(message, answer, sizeof(message)/sizeof(uint8_t), > &mcp3208); > return (uint16_t)(((answer[1] & 0x0f) << 8)|answer[2]); > }[/c] > Also das verstehe ich nicht. Ich möchte den ADU im single-ended Mode und Channel