-
Thread
TCPserver in C#
(mysocket,(SOCKADDR*)&addr,sizeof(SOCKADDR)); if(rc==SOCKET_ERROR) { printf("Fehler: connect gescheitert, fehler code: %d\n",WSAGetLastError()); return 1; } else { printf("Verbunden mit 127.0.0.1..\n"); } send(mysocket,mystring,sizeof(mystring),0); strcpy(mystring,"Verbunden\n"); send(mysocket,mystring,9,0); while(1) { i++; sprintf(mystring, "%d\n",i); send(mysocket,mystring,sizeof(mystring),0);
-
Thread
unsigned char vs. uint_8
es, weil die logische Konsequenz aus den Regeln von ISO C ist. char ist der kleinstmögliche Typ (sizeof(char) ist per Definition 1). Also kann uint8_t nicht kleiner sein. Und größer als char kann uint8_t natürlich auch nicht sein, denn char ist ja mindestens 8 Bit groß, also so groß wie uint8_t.
weil die logische Konsequenz aus den Regeln von ISO C > ist. char ist der kleinstmögliche Typ (sizeof(char) ist per Definition > 1). Also kann uint8_t nicht kleiner sein. > Und größer als char kann uint8_t natürlich auch nicht sein, denn char > ist ja mindestens 8 Bit groß, also so groß wie uint8
-
Thread
STM32F4 - Problem mit Array größe, Variable wird überschrieben
__StackTop = (ORIGIN (ram) + 0x20000) 0x2001f800 __StackLimit = (__StackTop - SIZEOF (.co_stack)) [/c] Das ist dein Stackbereich! 2KB
stack_dummy section */ __StackTop = ORIGIN(ram ) + LENGTH(ram ); __StackLimit = __StackTop - SIZEOF(.co_stack); PROVIDE(__stack = __StackTop); /* Check if data + heap + stack exceeds ram limit */ ASSERT(__StackLimit >= __HeapLimit, "region ram overflowed with stack") [/c] Das
-
Thread
C: Statische "Member" Variablen zurückgeben oder gleich globale verwenden? OOP Ansätze in C gesucht
testIntReturn; double testDouble = 1.5125e-19, testDoubleReturn; fifo_init( &fifo_i, buffer_i, sizeof(buffer_i), sizeof(buffer_i[0]) ); fifo_init( &fifo_d, buffer_d, sizeof(buffer_d), sizeof(buffer_d[0]) ); ... fifo_put(&fifo_i, &testInt ); fifo_put(&fifo_d, &testDouble ); ..
-
Thread
Linux und sg_utils für Vendor Specific ATA Command
(sgLibDevDescriptor, scsiAtaCommand, sizeof(scsiAtaCommand), 20, NULL, NULL, 0, scsiSenseBuffer, sizeof(scsiSenseBuffer), scsiAtaReturnDescriptor, sizeof(scsiAtaReturnDescriptor), &scsiResourceId,
-
Thread
verschiedene
write.param = *param; write.free = 0xFFFF; write.checkSumme = calcChecksumme((uint8*)&write.param, sizeof(write.param)); eepromWrite(adress, (uint8*)&write, sizeof(write)) } [/c] gleiches für struct2, struct3 and struct4 Diese Structuren sind komplett unterschiedlich Gibt es da einen weg
param; > write.free = 0xFFFF; > write.checkSumme = calcChecksumme((uint8*)&write.param, > sizeof(write.param)); > > eepromWrite(adress, (uint8*)&write, sizeof(write)) Ich vermute Du möchtest malloc vermeiden. Dann mach dir Gedanken eepromWrite neu zu schreiben oder zu wrappen. Es macht
-
Thread
Datentyp Stringübertragung UART Peter Fleury - ATMega8
(); if(u8_BufferNextIn<sizeof(anzeigeb)-1) { anzeigeb[u8_BufferNextIn]=chr_Character; u8_BufferNextIn++; } char anzeigeb[u8_BufferNextIn]=0; }while(chr_Character<'\n') ... do{ janein=uart_getc(); }while(janein!=
für Zeile 2 eintippen:"); u8_BufferNextIn=0; do{ chr_Character=uart_getc(); if(u8_BufferNextIn<sizeof(anzeigeb)-1) { anzeigeb[u8_BufferNextIn]=chr_Character; u8_BufferNextIn++; } char anzeigeb[u8_BufferNextIn]=0; }while(chr_Character<'\n') set_cursor(0,2); lcd_string(anzeigeb); uart_puts
-
Thread
Arrays und Zeiger
[c]zeiger++;[/c] Inkrementiert den Zeiger selbst, d.h. der Zeiger an sich wird um die Größe (sizeof) des Elements, auf das er zeigt, erhöht. Dabei ist es zunächst mal völlig egal, ob das ein Zeiger auf ein Array ist oder nicht (eine Variable ist ja auch nichts anderes als ein Array aus einem einzigen
]zeiger++;[/c] > Inkrementiert den Zeiger selbst, d.h. der Zeiger an sich wird um die > Größe (sizeof) des Elements, auf das er zeigt, erhöht. [...] Das ist falsch. Der Zeiger wird um die bei der Definition des Zeigers angegebene Größe erhöht und _nicht_ um die Größe des Elements auf das er zeigt
-
Thread
~100 TB Speichern
und PW sind immer gleich lang, also einfach aneinanderreihen und das n'te PW/Hash lese ich mit (sizeof(Hash)+sizeof(PW))*n?
sind immer gleich lang, also einfach > aneinanderreihen und das n'te PW/Hash lese ich mit > (sizeof(Hash)+sizeof(PW))*n? Das geht nicht, da die PW nicht alle gleich lang sind. Ich habe oben ja nicht nur n lange PW berücksichtigt, sondern auch n-m lange Passwörter bis n = m. Du hast also ne
-
Thread
Linux fork und Threads?
{ char tmpfile[256]; char buffer[16]; int fd, len, pid; qprintf(tmpfile, sizeof(tmpfile), "%s.%s", pidfile, "XXXXXX"); if ((fd = mkstemp(tmpfile)) == -1) { error("mkstemp(%s) failed: %s", tmpfile, strerror(errno)); return -1; } if (fchmod(fd, S_IRUSR |
strerror(errno)); close(fd); unlink(tmpfile); return -1; } qprintf(buffer, sizeof(buffer), "%d\n", (int) getpid()); len = strlen(buffer); if (write(fd, buffer, len) != len) { error("write(%s) failed: %s", tmpfile, strerror(errno)); close(fd); unlink(tmpfile);
-
Thread
structs in char*
Endianess bestimmt ist sicher nur ein Versehen. Und die genaue Größe der Struktur ist relativ egal, sizeof & co berücksichtigen das.
so groß, dass es passt. Probleme gibt es nur, wenn Du irgendwelche Dinge selbst ausrechnest (ohne sizeof oder []), vor allem wenn es um Arrays von Strukturen geht. Aber wenn bei Dir doch alles funktioniert, dann OK, freut mich!
-
Thread
BusPirate schießt I2C
= sizeof(AppBuffer); for(w = 0; w < wMaxGet; w += sizeof(AppBuffer)) { // Make sure the last chunk, which will likely be smaller than sizeof(AppBuffer), is treated correctly. if(w + sizeof(AppBuffer) > wMaxGet) wCurrentChunk = wMaxGet - w; // Transfer the data out of the TCP RX FIFO and into our local processing buffer. TCPGetArray(MySocket, AppBuffer,
-
Thread
Datenlogger: Zeitstempel wie speichern?
es ein 32-Bit Wert sei? [c] #include <stdio.h> #include <time.h> int main() { printf("sizeof(time_t): %u\n", (unsigned int)sizeof(time_t)); } [/c] [code] $ ./a.out sizeof(time_t): 8 [/code] Wer heute noch Sekunden seit Epoch in einem 32-Bit-Wert zählen will, hat aus dem Y2K-Problem
-
Thread
Parallel-/ Lpt-Port ansteuern mit C
[c]int giveio(void) { OSVERSIONINFO osvi; int ret = 1; osvi.dwOSVersionInfoSize = sizeof osvi; GetVersionEx(&osvi); if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) { HANDLE h; h = CreateFileA("\\\\.\\giveio", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL
{ OSVERSIONINFO osvi; //Was ist das? int ret = 1; osvi.dwOSVersionInfoSize = sizeof osvi; //sizeof osvi liefert z.B. 5.0 für win2k was dann osvi.dwOSVersionInfoSize zugewiesen wird GetVersionEx(&osvi); if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) //was sind osvi.dwPlatformId
-
Thread
ENC28J60 Basics für Philips LPC213x
httpd_fsdata_file file_processes_shtml[] = {{NULL, data_processes_shtml, data_processes_shtml + 17, sizeof(data_processes_shtml) - 17}}; const struct httpd_fsdata_file file_404_html[] = {{file_processes_shtml, data_404_html, data_404_html + 10, sizeof(data_404_html) - 10}}; const struct httpd_fsdata_file file_files_shtml[] = {{file_404_html, data_files_shtml, data_files_shtml + 13, sizeof(data_files_shtml) - 13}}; Die ersten beiden scheinen die Liste der Dateien zu sein, die einfach als Array gespeichert werden, aber woher kommen diese beiden Zahlenwerte hinter dem Array (dieses
-
Thread
ASCII Verarbeitung optimieren
BufferCnt; .... int main() { ..... while( 1 ) { if( receiveString( Buffer, sizeof( Buffer ), &BufferCnt ) ) cmd_T( Buffer, sizeof( Buffer ) ); } } [/C] Siehst du wie sich jede Funktion nur um den Mist kümmert, für den sie gemacht wurde? Die /receive_string/ kümmert
; pos++; return 0; } void task_uartCommand(void) { if( receiveString( Buffer, sizeof(Buffer)) ) //, &BufferCnt ) ) cmd_T( Buffer ); //, sizeof( Buffer ) ); } [/c] Hier dann noch die getc() (Anm.: Code von Peter Fleury) [c] unsigned int uart0_getc(void) {
-
Thread
EEPROM wird falsch beschrieben oder falsch gelesen
eeprom_write_byte(&ee_check, 0xE7); eeprom_write_block(&stored_ir_data,&ee_ir_data,sizeof(unsigned char)*BUTTONS*6); } else // else, read in the contents { eeprom_read_block(&stored_ir_data,&ee_ir_data,sizeof(unsigned char)*BUTTONS*6);
eine Frage: Wo hast du so was gelernt???? [c] eeprom_write_block(&stored_ir_data,&ee_ir_data,sizeof(unsigned char)*BUTTONS*6); [/c] das ist unterstes Level!!! Wenn sich die Struktur oder der Buffer ändert, bekommt das die Funktion nicht mit! Wie sind denn die sizeof Werte der beiden? Wenn
-
Thread
Atmel SAM TWI Peripherie auf JTAG Pin nutzen
buffer .length = sizeof(data_received) // transfer data size (bytes) }; while(twi_master_read(TWI1, &packet_read) != TWI_SUCCESS); [/c] Nach der Initialisierung sind die Register gleich
.length = sizeof(data_received) // transfer data size (bytes) }; // Perform a multi-byte read access then check the result. while(twi_master_read(TWI1, &packet_read) != TWI_SUCCESS);
-
Thread
uC für 0,20€ CH552 / CH554 von WCH Billig Micro mit USB Funktion, Chip vorstellung
sollte aber problemlos auf einem CH552 laufen. [c] const uint8_t code ConfigDesc[98] = { sizeof(ConfigurationDescriptor), USB_CONFIGURATION_DESCRIPTOR, sizeof(ConfigDesc),0, 3, // 3 interfaces 1, // one config USB_STRING_UNDEFINED,
, sizeof(EndpointDescriptor), USB_ENDPOINT_DESCRIPTOR, 0x2, EP_BULK, 0x40,0x00, 0, sizeof(EndpointDescriptor), USB_ENDPOINT_DESCRIPTOR, 0x82, EP_BULK, 0x40,0x00,
-
Thread
c-Programm - erster Versuch
int main (int argc, char *argv[]) { struct input_event ev[64]; int fd, rd, value, size = sizeof (struct input_event); char name[256] = "Unknown"; char *device = NULL; //Setup check if (argv[1] == NULL){ printf("Please specify (on the command line) the path to the dev event
Obermayer Florian schrieb im Beitrag #3924226: > hallo, > ... > int fd, rd, value, size = sizeof (struct input_event); für Größen ist der Typ size_t angemessener.
-
Thread
Cast Inkrement problem
Zeigerarithmetik ptr++ müßte die Größe des Datentyps bekannt sein, auf den ptr zeigt. Aber was ist sizeof(void) (0 oder was?)? Gruß Martin
selber noch versteht. Unleserlicher geht es kaum noch. > frame->dataLen = (UINT*)ptr; ptr += sizeof(UINT); Das ist die einzige Lösung, die akzeptabel ist.
-
Thread
Austausch C Coden sehr abstrakt
(dann noch > als Erweiterung von GCC) gern benutzt habe. Sowas fasse ich nicht ohne Not an. sizeof(struktur) liefert nicht mehr die reale Datensatzgröße. Damit erforderlich: Noch mehr Obacht mit memcpy() usw. Und der Compiler kann einen nicht warnen. Natürlich gibts in C keinen Copy Konstruktor
noch >> als Erweiterung von GCC) gern benutzt habe. > > Sowas fasse ich nicht ohne Not an. > sizeof(struktur) liefert nicht mehr die reale Datensatzgröße. Es liefert halt die Größe ohne das flexible array, also mit einem leeren Array, genau so, wie es auch hingeschrieben wird. Immer noch besser
-
Thread
STM32 NUCLEOF411RE USART1 mit HC-05 verbinden
HAL_Delay(100); > } sollte sein: [c] while (1) { HAL_UART_Transmit(&huart1, bufftx, sizeof[bufftx], 100); HAL_Delay(100); } [/c] Alternativ kannst du auch den bufftx lassen wie er ist und statt sizeof() strlen() nutzen.
im Beitrag #5509042: > sollte sein: > while (1) > { > HAL_UART_Transmit(&huart1, bufftx, sizeof[bufftx], 100); > HAL_Delay(100); > } > > Alternativ kannst du auch den bufftx lassen wie er ist und statt > sizeof() strlen() nutzen. Sorry, die Hitze... natürlich immer strlen()!!!
-
Thread
Tastatur
{ 120, 102, 3 }, // 'C' ... } }; .... TastenCode = -1; for( i = 0; i < sizeof( Tasten ) / sizeof( *Tasten ); ++i ) { if( ClickPositionX > Tasten[i].Links && ClickPositionX < Tasten[i].Links + Tastenbreite && ClickPositionY > Tasten[i].Oben &&
1 abzuschließen, >um das Ende variabel zu gestalten. Hä? Die Variable-Grösse wird durch das "sizeof"-Gedöns realsiert. Den dritten Parameter in Karl Heinz Struct könnte man für alles mögliche benutzen. Der Tastenindex ist ja schon durch die Schleife vorgegeben (Man muß ich sich nur merken...)
-
Thread
MinGW: __attribute__((packed)) und alignment
ret .seh_endproc .comm foo, 4, 0 .ident "GCC: (tdm64-1) 5.1.0" [/code] bzw. der "sizeof"-Operator liefert 4 zurück.
Walter T. schrieb im Beitrag #4481740: > der "sizeof"-Operator liefert 4 zurück. Ja, sagt ja auch die .comm-Anweisung.
-
Thread
char* in array
hätte ich auch drauf kommen koennen :-( ) Ich koennte noch die laenge pruefen. darf man da sizeof() verwenden?
[c] char wat[12]; char *token; sizeof(wat) /* 12 */ sizeof(token) /* 4 auf 32bit-Pentium */ [/c] Sonst strlen() oder mit dynamisch-statischem Speicher arbeiten: [c] size_t len = strlen(token); char wat[len + 1]; strcpy(wat
-
Thread
virtuelle Com ports anders in c++ als echte?
setting the size // of the input and output buffers with SetupComm. SecureZeroMemory(&dcb, sizeof(DCB)); dcb.DCBlength = sizeof(DCB); fSuccess = GetCommState(hCom, &dcb); if (!fSuccess) { // Handle the error. printf ("GetCommState failed with error %d.\n", GetLastError
Das tut er. [c] SecureZeroMemory(&dcb, sizeof(DCB)); // 1 dcb.DCBlength = sizeof(DCB); // 2 fSuccess = GetCommState(hCom, &dcb); // 3 [/c] Zwar wird die Struktur in (1) nullinitialisiert angelegt, aber in (2) wird
-
Thread
GCC: invalid use of flexible array member
------------------------- Folgendes geht nicht: tempProc->transitions=malloc(BLINK_NUMSTATES*sizeof(struct artsTransition)); (tempProc ist ein artsProcess ) Der GCC sagt: blinkLED.c:23: error: invalid use of flexible array member Was bedeutet das? Da "transisitons" ein Zeiger auf ein Array
Zeigerarithmetik heißt "+1" wohl immer "soviel wie der Typ lang ist addieren", also kann man sich sizeof sparen. Für Mitleser nochmal in Kürze, was geht: //Zeiger auf ein int(array beliebiger Größe) int *test; //Platz für einen 10 Einheiten langen Vektor schaffen test = malloc(10*sizeof(int
-
Thread
Frage zu C Code: Logische Funktion
expressions of different signedness: ‘long unsigned int’ and ‘int’ [-Wsign-compare] 7 | if(sizeof(double) > -1)[/code] Gruss WK
Modellbau_Hund schrieb im Beitrag #7309669: > 0b00001000 > 0b1111111 > ==> false 8 > 255 ist false sizeof() liefert einen Wert vom Typ size_t zurück. Das ist ein unsigned Typ.
-
Thread
Anfängerproblem: Funktionszeiger (void, typedef struct)
, mach_was, 123 }, {"Funktion 2", mach_noch_was, 123 }, }; static int functions_count = sizeof(programm_functions)/sizeof(programm_functions[0]); // Anzahl der Einträge int main() { int i; for (i=0;i<functions_count;i++) { printf("%s\n",programm_functions[i].description
123} }, {"Funktion 2", mach_noch_was, {"Test", 1234} }, }; static int functions_count = sizeof(programm_functions)/sizeof(programm_functions[0]); // Anzahl der Einträge int main() { int i; for (i=0;i<functions_count;i++) { printf("%s\n",programm_functions[i].description
-
Thread
Arduino Serial ganze wörter abfragen
serial_in_command, "reset") ) } // if(strlen(serial_in_command)) memset(&serial_in_command[0], 0, sizeof(serial_in_command)); stringComplete = false; } // void inSTR_Auswertung(void) void serialEvent(void) { while (Serial.available()) { char incomingByte = (char)Serial.read(); if(
erledigt ist loesche serial_in_command *serial_in_command=0; // memset(&serial_in_command[0], 0, sizeof(serial_in_command)); } // void inSTRauswertung(void) [/c]
-
Thread
Struct array in den EEprom schreiben und lesen
t=0; t<sizeof(cmdP); t++) { *((char*)&CMD[iP] + t) = EEPROM.read(adrIP + (iP + sizeof(cmdP)) +t); } Serial.println("Wert="); Serial.print(CMD[iP].Befehl); Serial.println
int t=0; t<sizeof(cmdP); t++) { EEPROM.write(adrIP +(iP + sizeof(cmdP))+ t, *((char*)&CMD[iP] + t)); } //Serial.println("Wert="); //Serial.print(CMD[iP].Befehl); //Serial.println
-
Thread
Schaltung geht, ziemlich genau 24H
} } /* eeprom_write_block(&irmp_data.command, (void *) 0x02,sizeof(&irmp_data.command)); eeprom_write_block(&irmp_data.address, (void *) 0x05,sizeof(&irmp_data.address)); eeprom_write_block(&irmp_data.protocol, (void *) 0x10,sizeof(&irmp_data.protocol
-
Thread
Parameter in Funktion speichern. Geht das überhaupt? C
, pActualParameters, sizeof(paramsTypeDef)); } } void main() { paramsTypeDef paramsA; paramsTypeDef paramsB; paramsTypeDef paramsC; paramsTypeDef actualFaders; actualFunctionTypeDef actualFunction = isFunctionA
Stefan K. schrieb im Beitrag #5212161: > memcpy (pSavedparameters, pActualParameters, sizeof(paramsTypeDef)); wieso nicht [c] *pSavedParameters = *pActualParameters; [/c] ?? Das reduziert (mindestens) eine Fehlerquelle und erlaubt dem Compiler, so zu optimieren, wie er das für richtig
-
Thread
struct aus rohbytes initialisieren
// jetzt will ich "sensordaten" befüllen // mit memcpy geht es,statt laenge geht // auch sizeof(sensordaten) memcpy(&sensordaten, data, laenge); // geht das auch mit einer Zuweisung und Typumwandlung // des uint8_t *daten? // wie muss ich hier casten? sensordaten = (??? ) daten
jetzt will ich "sensordaten" befüllen > // mit memcpy geht es,statt laenge geht > // auch sizeof(sensordaten) > memcpy(&sensordaten, data, laenge); > > // geht das auch mit einer Zuweisung und Typumwandlung > // des uint8_t *daten? > // wie muss ich hier casten? > sensordaten
-
Thread
2 Sketche vereinen
MirfHardwareSpi; Mirf.init(); Mirf.setRADDR((byte *)"serv1");// Name des Servers Mirf.payload = sizeof(unsigned long); Mirf.config(); Serial.println("Empfangen..."); } void loop(){ byte data[Mirf.payload]; // Hier wird der empfangene byte gespeichert if(!Mirf.isSending() &
Mirf.setRADDR((byte *)"clie1"); //Der Name bzw. Adresse des Clienten wird erstellt Mirf.payload = sizeof(unsigned long); // Hier wird die Laenge des Buffers Mirf.config(); //Laden der Konfigurationsdatein Serial.println("Beginn ... "); } void loop(){ unsigned long time = millis()
-
Thread
USB Enumeration
16bit Werte direkt in die Deskriptoren einzutragen. Je nach Compiler und Proz geht das schief. sizeof() funktioniert auch nicht immer. Diese Teile musst du in jedem Fall anhand des LST files prüfen. Thomas
Das sizeof() liefert den richtigen Wert (0x12).
-
Thread
volatile struct komplett nullen
LearnInModeActive; ... }standalone; [/c] So war es einst angedacht: [c] memset(&standalone, 0, sizeof (standalone)) [/c] Hat jemand einen Tip? Danke, Tobi
Dennis Heynlein schrieb im Beitrag #4170290: > memset((struct standalone_data*)&standalone, 0, sizeof (standalone)); dann kann man es auch gleich auf void* casten memset((void*)&standalone, 0, sizeof (standalone));
-
Thread
(Zeiger auf ) Array von Zeigern
*MyStructPointer_local; for (MyStructPointer_local=MyStructPointer; MyStructPointer_local < sizeof MyStructPointer / sizeof (MyStructPointer[0]); MyStructPointer_local++) { AnotherFunction(MyStructPointer_local); } };[/c] Ich bekomme allerdings eine Warnung: [code]warning: passing
Davon abgesehen, du hast in der Funktion keine Chance über den Pointer und sizeof an die Größe des Arrays zu kommen.
-
Thread
MSP430 8 Werte von ADC über RS232 senden, geht nicht.
raus!!! void SendUSART0 (void) { char i, j; for (j=0; j<8; j++) { for (i=0; i < sizeof Digit[j]; i++) U0TXBUF = Digit[j]; } } */ void Init_ADC(void) { P6SEL = 0xFF; // Analogeingänge A0 - A7 (P6.0 - P6.7) ADC12CTL0 = ADC12ON + MSC + SHT0_12
__interrupt void usart0_tx (void) { char i, j; for (j=0; j<2; j++) { for (i=0; i < sizeof Digit[j]; i++) TXBUF0 = Digit[j]; } } [/c]
-
Thread
CANopen Implementierung "nur" für Sensordaten
[0]=Red; frame_led.data[1]=Green; frame_led.data[2]=Blue; write(sfd,&frame_led,sizeof(struct can_frame));
index for AI Process Value 16Bit message.subindex = 0x01; // Channel 1 write(sfd,&message,sizeof(struct CANopen_message)); // receive SDO message read(sfd,&message,sizeof(struct CANopen_message)); ai_val = (int) (message.data[0] + message.data[1]); printf("Messwert: %d\n"
-
Thread
Türklingel per ESP32 (WLAN, SIP) an Fritzbox
.. ein memset... wie folgt einfügen: [c] wifi_config_t wifi_config; memset(&wifi_config, 0, sizeof(wifi_config)); // insert this line to set memmory of struct to 0 strncpy((char*)wifi_config.sta.ssid, CONFIG_WIFI_SSID, sizeof(wifi_config.sta.ssid)); strncpy((char*)wifi_config.sta.password, CONFIG_WIFI_PASSWORD, sizeof(wifi_config.sta.password)); wifi_config.sta.bssid_set = false; [/c] Ansonsten eine tolle Idee und Umsetzung. VG Didi
-
Thread
Anzahl der Array Elemente
char data_string[]) // gibt einen String aus { unsigned short str = 0; for(str=0; str<(sizeof(data_string)/sizeof(char));str++) { LCD_OutChar(data_string[str]); } } [/c] danke schonmal für eure Hilfe :)
Feld übergeben, sondern immer nur als Zeiger auf das unterste Element. Dementsprechend liefert dir sizeof(data_string) nicht die Feldlänge in Byte, sondern die Größe eines Zeigers in Byte. Die Länge des Strings musst du immer entweder getrennt an eine Funktion übergeben, oder es wird im Feld ein Element
-
Thread
Sonderzeichen LCD HD44780 kompatibel
zeigt wie es geht: #define P00(s) (__extension__({static const PROGMEM hd44780::a00::str<sizeof L##s/2> c(L##s); c.a;})) Es ist tatsächlich ein weiteres Makro erforderlich. A00 und P00 können nicht zusammengelegt werden. Der Typecast-Operator ist dazu überflüssig. Die Anwendung ist wie bei
15 markiert werden: #define F00(s) (__extension__({static const PROGMEM hd44780::a00::str<sizeof L##s/2> c(L##s); c.a+0x8000;})) Die Warnung „index out of range“ muss unterdrückt werden. Die Anwendung ist dann: lcd_puts(F00("Test ÄÖÜäöüß °C kΩ")); *lcd_puts* muss dann zur Laufzeit
-
Thread
Multibyte write
die Funktion [c] HAL_I2C_Master_Transmit(&hi2c1, ep1_address_write, &FORCE_ANA_CTRL_SIGS, sizeof(FORCE_ANA_CTRL_SIGS), 1000);[/c] Dabei ist ep1_address_write die Deviceadresse &FORCE_ANA_CTRL_SIGS die Adresse des Registers vom Sensor, das geändert werden soll (angegeben als Daten) und im
Ich habe die FunktionHAL_I2C_Master_Transmit(&hi2c1, ep1_address_write, > &FORCE_ANA_CTRL_SIGS, sizeof(FORCE_ANA_CTRL_SIGS), 1000); Wie ist die Signatur der Funktion? Um welchen Sensor handelt es sich? Grüße Oliver
-
Thread
ESP 32: Smarthome Beet über MQTT: FAST fertig
mit dem Schalter sein, das überprüfe ich am WE [c] void setupPins() { for (int i = 0; i < sizeof(ausgangspins) / sizeof(ausgangspins[0]); i++) { pinMode(ausgangspins[i], OUTPUT); digitalWrite(ausgangspins[i], LOW); } pinMode(waterSensorPin, INPUT); // Eingangspin für Wasserstandssensor
Serial.println("-- Subscribe to properties"); client.setCallback(callback); for (int i = 0; i < sizeof(properties) / sizeof(properties[0]); i++) { if (client.connected()) { String topic = String(MQTT_BASE_TOPIC) + "/" + String(properties[i]); if (client.subscribe(topic.c_str())) {
-
Thread
Ring-Puffer Indexierung
]; dann degeneriert der Ausdruck 'Tmp' alleine in den meisten Fällen (eine Ausnahme wäre zb. sizeof) zu einem Pointer auf das erste Element von Tmp. So zb in foo( Tmp ); Hier degeneriert Tmp zu einem Pointer auf Tmp[0]. Man könnte auch salopp sagen, dass 'Tmp' synonym ist zu '&Tmp[0]'
Pointer-Arithmetik wird dbei Addition eines Integer-Typen zu einem Pointer, der Integer-Typ zuerst mit dem sizeof des Pointer-Quelltyps multipliziert. Obiges ist daher equivalent zu: *( ((unsigned char*)a) + b * sizeof( *a ) ) Diese Transformation macht der Compiler intern, wenn er auf einen Ausdruck
-
Thread
C-Variablen aus I2C EEPROM "booten". Wie deklarieren
auf die Struct und die Startadresse im EEPROM zu übergeben, sowie die Größe der Struct in Byte (sizeof(struct)). Und die andere kopiert vom RAM in den EEPROM. Entweder es gibt schon eine eeprom.h, die beide Routinen verfügbar macht oder Du schreibst sie selber.
Struct und die > Startadresse im EEPROM zu übergeben, sowie die Größe der Struct in Byte > (sizeof(struct)). > Und die andere kopiert vom RAM in den EEPROM. > Entweder es gibt schon eine eeprom.h, die beide Routinen verfügbar macht > oder Du schreibst sie selber. Ja danke, ich glaube, so
-
Thread
Größe eines Objektes
m_iAnzSpur; }; [/c] Jetzt wird ein Objekt dieser Klasse angelegt, anschließend möchte ich per sizeof die Größe dieses Objekts ermitteln. Sizeof gibt mir einen Wert von 1624 zurück. Das würde ja bedeuten, dass das Objekt knapp 1,6 kB braucht! Wie kommt das denn bitteschön? Wenn ich das mal grob im
zusätzliche Padding Bytes * (Die sizeof kann nicht 0 sein)
-
Thread
Probleme mit Textdatei
256;m++) buffer[m] = 111; myfile = fopen( "log_datei.txt" , "w+" ); fwrite (buffer , sizeof(buffer[0]) , sizeof(buffer) , myfile ); fclose(myfile); [/c] Ich verstehe nicht wo der Fehler liegen könnte.
aber schon aufgefallen sein das nicht mal ein trennzeichen vorhanden ist. for( int i = 0; i < sizeof( buffer ); ++i ) { fprintf( myfile, "%d;", buffer[i] ); } nicht getestet, aber so sollte es gehen