-
Thread
Probleme mit pgmspace. ATMega1284P hangt sich durch strcpy_P auf
) { ili9341_fillrect((x - 49), (y - 1), clrWidth, clrHeight, BLACK); snprintf_P(strIP, sizeof(strIP), PSTR("%03d"), eIP[ipByteSelector - 1]); ili9341_combo((x - 49), y, WHITE, BLACK, 2, 3, 0, 0, strIP); } [/code] Es wird dort ja erst geprüft ob der Selector größer als 1 ist(Später
, 111, 111}; void setup() { // put your setup code here, to run once: memset(strIP, 0x00, sizeof(strIP)); Serial.begin(115200); } void loop() { // put your main code here, to run repeatedly: sprintf_P(strBuffer, PSTR("IP : %d03.%d03.%d.%d"), MyIP[0], MyIP[1], MyIP[2], MyIP[3]);
-
Thread
Kleine Positiv/Negativ Rechnung in C
Hab den Standard grad nicht rumliegen, aber bei "unsigned" <=> "signed" gleicher Bitbreite und sizeof(int) aufwärts gewinnt "unsigned". Bei sizeof(unsigned) < sizeof(signed) hingegen gewinnt "signed". Aber erst ab ANSI C89, bei K&R was dies schwach oder garnicht definiert und oft als "unsigned gewinnt
Hab den Standard grad nicht rumliegen, aber bei "unsigned" <=> "signed" > gleicher Bitbreite und sizeof(int) aufwärts gewinnt "unsigned". > ist ein normaler unary operator wie ~0 oder !1. Folglich ist > ((int)a - b) > identisch mit > (((int)a) - b) > als von den Typen her > signed -
-
Thread
AVR32 EVK1100: Auf Spare SPI (SPI0) schreiben erzeugt TIMEOUT
AVR32_PM, FOSC0, OSC0_STARTUP); // Assign GPIO to USART. gpio_enable_module(USART_GPIO_MAP, sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0])); // Assign GPIO to SPI. //gpio_enable_module(USART_SPI_GPIO_MAP, sizeof(USART_SPI_GPIO_MAP) / sizeof(USART_SPI_GPIO_MAP[0])); // IO-Map zuweisen gpio_enable_module(SPI0_GPIO_MAP, sizeof(SPI0_GPIO_MAP) / sizeof(SPI0_GPIO_MAP[0])); // Initialize USART in RS232 mode. usart_init_rs232(EXAMPLE_USART, &USART_OPTIONS, FOSC0); // Init Master error_code = spi_initMaster
-
Thread
Hex in Char casten und ab aufs Display
uart_string[]. Für die Display Ausgabe verwende ich folgende Routine: [c] uint8_t size = sizeof(uart_string)/sizeof(uart_string[0]); uint8_t i; for (i=0; i < size; i++) { sprintf(ausgabe,"%c",uart_string[i]); lcd_setcursor(i, 2); lcd_string(ausgabe); } [
binärdaten. Wenn du die hexadezimal anzeigen willst, dann geht das anders: [c] uint8_t size = sizeof(uart_string)/sizeof(uart_string[0]); uint8_t i; char ausgabe[3]; for (i=0; i < size; i++) { sprintf(ausgabe,"%02x",uart_string[i]); lcd_setcursor(i*2, 2); lcd_string(ausgabe
-
Thread
IEEE-754 Float erzeugen
[c] unsigned char tmp[2]; tmp[0] = 0x43FA; tmp[1] = 0x9B9A; float f; memcpy( &f, &tmp, sizeof( float ) ); [/c] eventuell die Reihenfolge tauschen.
korrektur: [c] uint16_t tmp[2]; tmp[0] = 0x43FA; tmp[1] = 0x9B9A; float f; memcpy( &f, &tmp, sizeof( float ) );
-
Thread
Adresse eines Arrays einem Pointer zuweisen und löschen
freigeben oder ist das Array dann auch futsch? z.B uint8_t *test1; test1=(uint8_t*) malloc(3*sizeof(uint8_t)); uint8_t test2[3]; test2=test1; Das ist jetzt ein triviales Bespiel aber es hilft hoffentlich mein Problem zu verstehen. Vielen Dank im Vorraus
[c] uint8_t *test1; test1 = (uint8_t*) malloc(3*sizeof(uint8_t)); uint8_t test2[3]; test2 = test1; // #### [/c] Das geht nicht. test2 kann nichts zugewiesen werden.
-
Thread
Fleury's Uart, wie string empfangen?
Zeichen verarbeiten uart_putc( (unsigned char)c ); uart_gets( Line, sizeof( Line ) ); uart_putc( (unsigned char) sizeof( Line ) ); uart_puts( Line ); } } } [/c] Gruß Maik
main [c] ... //Empfangenes Zeichen verarbeiten uart_gets( Line, sizeof( Line ), (unsigned char)c ); } if (flag == 1) { flag=0; //uart_puts(Line); uint8_t i=0; while (i < sizeof (Line))
-
Thread
Array[8] mit 0 und 1 zu integer zb 255
[code] value = 0; for(i=0; i < sizeof(Array); ++i) { value = (value << 1) | Array[i]; } [/code]
sowohl C als auch C++ programmieren, der Version ++i den Vorzug zu geben :-) Also for( i=0; i < sizeof(Array); ++i ) anstelle von for( i=0; i < sizeof(Array); i++) Warum ist das so? Bei int oder anderen eingebauten Datentypen macht es keinen Unterschied. Ist i aber ein anderer Datentyp, eine
-
Thread
invalid application of 'sizeof' to incomplete type 'char[]'
character.h: [c]extern char xxxx[];[/c] file main.c: [c]void main (void) { ... print_ulong( sizeof(xxxx) ); ... }[/c] Möchte ich diese nun compilieren, erhalte ich die Fehlermeldung "invalid application of 'sizeof' to incomplete type 'char[]'". Definiere ich das Array "xxxx" direkt in der Datei main.c, geht alles in Ordnung. Aber gibt es nicht auch eine Möglichkeit sizeof() zu nutzen, wenn das Array in einer anderen Datei definiert wurde?
-
Thread
ISR und Stackgröße
von alleine, wenn sich mal die Arraygröße verändert. [C] strncpy(breitengrad, "Warte...", sizeof(breitengrad)); [/C] strncpy ist aber nur die halbe Miete, denn strncpy hat hier ein Designproblem: Wenn der String gerade noch ohne das obligatorische \0 in das Ziel passt, dann wird das obligatorische
ungültigen String vorliegen. Verhindern kann man das nur so [C] strncpy(breitengrad, "Warte...", sizeof(breitengrad)); breitengrad[ sizeof(breitengrad)-1 ] = '\0'; [/C] Wieder: verusch nicht selber die Zahlenwerte auszurechnen, sondern versuche die Dinge mittels sizeof auszudrücken. Auf die Art
-
Thread
CCS8 -- unsigned int zählt nicht über >32767
]sprintf(vers,"%s","0050-CCS-TS5435");[/c] geht besser so: [c]strncpy(vers, "0050-CCS-TS5435", sizeof (vers));[/c] Oder gleich viel einfacher: [c]const char vers [] = "0050-CCS-TS5435";[/c] Und [c]for (z=0; z<26;z++) { c=vers[z]; lcd_write_command(LCD_CMD_WRITE_DATA, c); }[/c] Geht einfacher so: [c]for (size_t i = 0; i < sizeof(vers)-1; ++i) lcd_write_command(LCD_CMD_WRITE_DATA, vers [i]);[/c] Generell sollte man Variablen nicht (mehr) am Anfang der Funktion definieren, sondern erst dann wenn man tatsächlich einen Wert
-
Thread
Sinus bis pi/2 mit Ansi-C berechnen und.
sin_tab_struct* s_sin,sin_tab_struct* s_cos) { int n; float x=0; memset((void*)s_cos,0,sizeof(sin_tab_struct)); memset((void*)s_sin,0,sizeof(sin_tab_struct)); for(n=0;n<=TAB_SIZE;n++){ sin_tab_table[n]= (sin(x)/TAB_SIZE)*PIDIV2; x++; } } Das ist der Teil, der mir eigentlich
sin_tab_struct* s_sin,sin_tab_struct* s_cos) > { > int n; > float x=0; > > memset((void*)s_cos,0,sizeof(sin_tab_struct)); > memset((void*)s_sin,0,sizeof(sin_tab_struct)); Kannst du dir sparen. Du überschreibst ja soewieso das Feld > for(n=0;n<=TAB_SIZE;n++){ gewöhn dir das <= an dieser
-
Thread
BigData - Massendaten-Speicherung mit sehr schneller Abfrage
Position für den neuen Timestamp erreicht ist. [c]time_t prevMinute = logStart - 60 + mFile.size() / sizeof(logEntry_t) * 60; while (prevMinute + 60 < currentMinute) { prevMinute += 60; mFile.write((uint8_t*)(&dummyEntry), sizeof(entry)); } mFile.write((uint8_t*)(&entry), sizeof(entry));[/c]
für den gewünschten Timestamp berechnet. [c]uint32_t pos = (jobEntry.timestamp - logStart) / 60 * sizeof(logEntry_t); file.seek(pos); file.read((uint8_t*)(jobEntry.logEntry), count * sizeof(logEntry_t));[/c] Vielleicht genügt bei deinem Problem auch so eine Triviallösung.
-
Thread
Problem mit Websever, Port unklar und ändert sich
sockaddr_in a, a1; static int port = 8001; s = socket( AF_INET, SOCK_STREAM, 0); memset( &a, 0, sizeof( a)); a.sin_family = AF_INET; a.sin_port = htons( port); a.sin_addr.s_addr = htonl( INADDR_ANY); bind( s, (struct sockaddr*) &a, sizeof( a)); listen( s, 100); printf( "\nlistening
kriegst du es mit [c] int flagvalue = 1; setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &flagvalue, sizeof(int)); [/c] vor dem "bind".
-
Thread
RS232 VS 2012 SP4 Error C2664
OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0); if(hFile==INVALID_HANDLE_VALUE)return 0; memset(&sDcb,0,sizeof(sDcb)); sDcb.DCBlength = sizeof(sDcb); sDcb.BaudRate = 9600; // Baudrate sDcb.fParity = FALSE; sDcb.fBinary = TRUE; sDcb.Parity
OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0); if(hFile==INVALID_HANDLE_VALUE)return 0; memset(&sDcb,0,sizeof(sDcb)); sDcb.DCBlength = sizeof(sDcb); sDcb.BaudRate = 9600; // Baudrate sDcb.fParity = FALSE; sDcb.fBinary = TRUE; sDcb.Parity
-
Thread
Arduino EEPROM _read_block HOW TO?
if(Serial.available()){ int input = Serial.read(); eeprom_write_block(0,&input,sizeof(2)); delay(1000); } } [/c] nach dem delay soll er den gespeicherten Wert wieder zurück an die UART senden. kann mir wer beim auslesen helfen? ich verwende die AVR/EEPROM libary.
eeprom_read_block(0,&output,sizeof(2)); anstatt sizeof(2) schreibst du besser sizeof(int) oder noch besser sizeof(output). Für 16 Bit Einheiten gibt es dann auch noch die speziellen Funktionen eeprom_read_word ( eeprom Adresse
-
Thread
Pointer auf Array
#3033967: > Schön ist es nicht, aber was soll daran falsch sein? Weil das zumindest noch durch sizeof(ArrayElement) geteilt werden muss: Sinngemäss index = (pArray - Array + 1) / sizeof(int);
i ) und die Pointer Arithmetik ist dergestalt, dass es das den sizeof von *ptr automatisch mit einrechnet.
-
Thread
Problem mit winsock
das einfach nicht. char* readData(int buf) { SOCKADDR_IN remoteAddr; int remoteAddrLen=sizeof(SOCKADDR_IN); char *data=malloc(buf); int byt=recvfrom(s,data,buf,0,(SOCKADDR*)&remoteAddr,&remoteAddrLen); if(byt==SOCKET_ERROR ) { int a=closesocket(s) ; WSACleanup
Längenangabe 1 Byte ist. unsigned char * returnData; bytesReceived = recvfrom( s, data, sizeof(data), 0, (SOCKADDR*)&remoteAddr, &remoteAddrLen ); // das erste empfangene Byte gibt die Länge des Datensatzes an expectedBytes = data[0]; bytesReceived--;
-
Thread
Struct zerlegen für Schleife
den Beginn der struct-Variablen [C] ... summ = CheckSumm( (uint8_t*)&my_struct daten, sizeof( *my_struct daten ) ); [/C]
Struktur noch weitere Elemente einfügen, dann mußt Du an der Schleife nix ändern, die läuft immer bis sizeof(struct). Peter
-
Thread
CGI - Apache Auth
adress.sin_addr.s_addr = inet_addr(ip); conValue = connect(sockfd, (struct sockaddr *)&adress, sizeof(adress)); printf("[CONVALUE %d]\n",conValue); if(conValue == 0)printf("Verbindung steht...\n"); else perror("[CONNECT]"); return sockfd; } //--------------------------------------
mein base64 kodiertes BN:PW'\r\n\r\n"; char empfangen[10000]; write(socketNummer, befehl, sizeof(befehl)); read(socketNummer, empfangen, sizeof(empfangen)); printf("%s\n",empfangen); write(socketNummer, befehl2, sizeof(befehl2)); read(socketNummer, empfangen, sizeof(empfangen));
-
Thread
Struct mit Array - verschiedene Arraygrößen - Wie?
compiler geht auch [0] }; struct PFUSCH * new_pfusch(int size) { struct PFUSCH *p = malloc(sizeof(struct PFUSCH) + sizeof(uint8_t) /* ich weiß ... */ * (size - 1)); if(p) { p->buffer_size = size; } return p; } struct PFUSCH * p64 = new_pfusch(64); [/c]
Array von drei FIFOs mit Initialisierung der Puffer struct FIFO FIFO_Buffer[3] = { { buffer0, sizeof buffer0, 0, 0 }, { buffer1, sizeof buffer1, 0, 0 }, { buffer2, sizeof buffer2, 0, 0 } }; [/c] Den Funktionen zum Schreiben und Lesen der FIFOs wird jeweils ein Zeiger (z.B. fifo_ptr)
-
Thread
((long*)mem)++; -> lvalue required as increment operand
andere Variante besser lesbar finde. Was mich noch interessieren würde ist ob auch [c]mem += sizeof(long)[/c] funktionieren würde. _Das_ fände ich tatsächlich gut lesbar, einfach, kurz. Nur habe ich den Verdacht das das nicht immer funktioniert. Viele Grüße Paul Roßmann
Ohne Testen würde ich sagen: klappt nicht. Angenommen, sizeof(long) liefert 4. Dann würde der Zeiger um 4 * sizeof(Zeigertyp) erhöht werden. mem zeigt aber auf void. Was ist sizeof(void)?
-
Thread
GCC - Rundungsfehler ?
float sein Um es zu präzisieren: AVR-GCC verwendet für float und double den gleichen Datentyp; sizeof float == sizeof double == 4. Es hat sich bislang niemand die Mühe gemacht, 64-Bit-floatingpoint-Aritmetik auf den AVR zu portieren.
sein > > Um es zu präzisieren: > AVR-GCC verwendet für float und double den gleichen Datentyp; sizeof > float == sizeof double == 4. > > Es hat sich bislang niemand die Mühe gemacht, > 64-Bit-floatingpoint-Aritmetik auf den AVR zu portieren.
-
Thread
Stuktur in EEPROM schreiben (c)
(*) Auf einem AVR ist das kein Thema. Aber auf einem PC gilt nicht notwendigerweise, dass die sizeof der kompletten Struktur gleich ist der Summe der sizeof der Komponenten.
ich würde noch das "(BYTE)72" durch "sizeof(calData)" ersetzen, dann klappt das ganze auch noch wenn sich dein struct ändert
-
Thread
Ausgabe aller IP-Adressen
main(){ char input[256]; struct addr_list list = {0}; while(fgets(input,sizeof(input),stdin)){ if(!strcmp(input,"\n")) break; if(input[strlen(input)-1]=='\n') input[strlen(input)-1] = 0; struct addrinfo* result = 0; int ret = getaddrinfo(input
(entry->info); } free(list.list); memset(&list,0,sizeof(list)); return 0; } [/c]
-
Thread
winavr linkerscript .bss vor .data und an konst. Adresse
.bss*) *(COMMON) PROVIDE (__bss_end = .); }> data __bss_data_end = (ADDR(.bss) + SIZEOF(.bss)); /* .data wird mit Konstanten initialisiert */ /* .data ADDR (.bss) + SIZEOF (.bss) : AT (ADDR (.text) + SIZEOF (.text)) */ /* .data (ADDR(.bss) + SIZEOF(.bss)) : AT (ADDR (.text) + SIZEOF (.text)) */ .data AT( __bss_data_end ) : AT (ADDR (.text) + SIZEOF (.text)) { PROVIDE (__data_start = .); *(.data) *(.data*) *(.rodata) /* We need to include .rodata here
-
Thread
Pointer als parameter von Funktion zurück
t numOfDoubled = 0; for(uint8_t x=0; x<4; x++) { a[x] = 0x10; } work(&a[0], sizeof(a), c, &numOfDoubled); for(uint8_t x=0; x<numOfDoubled; x++) { printf("%02X ", c[x]); } return EXIT_SUCCESS; } static void work(uint8_t* a, uint8_t numOfA, uint8_t* resArray
Johannes schrieb im Beitrag #6443160: > work(&a[0], sizeof(a), c, &numOfDoubled); &a[0] ist quatsch, da a[0] bereits die Adresse ist.
-
Thread
Speichermanipulation FLASH - STM32F411CEU
i][0], sizeof (float)); Adr += sizeof (float); Flash_Write_Data(Adr, Data[i][1], sizeof (float)); Adr += sizeof (float); } [/c] Ich kenne die Funktion Flash_Write_Data() nicht, ist die von Dir? Wenn
größeren Brocken klarkommt, reduziert sich das auch auf eine Zeile: [c] Flash_Write_Data(Adr, Data, sizeof (Data)); [/c]
-
Thread
Struct-Array im EEprom sortiert ausgeben
[c] char buffer[20]; for( i = 0; i < 6; ++i ) { eeprom_read_block(&buffer,&Index[i],sizeof(Index[i])); uart_puts( buffer ); } [/c]
" ist nicht die Adresse, von der aus dem EEPROM gelesen werden muss, sondern "Index[i]". 2) "sizeof(Index[i])" ist 2.
-
Thread
AVR: Effizienzter weg gesucht um Hertz in Mehahertz umzurechen
Damit es Anfänger Nahvollziehen können nochmal die Erklärung: char* fr = calloc(35,sizeof(char)); char* original = calloc(35,sizeof(char)); Mit diesen zwei zeilen erstelle ich zwei 35 zeichen lange "Strings" die mit 0 gefüllt sind ... dies ist später nötig damit das LCD weiss wo schluss
> char* fr = calloc(35,sizeof(char)); Wo sind die free() ?
-
Thread
Arraylänge falsch?
Sizeof kennt keine Sonderbehandlung einer 0. Strlen hingegen hört vor einer 0 auf.
Unterschied, wenn du ein globales uninitialisiertes Array hast. Dann liefert strlen 0 Und sizeof den reservierten Speicher in Bytes.
-
Thread
32F746Disco, SW4STM32, kompiliert, nach kleiner Änderung aber nicht.
loop */ /* USER CODE BEGIN WHILE */ while (1) { Lesekopf = j; j++; j %= sizeof(Ringpuffer); i = 0; while( i < sizeof(Ringpuffer) ) { if( (Farbflags & (1 << Rot_run)) != 0) { if ( (Farbflags & (1 << Rot_dir)) == 0)
Textpuffer[i] = Ringpuffer[Lesekopf]; i++; Lesekopf++; Lesekopf %= sizeof(Ringpuffer); } BSP_LCD_DisplayStringAtLine (0, &Textpuffer[0]); HAL_Delay (k); } /* USER CODE END WHILE */ [/c]
-
Thread
IAR math funktion mit 64bit double
einstellen? hier noch ein Auszug aus meinen Testprogramm: union convert{ unsigned char bytes[sizeof(double)]; double value; } ; ----------------------- union convert test; test.value=pow(12.5,2.5); for (char i=0 ; i<sizeof(double) ; i++ ) { PORTA=sizeof(double)-i; DDRA=test.bytes[sizeof(double)-1-i]; } MfG Marten
-
Thread
Der tiefere Sinn hinter __packed
Ich habe hier eine Structure: Was würde mir hier sizeof(IO_VAL_DIGITAL) geben? (ja mir ist klar das hier noch eine dekleration der eigentlichen Variable fehlt) [c] typedef struct __attribute__((__packed__)) { UINT8 block_time; // block
bReserved : 5; } bits; UINT8 val; } flags; } IO_VAL_DIGITAL; [/c] Sizeof gibt einmal 6 und einmal 12 wieder je nachdem obs packed ist oder nicht. Nur wo kommen hier die weiteren 6 Bytes her und vorallem warum?
-
Thread
structs auf 8-Bit-MCUs
verwenden ... MfG Thomas Pototschnig *edit* Wenn du das eh im Speicher hast, dann memcpy(t,p,sizeof(MyType)); und fertig ...
> char* ptr = (char*) t; > > for (int i=0;i<sizeof(myType);i++) > { > send(*ptr); ptr++; > } > memcpy(t,p,sizeof(MyType)); Das ist Käse, wegen der später möglichen Endianness-Probleme. Heute hast du einen Little-Endian 8-Bit-Prozessor
-
Thread
alle "," durch "." eines strings ersetzen (in C)
> stimmt aber vermutlich nur bei byte und char array... nein , denn i wird implizit zu (*)(i*sizeof(*a)) erweitert. Danach werden die beiden Zeiger addiert. Volker
das array z.b. mit z.B. 4 multipliziert werden würde und man damit "irgendwo" ist.. und B >sizeof(*a) nachdem i ja "alles mögliche" sein kann (byte/word/int usw.) wird, wenn man a und i vertauscht aus sizeof(*a) (also sizeof(*i) wird) ja entweder 1, 2, 4 ... man multipliziert also entweder
-
Thread
Parameter Serielle Schnittstelle
LocalAlloc(LMEM_ZEROINIT, (lstrlen((LPCTSTR)lpMsgBuf) + lstrlen((LPCTSTR)lpszFunction) + 40) * sizeof(TCHAR)); StringCchPrintf((LPTSTR)lpDisplayBuf, LocalSize(lpDisplayBuf) / sizeof(TCHAR), TEXT("%s failed with error %d: %s"), lpszFunction, dw, lpMsgBuf); MessageBox(NULL, (
sscanf(Dialog1.baudrate,"%ld",&a); MyDcb.BaudRate=a; /* oder was Anders */ MyDcb.DCBlength=sizeof(DCB); /* !!! */ MyDcb.fBinary=1; MyDcb.fOutxCtsFlow=0; MyDcb.fOutxDsrFlow=0; MyDcb.fDtrControl=DTR_CONTROL_ENABLE; MyDcb.fDsrSensitivity=0; MyDcb.fRtsControl=RTS_CONTROL_ENABLE
-
Thread
Uart funktioniert nicht
" #include "lib/lcd.h" char buffer; ISR(USART_RXC_vect){ uart_get_string(buffer, sizeof(buffer)); lcd_clear(); lcd_home(); lcd_string(buffer); } int main(void){ pinMode(&DDRB, PB1, 1); pinMode(&DDRB, PB2, 1); uart_init(); lcd_init(); sei();
> uart_get_string(buffer, sizeof(buffer)); weil sizeof(buffer) immer 1 ist ! Deine Funktionen können doch nicht wissen wie lang der String ist bzw. wissen es nur wenn die 0x00 gekommen ist. Kannst du garantieren das die Funktionen
-
Thread
cast to pointer from integer of different size.
char *string, uint8_t CRC) { char VT[50] = "\v"; VT [1] = CRC; strncpy (VT+2, string, sizeof(VT)-2); size_t commandLen = strlen(VT); if (commandLen > sizeof(VT)) commandLen=sizeof(VT); // Kann passieren wenn string zu lang RS232_flushTX(ComPort); for (size_t i = 0; i <= commandLen
uint8_t > CRC) > { > char VT[50] = "\v"; > > VT [1] = CRC; > strncpy (VT+2, string, sizeof(VT)-2); > size_t commandLen = strlen(VT); > if (commandLen > sizeof(VT)) commandLen=sizeof(VT); // Kann passieren > wenn string zu lang > > RS232_flushTX(ComPort); > > for (size_t
-
Thread
Pointer auf Array in struct, aber wie macht man das?
richtige Anzahl an Bytes schreibt. Und an dieser Stelle kommt dann eine zweite Zutat ins Spiel: ein sizeof. um das komplette Array zu schreiben. [C] spi_write_data( (char*)settings.DRVCONF, sizeof( settings.DRVCONF ), CS_EXT); [/C]
#2866444: > um das komplette Array zu schreiben. [c] spi_write_data( (char*)settings.DRVCONF, sizeof( settings.DRVCONF ), CS_EXT); [/c] Ich werd es sofort ausprobieren. Das mit dem 'sizeof' wollte ich auch noch machen wenn es erstmal funktioniert. Danke euch allen schon mal. Steffen
-
Thread
Betriebsstundenzähler für Terrarium UV Lampen - Arduino
// von time zur 'Variablen' ins EEPROM schreiben eeprom_write_block( &time, &timeEEPROM, sizeof( time ) ); .... // von der 'Variablen' im EEPROM den Wert nach time holen eeprom_read_block( &time, &timeEEPROM, sizeof( time ) ); [/c]
zeigt er mir fehler an. Habe es auch mal so probiert. EEPROM.write.Block( &time, &timeEEPROM, sizeof( time )); Ich weiß nicht weiter.
-
Thread
Funktionspointer
mit hinzu, um auf diese Sprungtabelle zuzugreifen: [avrasm] #define bl_offset 0x1800 #define sizeof_rjmp 2 .equ bootload, bl_offset + 0 .equ thisfunc, bl_offset + 1 * sizeof_rjmp .equ thatfunc, bl_offset + 2 * sizeof_rjmp .equ whatever, bl_offset + 3 * sizeof_rjmp [/avrasm] Wie geschrieben
-
Thread
Endianess beim Kopieren automatisieren
ist außer Frage? Achim S. schrieb im Beitrag #4969948: > Wir senden quasi per (47, &Status47, sizeof(Status47)) problemlos, da > Typ, struct, Padding, Endian gleich sind. Diese Herangehensweise rächt sich hier, deswegen macht man das direkt richtig...
raw, uint16_t v ) { raw[ 0 ] = v & 0xff; raw[ 1 ] = ( v & 0xff00 ) >> 8; return raw + sizeof( v ); } [/c]
-
Thread
länge zur Laufzeit
eines im flash ROM abgelegten Datensatzes zur laufzeit zu bestimmen ? Bis jetzt verwende ich immer sizeof(), das wird aber (wenn ich es richtig weiss) vom coprozessor schon rausgeschnissen und durch die zahl ersetzt. Ich brauche aber die Länge zur Laufzeit, da das HEX File nach dem compilieren und linken
Hi ich habs nicht verstanden. sizeof() bestimmt ja nur die Größe eines Datentypes bzw. Arrays. Und was willst du jetzt genau zur Laufzeit herausfinden? BTW: sizeof() wird AFAIK nicht vom Präprozessor ausgewertet. Zumindest wirft es
-
Thread
ARM Cortex M3 (ATSAM3S4B) - SPI mit PDC (DMA-Controller)
SPI_PTCR_RXTDIS; // DMA-Receive disable SPI->SPI_TPR = &spi_tx_buffer; SPI->SPI_TCR = sizeof(spi_tx_buffer); SPI->SPI_RPR = &spi_rx_buffer; SPI->SPI_RCR = sizeof(spi_rx_buffer); for (uint8_t i=0; i<sizeof(spi_tx_buffer); i++) // Sendedaten aktualisieren {
PIO_SODR_P17; PWM->PWM_ISR1; SPI->SPI_TPR = &spi_tx_buffer; SPI->SPI_TCR = sizeof(spi_tx_buffer); SPI->SPI_RPR = &spi_rx_buffer; SPI->SPI_RCR = sizeof(spi_rx_buffer); SPI->SPI_PTCR = (SPI_PTCR_TXTEN | SPI_PTCR_RXTEN); for (uint8_t i=0; i<sizeof
-
Thread
Visual C++ 2010 Express mit FileHandle Gesperrt
(saveFileDialog1->OpenFile()); if(fs) { unsigned int i; for(i=0;i<=sizeof(TestV);++i) fs->WriteByte( TestV[i] ); // Set the stream position to the beginning of the file. //fs->Seek( 1, SeekOrigin::Begin ); fs->Close();
) { char filename[MAX_PATH] = { 0 }; OPENFILENAME ofn = { 0 }; ofn.lStructSize = sizeof(ofn); ofn.lpstrFilter = "Text files (*.txt)\0*.txt\0"; ofn.lpstrFile = filename; ofn.nMaxFile = sizeof(filename); ofn.lpstrDefExt = "txt"; ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY
-
Thread
CallbackFunktion übergabe mit oder ohne &
das gesamte Array (und nicht nur auf das erste Element) zu definieren. Außerdem kann man darauf sizeof anwenden, um die Größe des Arrays zu erhalten. In allen Ausdrücken, in denen dem Array-Vezeichner kein & oder sizeof vorangeht, wird er in einen Pointer auf das erste Element konvertiert. Aber
werden muss. Die Dereferenzierung eines Funktionspointers wäre demzufolge ein Fehler, da für wäre sizeof erlaubt und würde die Größe eine Code-Adresse liefern.
-
Thread
Überschreiben von Strukturelementen
einer Funktion gefüllt: [c] { g_sTest[nIndex].n = 0; strncpy(g_sTest[nIndex].szName, Name, sizeof(g_sTest[nIndex].szName)); g_sTest[nIndex].szName[sizeof(g_sTest[nIndex].szName) - 1] = 0; printf("Ab hier werden die Werte der Struktur überschrieben"); } [/c] Bis zum printf läuft auch
Schreib es doch so: { TEST *slot = g_STest + nIndex; strncpy(slot->szName, Name, sizeof(slot->szName) - 1); } Das extra-Schreiben der 0 ist überflüssig, wenn man sie nie überschreibt (da globale Arrays sowieso mit 0 initialisiert sind). Woher dein Problem kommen könnte: wie die
-
Thread
Pointer auf Strings im FLASH?
ganz zu stimmen. > const char pgmStartString[] PROGMEM = "ATmega32 online!"; > for (int i=0; i<sizeof(pgmStartString); i++) { sizeof(pgmStartString) liefert Die die Länge des Pointers zurück. Du brauchst aber die Stringlänge - also strlen() Da strlen() aber nur im RAM geht, bräuchtest
pgmStartString ist ein Array, kein Pointer, daher passt sizeof().
-
Thread
Strings und Newlib
dem String selber? und nein. sizeof(file_name) wird ziemlich sicher nicht 5 sein. 4 klingt plausibel, wenn wir davon ausgehen, dass ein Pointer auf deinem System eine Länge von 4 Bytes hat, was bei einem ARM nicht ungewöhnlich sein sollte
sizeof(file_name) liefert 4, weil file_name ein pointer ist. Und der hat wohl 4 byte. Was du willst, kann C von haus aus nicht. strlen () ist dein Kandidat. Damit bekommst du die stringlänge raus.