-
Thread
struct oder array wählen?
5 #define SATURDAY 6 #define SUNDAY 7 void Init() { uint8_t i; for( i = 0; i < sizeof(Data)/sizeof(*Data); ++i ) { Data[day].Values = NULL; Data[day].nrAllocated = 0; } } uint8_t Allocate( uint8_t day, uint8_t nrValues ) { struct Entry* newData = realloc( Data[day].Values, nrValues * sizeof( *Entry.Values ) ); if( newData == NULL ) { // Out of memory // tja. Was soll jetzt geschehen return FALSE; } Data[day].Values = newData; Data[day].nrAllocated = nrValues
-
Thread
Problem mit ADC-Wert glätten für PWM LUT
Programmes. Der Compiler kennt die Grösse deines Arrays. Versuchs mal so: if(dutycalc >= sizeof(DutyCycleLUT)) { dutycalc = sizeof(DutyCycleLUT) - 1; }
-
Thread
C pointer in Struct-Array übergeben
= { {"Zähler 1", &cnt}, {"Zähler 2", &cnt2} }; uint8_t nmbr_of_uint32_t_variables = sizeof(uint32_t_variablen)/sizeof(*uint32_t_variablen); [/c] mit der Funktion void MP_update_array(void) möchte ich nun das Array tx_value_buffer updaten. wie folgt: [c] void MP_update_array(void)
kannst Du auch folgendes machen: *reinterpret_cast<uint32_t*>(pos) = *value; pos += sizeof(uint32_t); So bleibt die Endianess aber gleich! Wenn Du aber Little Endian bist und Big Endian rausschreiben willst wie in Deinem Code (Highbyte first), musst Du die Endianess vorher drehen.
-
Thread
Bug bei FOR-Schleife ?
Bei statischen Vektoren kann man das elegant so lösen: [c] #define N_VECT(v) ( sizeof(v) / sizeof (*(v)) ) int vector[100] = { ... } for (int i = 0; i < N_VECT(vector); i++) .. [/c]
-
Thread
Probleme nach dem Optimieren "-O1"
= 0x0000; /* Füllen der Puffer mit definierten Werten */ memset(hex_buffer, 0x00, sizeof(hex_buffer)); memset(flash_data, 0xFF, sizeof(flash_data)); /* Interrupt Vektoren verbiegen */ temp = MCUCR; MCUCR = temp | (1<<IVCE); MCUCR = temp | (1<<IVSEL);
program_page((uint16_t)flash_page, flash_data); memset(flash_data, 0xFF, sizeof(flash_data)); flash_cnt = 0; flash_page_flag = 1; } uart_putc(XON
-
Thread
433 Funksteckdose mit RFM69 steuern
rf69.spiWrite(RH_RF69_REG_38_PAYLOADLENGTH, 0); } void loop() { rf69.sendRaw(dataON, sizeof(dataON)); rf69.waitPacketSent(); } [/code] Die SendRaw Funktion habe ich selber in die RadioHead Library eingebaut und sieht so aus: [code] bool RH_RF69::sendRaw(const uint8_t* data, uint8
verwende ich folgend Code im loop: [code] setOpMode(RH_RF69_OPMODE_MODE_RX); uint8_t buf[sizeof(RH_RF69_MAX_MESSAGE_LEN)]; // RH_RF69_MAX_MESSAGE_LEN uint8_t len = sizeof(buf); uint8_t readLength = rf69.readFifoTest(buf, len); //Serial.print("got reply: "); for (int i =
-
Thread
String to unint16
nicht was du meinst ich versuche es mit: char string[11]; uint16_t ein2=0; uart_gets( string, sizeof( string ) / sizeof( string[0] ) ); ein2=atoi(string);
-
Thread
union / struct löschen
reicht, alle Bits auf 0 zu setzen tut es das spätestens in C++ verpönte memset( &ProzessStatus, 0, sizeof ProzessStatus ) . @Micha: Er hat aber einen Namen hinter die namenlose Typdefinition geschrieben. Dass definiert dann schon eine Variable (mal abgesehen von dem fehlenden "}". Schöne Grüße
ProzessStatus.Bit.RunProg" auf 0 gesetzt. Versuche es dann die C++ Anweisung "memset( &ProzessStatus, 0, sizeof ProzessStatus );" Dieses funktioniert, aber der ASM Code ist größer als bei 8 Einzelzeilen. möchte zwar keine Durcheinander von C und C++, aber wenn es nicht anderst geht, dann muß es sein. ProzessStatus.Bit.RunProg
-
Thread
Uart Interrupt Problem
while(1) { //uart_puts("T\n"); if(uart_str_complete==1) { //uart_gets(Line, sizeof( Line ) ); //uart_puts(Line); Clear_LCD(); GotoXY_LCD(0,0); LCD_PutString((const char*)uart_string); uart_puts((const char*)uart_string); LCD_PutString_P
while(1) { //uart_puts("T\n"); if(uart_str_complete==1) { //uart_gets(Line, sizeof( Line ) ); //uart_puts(Line); Clear_LCD(); GotoXY_LCD(0,0); LCD_PutString((const char*)uart_string); uart_puts((const char*)uart_string); LCD_PutString_P
-
Thread
Fühlt sich der gcc hier veralbert?
, dass ein char pointer in ein Array nach einem increment 4 Bytes weiter zeigt. Oder ein pChar + sizeof(char) äquivalent zu pChar + 4 ist. Aber sizeof(char) trotzdem 1 ist. Und folglich muss unterschieden werden, ob der ponter in ein statisches oder in ein allokiertes array zeigt. Oder irgendwie so
wieder direkt aufeinander folgend im Speicher. Um es nochmal klipp und klar zu sagen: 1) sizeof(char) ist immer 1. 2) wenn du einen Zeiger auf ein char inkrementierst, dann wird er um 1 erhöht. 3) in einem Array liegen alle Zeichen direkt hintereinander. 4) das ist völlig unabhängig vom Alignment
-
Thread
uint16 - uint16 = negative zahl?
Das kommt drauf an: [c] if (sizeof(uint16) < sizeof(int)) signed; else unsigned; [/c] Grund: Operanden kleiner int werden auf int erweitert und erst dann gerechnet.
-
Thread
C: Pixel auf dem Bildschirm ausgeben
{ "Hans", "Rosenthal" }, { "Barbara", "Salesch" } }; #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x)) int sortFirstName( const void *elem1, const void *elem2 ) { return strcmp( ((struct Person*)elem1)->FirstName, ((struct Person*)elem2)->FirstName ); } int sortFamilyName
( ARRAY_SIZE( member ) * sizeof( *Indices ) ); for( i = 0; i < ARRAY_SIZE( member ); ++i ) Indices[i] = i; qsort( Indices, ARRAY_SIZE( member ), sizeof( *Indices ), sortByIndex ); for( i = 0; i < ARRAY_SIZE( member
-
Thread
Konstruktion einer kontextfreien Grammatik
wo ich in der Grammatik das Typecasting, den Trinären-Operator "(bool) ? (bool) : (bool)", einen sizeof()-Operator, die Deklaration eingener Funktionen, sowie eine Fehlerbehandlung mit REPORT oder THROW einbauen muss. Da diese Grammatik auch die Deklaration von Feldern ermöglicht, wäre es natürlich
unary | ++ unary | -- unary | unary ++ | unary -- | ( BASIC ) unary | SIZEOF BASIC unary | SIZEOF ID unary | call call -> ID ( optparams ) | factor optparams -> params | EPSILON params -> params , bool | bool factor -> ( bool ) | loc
-
Thread
Array an funktion übergeben möglichkeiten
in C: [c] $ cat test.c #include <stdio.h> void f(char (*buffer)[10]) { printf("%zu\n",sizeof(*buffer)); } int main() { char buffer[10]; printf("%zu\n",sizeof(buffer)); f(&buffer); return 0; } $ gcc -Wall test.c -o test $ ./test 10 10 [/c] Beispiel für Array ohne Zerfall
-
Thread
Gleichung lösen
Variablen sind alles als double definiert. Das hilft dir bei WinAvr auch nicht viel. Bei WinAvr gilt: sizeof(double) == sizeof(float) Und je nachdem in welchem Wertebereich deine Variablen liegen kann eine 08/15 Implementierung dieser Terme alle möglichen Ergebnisse liefern: Von ziemlich genau bis hoffnungslos
-
Thread
Sinnvoll EEPROM Adressen speichern?
anstatt die Adressen per Hand einzutragen, dass den Compiler machen lassen? Mir schwebt irgendwas mit sizeof(x) vor, aber eine Umsetzung fehlt mir noch dazu. Jemand ne Idee? Ingo
for( uint8_t i = 0; i < NR_DEVICES; i++ ) eeprom_read_block( &(Devices[i].core), &storage[i], sizeof(*storage) ); } int main() { ... coreToSRAM(); // Die fixen Gerätewerte aus dem EEPROM wieder herstellen ... } [/C] Kein Mensch muss irgendwelche EEPROM Adressen wissen.
-
Thread
ESP 8266 ESP-NOW Webserver
a string char macStr[18]; Serial.print("Packet received from: "); snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]); Serial.println(macStr); memcpy(&incomingReadings, incomingData, sizeof(incomingReadings)); board["id"] = incomingReadings.id; board["temperature"] = incomingReadings.temp; board["humidity"] = incomingReadings.hum; board["temp1"] = incomingReadings.temp1
-
Thread
float oder double seriell senden
residiert. Das kann man zb so machen: unnion Wandler { float Wert; unsigned char Bytes[ sizeof( float ) ]; }; int main() { float Value = 3.4; union Wandler wandel; wandel.Wert = Value; for( i = 0; i < sizeof( float ); ++i ) { Sende_ein_byte( wandel.Bytes[i] ); }
-
Thread
Mittels Switch Case zwischen Unterprogrammen in der main wechseln
tracking}; > > /* ... */ > > wahl=1; > machwasichwill[wahl](); [c] machwasichwill[wahl < sizeof(machwasichwill) / sizeof(machwasichwill[0]) ? wahl : 0](); [/c] Dergute W. schrieb im Beitrag #5189673: > Obacht: wahl darf hier nur 0,1 oder 2 sein - sonst droht ewige > Verdammnis. Nicht
-
Thread
Zuweisung an eine member-Variable in einem struct erfolgt an einer falschen Adresse
, damit mit glatten 32-Bit-Zugriffen gearbeitet werden kann. Vergleiche einfach mal das, was /sizeof/ von Deinen Strukturdefinitionen hält und was Du durch Auszählen der Elemente herausbekommst.
struct in_addr sin_addr; // 4 Byte char sin_zero[8]; // 8 Byte };[/c] sizeof(sockaddr_in) = 16 Es scheinen also keine Padding-bytes im struct eingefügt zu sein. Aber auch wenn das so sein sollte, das erklärt doch nicht, warum die Anweisung [c]sockaddr_in->sin_addr.s_addr
-
Thread
Handhabung globaler Variablen
dann aber auch nur für "simple" Initialisierungen. immerhin tut: [c] #define countof(a) (sizeof(a) / sizeof(*(a))) #define TxBufferSize (countof(TxBuffer) - 1) EXTERN volatile uint8_t TxBuffer[] INIT("\n\rbla bla bla\n\r"); [/c] aber offensichtlich gibts keine wirkliche Patentlösung
-
Thread
AVR unverständliche for Schleife
//-- Hilfsvariablen --------------------- uint8_t u8Idx; uint8_t u8Max = (uint8_t) ( sizeof(PGM_STAR_D ) / sizeof(PGM_STAR_D[0]) ); //-- Port auf Ausgang ------------------- DDRC = 0xFF; DDRD = 0xFF; //-- Schleife ------------------------
-
Thread
Externer struct zugriff
Wenn ich im eeprom.c z.B. "Hallo Welt!" schriebe mit [c] memcpy(struct_eeprom_data, "Hallo Welt!", sizeof("Hallo Welt!"); [/c] (Mit dem Debugger kontrolliert ist das "Hallo Welt!" auf der stelle 0 wie es auch sein sollte) sehe ich im data.c zwar das "Hallo Welt!" aber nicht an der selben stelle sonder
den ich nicht finde. Als Test habe ich mit: [c]memcpy(struct_eeprom_data, "Hallo Welt!", sizeof("Hallo Welt!");[/c] Versucht einen String zu kopieren und diesen dann aus dem anderen File zu lesen mit dem Debugger. Das hat nichts mit der Ansteuerung vom EEPROM zu tun. Es hat auch nichts mit
-
Thread
Ansi C: Convertierung int to string
addr.sin_addr.s_addr = htonl (0xc0a8010c); res = getnameinfo ((struct sockaddr*) &addr, sizeof (addr), hostname, sizeof (hostname), NULL, 0, NI_NUMERICHOST); if (res == 0) { printf ("Adresse als String: %s\n", hostname); return 0; } else { printf ("Fehler: %s\n", gai_strerror
-
Thread
Promgrammfehler in Arduino
switch ( statusSchalter() ) { case HIGH: //Zufallsmodus //Zufallswert i zwischen 0 und sizeof fktZeigerArray-1 auswürfeln int i = random ...; // siehe Arduinodoku wie man Zahlen auswürfelt. fktZeigerArray[i]; //entspr. Funkt wird aufgerufen //soll das mehrmals
}, { HIGH, 400 }, { LOW, 200 } }; unsigned int actSchritt; #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x)) void loop() { // ---- Position A digitalWrite( 5, Sequence[actSchritt].Status ); delay( Sequence[actSchritt].Dauer ); actSchritt++; if( actSchritt == ARRAY_SIZE
-
Thread
String sortieren mit Qsort
mache ich das also mit dynamischer Speicherverwaltung? [c] qsort((void *)FileList, TotalFileCount, sizeof(fileListString), compare); // GEHT SO LOGISCHERWEISE NICHT [/c] Gruß
Got it: Der Aufruf muss so lauten: qsort(FileList, TotalFileCount, sizeof(char *), compare); // Sort
-
Thread
Linux, accept() file handle
void show_fd0() { char buf[256]; ssize_t n; n = readlink("/proc/self/fd/0", buf, sizeof(buf)-1); if (n >= 0) { buf[n] = 0; puts(buf); } else perror("readlink"); } [/c]
liegenden FD-Parameter mit 0. Kann z.B. bei einem memset() oder bzero() passieren, wenn man nicht sizeof benutzt.
-
Thread
Linux C: Serielle Daten loggen und verlorene Zeichen
{ perror(MODEMDEVICE); exit(-1); } tcgetattr(fd,&oldtio); bzero(&newtio, sizeof(newtio)); newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD; newtio.c_iflag = IGNPAR; newtio.c_oflag = 0; newtio.c_lflag = ICANON; newtio.c_cc[VINTR] = 0; newtio.c_cc[VQUIT]
oldtio); /* save current port settings */ // Konfiguration der Schnittstelle bzero(&newtio, sizeof(newtio)); newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD; newtio.c_iflag = IGNPAR; newtio.c_oflag = 0; // set input mode (non-canonical, no echo,...) newtio.c_lflag = 0;
-
Thread
STM32F10x EEPROM Emulation
/* EEPROM Init */ EE_Init(); //schreibt das sampleData struct ins Flash length = (sizeof(sampleData) + 1) / 2; vaddr = 0; for (i=0; i<length; i++) { EE_WriteVariable(vaddr, *dataPtr); vaddr ++; dataPtr++; } // zur kontrolle struct wieder auslesen vom Flash length = (sizeof(readBackData) + 1) / 2; vaddr = 0; for (i=0; i<length; i++) { EE_ReadVariable(vaddr, readBackPtr); vaddr++; readBackPtr++; } Im readBackData struct müssen nun die
-
Thread
EEPROM Fehler.
e_checksum; void save_data() { eeprom_write_block((const void*)dset, (void*)&globstate, sizeof(struct glob)); eeprom_write_byte(&e_checksum, CHKSUM); } void init_data() { /* Try to read the dataset from EEPROM */ if(eeprom_read_byte(&e_checksum) == CHKSUM) { lcd_string("Reading EEPROM"); eeprom_read_block((void*)dset, (const void*)&globstate, sizeof(struct glob)); } else { /* Dataset is not in EEPROM, reset it */ dset = malloc(sizeof(struct glob)); if(dset == 0) { lcd_string("MEMORY ERROR!!!"); } }
-
Thread
STM32L4 - DMA Puffer Leer
rxbuf[BLOCK_SAMPLES*4]; while(1) { stat = HAL_SAI_Receive(&hsai_BlockB1, (uint8_t*) txbuf, sizeof(txbuf) / 2,10); stat = HAL_SAI_Transmit(&hsai_BlockA1, (uint8_t*) txbuf, sizeof(txbuf) / 2,10); } Soweit so schön. Wenn ich dann aber auf DMA umbaue: if (HAL_OK != HAL_SAI_Receive_DMA(&hsai_BlockB1, (uint8_t*) rxbuf, sizeof(rxbuf) / 2)) { DebugLog("HAL_SAI_Receive_DMA fail 1\r\n"); Error_Handler(); } if (HAL_OK != HAL_SAI_Transmit_DMA(&hsai_BlockA1, (uint8_t*) txbuf, sizeof(txbuf) / 2)) { DebugLog("HAL_SAI_Transmit_DMA
-
Thread
Suche Hilfe bei Optimierung Bootloader
buffer */ void uartPuts(const char *sb) { int len = strlen(sb); if ((txpos+len) < sizeof(txbuffer)) { strcat(txbuffer, sb); txpos+=strlen(sb); } } #define MSG "BOOT" /*SPM_PAGESIZE "\r\n"*/ /** * setup UART comm port */ void initUart(uint16_t baud
Das hier [c] void uartPuts(const char *sb) { int len = strlen(sb); if ((txpos+len) < sizeof(txbuffer)) { strcat(txbuffer, sb); txpos+=strlen(sb); } } [/c] ist auch viel zu kompliziert [c] void uartPuts(const char *sb) { while( *sb && txpos < sizeof(txbuffer
-
Thread
uint16_t als ASCII mit HAL_UART_Transmit
32bit-Prozessor handelt, und die struct nicht "gepacked" wurde. Für sowas gibt es dann aber auch "sizeof()"... Harry L. schrieb im Beitrag #6390355: > Du kennst den Unterschied zwischen Binär-Daten und > human-readable-Strings? Dem sollte man kennen.
printf("Size is %ld ", sizeof(bhy_data_quaternion_t)); 64 Bit Linux auf X86 12 32 Bit Linux auf Raspi 12
-
Thread
Char Array in einzelne Variable
zeichen wirklich im Speicher Das lässt sich ganz leicht herausfinden: [c]printf("%d bits", 8 * sizeof(char));[/c] Stefan us schrieb im Beitrag #3917908: > Die Pointer Syntax (buffer++) geht stillschweigend davon aus, dass ein > char ein byte groß ist Komisch, bei double, int, stuct,... Arrays
sizeof(char) ist per Definition 1 Allerdings sind 8 Bit nur die Mindestgröße für ein char. Wie groß ein char ist, kann man mit dem Makro CHAR_BIT feststellen. [c]printf("%d bits", CHAR_BIT);[/c]
-
Thread
C: Variablen in Bedingungsanweisungen definieren
auf size_t ein design-flaw. Aber man kann auch anderer Meinung sein aus Gründen der Kongruenz zu sizeof(). Außerdem hätte man sich dann auch den nested typ-alias size_type sparen können, wenn Größenangeben /immer/ size_t sind. Aus Rückwärtskompatibilitätsgründen wird daran aber (im Moment) nichts geändert
size_t inkompatibel definiert, lieber bei jemand anderem anschauen. Ist beides mal der Typ, den sizeof() zurückgibt. Das gibt bestimmt ein paar lustige Makro-Effekte. Je nach Front-End und dann mit Text-Ersetzung, mal dies mal jenes... Und dann einfach mal Gentoo mit KDE durchbauen lassen. vn nn
-
Thread
PIC32 Daten im Flash ablegen
DataEEInit(); // Konfiguration aus EEPROM in RAM kopieren DataEEReadArray(&AppConfig, EEPADR_APPCONF, sizeof(AppConfig)); [/c] oder zum Wegspeichern: [c] // Konfiguration aus RAM in EEPROM kopieren DataEEWriteArray(&AppConfig, EEPADR_APPCONF, sizeof(AppConfig)); PackEE(); [/c]
-
Thread
Warum wird aus einem right-shift eines uint8_t ein 16-Bit arithm.-shift beim avr-gcc
populäreren Architektur reproduziert werden kann. Hier nach Möglichkeit auf einer, welche wie avr sizeof(int) > sizeof(word) erfüllt, d.h. >> promotet zu int.
-
Thread
Arrays können max 32768 Byte groß sein. Warum nicht 65534?
des Feldes, sondern auch am Datentyp, da die Adressrechnung ja &a[0]-&a[N] intern als &a - &a+N*sizeof(T) durchgeführt wird. Eigentlich sollte das beim AVR Flash speicher auch mit uint16_t funktionieren, da der ja 16 Bit breit ist, tut es aber nicht. Warum? Da bin ich überfragt. BTW, das zweite Codesegment
> da die Adressrechnung ja intern als &a - &a+N*sizeof(T) > durchgeführt wird Kaum. Jedenfalls wenn die Adressen nicht konstant sind - das war nicht ganz so wörtlich gemein. Ausführlicher: uint16_t *p1 = ?; // Wert: &a[0], dem Compiler nicht bekannt
-
Thread
UART Receive vom PC. Erstes Zeichen ist ständig 0
object.connect("COM4"); object.sendArray(sendBuffer, sizeof(sendBuffer)); object.disconnect(); [/c] Empfangsseite Mikrocontroller, im UART-receive-Interrupthandler: [c] if(USART_GetITStatus(USART2, USART_IT_RXNE)) { USART_ClearITPendingBit
50) und einmal Sleep(200) jeweils zwischen object.connect(); und object.sendArray(sendBuffer, sizeof(sendBuffer));
-
Thread
SPI will nicht richtig
<util/delay.h> int Tabelle[] = {1,2,4,8,16,32,64,128,64,32,16,8,4,2 }; int ElementeAnzahl = sizeof(Tabelle) / sizeof( int ); int Zaehler; int main (void) { DDR_SPI = (1<<DD_MOSI) | (1<<DD_SCK) | (1<<DD_RCK); SPCR = (1<<SPE) | (1<<MSTR) | (1<<SPR0) ; while (1) { for (Zaehler
-
Thread
[C-Code Optimierung] RDM responder
STARTADR_DMX: DmxField[RxCount_8++]= DmxByte; //get channel if (RxCount_8 > sizeof(DmxField)) { Flags |= (1<<EVAL_DMX); //reception finished RxState = IDLE; //all ch received -> wait for break } break;
noch um nen Punkt erweitern: case SOFTWARE_VERSION_LABEL: getMsgP(Software_V_Label_Msg, sizeof(Software_V_Label_Msg)); rdm->PDLen= sizeof(Software_V_Label_Msg); rdm->PortID= RESPONSE_TYPE_ACK; //Acknolege respondMsg(); break; Und was mir in deinem Code auch
-
Thread
2 Arrays miteinander vergleichen
char u[5] = {1, 2, 3, 4, 6}, v[5] = {1, 2, 3, 4, 5}; while(1) { if (!memcmp(u, v, 5*sizeof(char))){ printf("7\n"); } else{ printf("8\n"); } } return 0; } [/c]
Könnte gehen: [c] unsigned char i; unsigned char sendok; sendok = 0; for (i=0;i<sizeof(u);i++){ if (u[i]!= v[i]){ sendok++; } } if (sendok){ /* Unterschiedlich */ } else{ /* Gleich */ } [/c]