-
Thread
AVR-GCC: ARRAY an eine feste RAM-Adresse legen
const char* name; void *address; int16_t size; } symlist = { { "ganze_struct", &daten, sizeof(daten_t) }, { "ganze_struct.feld1", &daten.feld1, sizeof(whatever_daten_feld_1_is) }, ... }; [/c] unterbringen kannst und willst (ist ja bei 400 Feldern schon ein wenig Arbeit), dann wäre es
char* name; > void *address; > int16_t size; > } symlist = { > { "ganze_struct", &daten, sizeof(daten_t) }, > { "ganze_struct.feld1", &daten.feld1, sizeof(whatever_daten_feld_1_is) > }, > ... > }; > [/c] > unterbringen kannst und willst (ist ja bei 400 Feldern schon ein wenig > Arbeit
-
Thread
warum mecket der gcc nicht wenn der Flash überfüllt wird?
Linkerscript anghängt: [code] /* Check if text + data exceeds Flash limit */ /*ASSERT((SIZEOF(.text) + SIZEOF(.data)) <= LENGTH(FLASH), "region text overflowed")*/ [/code]
schrieb im Beitrag #5328936: > /* Check if text + data exceeds Flash limit */ > /*ASSERT((SIZEOF(.text) + SIZEOF(.data)) <= LENGTH(FLASH), "region > text overflowed")*/ wenn Du das - wie gezeigt - in Kommentarzeichen hast, ist es nutzlos.
-
Thread
RFM12USB senden oder empfang Problem
| USB_RECIP_DEVICE | USB_ENDPOINT_IN, RFMUSB_RQ_RFM12_GET, 0, 0, buf, sizeof (buf), 5000 ); // Empfangen if (tmp > 0) { /* data received from usb bus */ if (buf[2] == 0) { checkSendFile
USB_RECIP_DEVICE | USB_ENDPOINT_OUT, RFMUSB_RQ_RFM12_PUT, USB_TXPACKET, 0, receiveReturn, sizeof receiveReturn, 5000 ); rfmData = "/data/"; for (i=3; i<tmp; i++) { g_printf("%.2x ", buf[i]); g_snprintf(temp, sizeof temp,
-
Thread
PLZ nach Entfernung sortieren
ientr, idb; double hdbl; int i,h1; char s2[0x40]; is=0; h1=0; ientr=0; idb=0; while (fgets(s,sizeof(s), fh)!=NULL) { //printf("%s\n",s); if (s[0]=='#') continue; is=0; if (str_searchch2(s,&is,"\t\n")==1) continue; // search for \t or \n. // if a \n is found, proceed next line
idb; double f1, f2; int h1,h2; char s2[0x40]; is=0; h1=0; ientr=0; idb=0; while (fgets(s,sizeof(s), fh)!=NULL) { if (s[0]=='#') continue; if (sscanf(s,"%d %d %lf %lf %[^\n\r]s", &h2,&h1,&f1,&f2,s2)!=5) { printf("**%s\n",s); continue; } plzdb[idb+0]=h1; plzdb[idb
-
Thread
SocketCAN und Message Object
PF_CAN, SOCK_RAW, CAN_RAW ); . . setsockopt(mySkt, SOL_CAN_RAW, CAN_RAW_FILTER, &t_Filter1, sizeof(t_Filter1) ); setsockopt(mySkt, SOL_CAN_RAW, CAN_RAW_FILTER, &t_Filter2, sizeof(t_Filter2) ); . . bind( mySkt1, (struct sockaddr*)&addr, sizeof(addr) ); bind( mySkt2, (struct sockaddr*)&addr, sizeof(addr) ); [/c] und empfangen dann über [c] read( mySkt1, &frame, sizeof(frame) ); [/c] bzw. [c] read( mySkt2, &frame, sizeof(frame) ); [/c]
-
Thread
FatFs mit Fifo Bibliothek von Falk Brunner, Fifo behält trotz Auslesen und read_bursted Restdaten.
} } } } int main(){ [...] fifo_init(&fifo, fifo_bufferarray,sizeof(fifo_bufferarray)/sizeof(fifo_data_t)); uint16_t fifo_wrap_size; uint16_t fifo_block_size=fifo_writesize; while(1){ [...] // Normaler Schreibvorgang auf SD Karte if(SDcard_ready
operation f_write(&file1, (uint8_t*)fifo.read_p, rest_size * sizeof(fifo_data_t), &fatfs_bytes_written); fifo_read_bursted(&fifo, fifo_block_size); // Anm.: hier dann natürlich ebenfalls rest_size f_sync(&file1); } [/c] > > Kleiner Tip. Die Sequenz
-
Thread
Arduino + RF24 (nRF24L01+) sendet/empfängt immer nur 3 Mal Daten
auslesen //data.soilMoisture = analogRead(SOIL_MOISTURE_DATA); //bool ok = radio.write(&data,sizeof(dataStruct), 0); //bool ok = radio.write(&data,sizeof(dataStruct), 1); bool ok = radio.writeBlocking(&data,sizeof(dataStruct), 1000); radio.txStandBy(1000); if (ok) {
; while(radio.available(&pipeNumerSenderLivingroom)) { radio.read(&data, sizeof(dataStruct)); //radio.stopListening(); //bool acknowledgement; //radio.writeAckPayload(pipeNumerSenderKitchen, &acknowledgement, sizeof(bool) ); }
-
Thread
Ein Stringproblem
(i=0; i<sizeof(msg); i++) { transfer.xor = transfer.xor ^ msg[i]; } printf ("XOR: %X\n", transfer.xor); printf ("Sender: %X, Länge: %X, Empfänger: %X, Daten: %X, CRC: %X\n", transfer.sender
austeste und diese dann in das Programm einbaue. Also es wäre dann Ersatz. zum Punkt 2: Stimmt, sizeof liefern die reservierte Grösse zurück und strlen die Länge eines Strings. Hast Recht. Zum Punkt 3: Ja, das habe ich testweise runtergesetzt. Es hat den Hintergrund, dass nicht immer alle 32 Byte
-
Thread
Speicherplatz Frage C & EEMEM
Soweit mir bekannt, wird das nicht gelingen. Das einzige mir bekannte Mittel um was zu bauen ist sizeof() in Verbindung mit offsetof(). Aber einen größeren Wertebereich als size_t hat das auch nicht.
Idee eine struct zu verwenden, da ein naives Lesen/Speichern a la var_t x; read_ee(0x1000, &x, sizeof(x)); write_ee(0x1000, &x, sizeof(x)); Annahmen über das Padding und Alignment in dieser Struktur macht.
-
Thread
EEPROM Segmentierung & Speicherung
attribute__ ((section (".eeprom"))) #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_LAST
__ ((section (".eeprom"))) > > #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
-
Thread
Ich dachte ich könnte C - was tut diese Zeile?
durch einen Pointer auf diese Funktion ersetzt, es sei denn, der Ausdruck ist Argument des sizeof- oder des Adressoperators. In diesem Fall bleibt der Ausdruck unverändert. 2. Der sizeof-Operator auf eine Funktion angewendet ist ein Fehler¹. 3. Ein Funktionspointer mit nachfolgender eingeklammerter
der beiden von dir genannten Schemata. ——————————— ¹) Der GCC erweitert die Definition von sizeof dahingehend, dass sie bei der Anwendung auf eine Funktion den Wert 1 liefert.
-
Thread
SRAM in C direkt auslesen
Ram liegt ist doch egal. Mit einer For Schleife sendet man das dann: uint8_t i; for (i=0; i <sizeof (byBuffTx); i++) { while (!Uart frei...){}; Uart Tx Register = byBuffTx [i]; }
addr == 0xaffeaffe) { glbls = (struct globals *) addr; if (glbls->size == sizeof(struct globals)) break; glbls = NULL; } } while (addr++ != _data_end); if (glbls != NULL) { ... } [/c] Besonders effektiv ist das natürlich nicht (muß es aber
-
Thread
RFM12 Übertragung Verschlüsseln?
Sender-SourceCode { CryptedData[3] = 12345789; // Nutzdaten EncodeData(CryptedData, sizeof(CryptedData)/sizeof(*CryptedData)); // CryptedData[] wird gesendet... } // - Empfänger-SourceCode { // ...CryptedData[] wird empfangen // - Variable "SynchronizeKeyPressed
SynchronizeKeyPressed = true; // die "Sync-Taste" if(DecodeData(CryptedData, sizeof(CryptedData)/sizeof(*CryptedData), SynchronizeKeyPressed)) { // es wurden Nutzdaten empfangen... (CryptedData[3]) } SynchronizeKeyPressed = false
-
Thread
Frage zu serieller Schnittstelle! DRINGEND Bitte!
L'; h_str [4] = 'L'; h_str [5] = 'O'; COMPort.SendData(h_str, sizeof(h_str)); // SendData( Daten die gesendet werden sollen, größe der Daten) beispiel SendData(h_str,2) Sendet die ersten beiden FElder von h_str //printf("%s",h_str);
kann man das auch als 'char *h_str = "HALLO";' schreiben. [c] COMPort.SendData(h_str, sizeof(h_str)); [/c] sizeof(h_str) ist in deinem Fall aber 10. [c] //printf("%s",h_str); [/c] Das wird schiefgehen, da das besagte Nullbyte fehlt.
-
Thread
Soft-PWM Problem
Außerdem: uint8_t arraysize = sizeof(servo_pulse) / sizeof(uint8_t); Was rechts vom Gleichheitszeichen steht, ist eine Konstante, die der Compiler schon ausrechnen kann. Der Wert landet in einer globalen Variable. Daher wird der Compiler
später mit der Variablen machen statt mit der Konstanten. Daher besser: [c] #define ARRAYSIZE (sizeof(servo_pulse) / sizeof(uint8_t)) .... if (i < ARRAYSIZE - 1){ // -1: Hier den anderen Fehler glattgebügelt ... [/c]
-
Thread
Datei unbekannten Formates
// Fehlerbehandlung } float-Werte in Schleife aus Datei lesen: while (fread(&wert, sizeof (float), 1, datei) == sizeof (float)) { // wert wie auch immer ausgeben printf("Wert %f\n", wert); } Datei schließen fclose(datei);
Fehler im System"); } /* float-Werte in Schleife aus Datei lesen:*/ while (fread(&wert, sizeof (float), 1, dateimesswerte) == sizeof (float)) { // wert wie auch immer ausgeben printf("Wert: %f\n", wert); } fclose(dateimesswerte); } Ich compilier das Programm mit Dev-C
-
Thread
SDL: exe Datei lässt sich nicht ausführen
Datei ohne Fehlermeldungen starten. [c] char text_points[50]; main() { memset(text_points,0,sizeof(text_points[50])); ... while(1) { ... sprintf(text_points,"Points=%d",points); ShowTEXT(text_points,10,270,screen); ... } } [/c]
memset nur 1 char, nämlich text_points[0] auf 0 setzt? sizeof(text_points[50]) ist nämlich 1
-
Thread
C++11 return typ automatisch bestimmen
Point<float,2>( 0, 1 ) }; Point<float,10> center { 0, 0 }; for( auto it=points, end=points+sizeof(points)/sizeof(*points); it < end; it++ ) center += *it; center /= sizeof(points)/sizeof(*points); [/c] Lineare Interpolation: [c] float t = 0.5; // Position zwischen den Punkten 0
-
Thread
Messwerte auf Externen EEPROM speichern
Serial.begin(9600); EEPROM.put(adresse, f); /* Float schreiben */ adresse += sizeof(float); /* Groesse eines Float addieren */ EEPROM.put(adresse, Hello); /* String schreiben */ adresse = 0; /* Adresse wieder auf 0 setzen */ EEPROM.get(adresse, g); /* Daten einlesen und Ausgeben */ Serial.println(g, 3); adresse += sizeof(float); EEPROM.get(adresse, Buffer); Serial.println(Buffer); /* Hexdump EEPROM */ for (int i = 0; i < (sizeof(float)+sizeof(Hello)); i++) Serial.println(EEPROM[i],HEX); }
-
Thread
ADC-gesteuerte PWM mit LED-Anzeige
geschafft. Heute fällt das kaum noch auf [c] static char *FileMask; FileMask = (char*)malloc(sizeof(char) * STRINGSIZE);[/c] Zwischendurch sah es mal so aus: [c] int main(int argc, char **argv) BEGIN char *Env,*ph1,*ph2; String Dummy; int i; static Boolean First=TRUE;
Bauform B. schrieb im Beitrag #8014456: > sizeof(char) sizeof (char) ist per Definition *immer* 1 und kann daher weggelassen werden.
-
Thread
Arrays/Zeiger und Callbackfunktionen
Codeabschnitte identisch? [c] #define MAX_EVENTS 100 struct epoll_event *events; events = malloc (sizeof (struct epoll_event) * MAX_EVENTS); [/c] [c] #define MAX_EVENTS 100 struct epoll_event events[MAX_EVENTS]; [/c] Und meine zweite Frage bezieht sich auf folgenden Abschnitt: [c] int
Callbackfunktion void callback_timer (struct epoll_event *events, uint64_t *count) { read(tfd, &count, sizeof(count)); printf("Timer \n"); } void callback_signal(struct epoll_event *events, uint64_t *count) { read(sfd, &siginfo, sizeof(siginfo)); printf("Signal: %d \n", siginfo.ssi_signo); }
-
Thread
struct verschachtelung dynamisch gestalten
überhaupt als array ansprechen? wie bekomme ich den übergebenen zeiger wieder auseinander? anzahl = sizeof(alles)/sizeof(teil) ? danke für eure hilfe, ich hoffe die angelegenheit ist nicht allzu banal, sonst schäm ich mich zu tode ;-) .
inkrementiert werden. > wie bekomme ich den übergebenen zeiger wieder auseinander? anzahl = > sizeof(alles)/sizeof(teil) ? Aus einem Zeiger lässt dich die Größe des Objekts, auf das er zeigt, mittels sizeof nur dann bestimmen, wenn das Objekt eine feste (nicht dynamische) Größe hat. Bei Objekten
-
Thread
Registerinhalt rausblinken?
template <typename T> void rausblinken (const T input) { T tmp = input; for (decltype(CHAR_BIT * sizeof(T)) i = 0; i < (sizeof (T) * CHAR_BIT); i++) { led_an (); if (tmp & 1) { _delay_ms (1000); // Lang blinken } else { _delay_ms (500); // Kurz blinken } led_aus
einem mit Interrupts vollgespammten tiny44 laufen. [c] for(uint8_t bytecount = 0; bytecount < sizeof(transmitt); bytecount++){ PORTB &= ~(0b00000100); _delay_us(2500); for(bitcount=0;bitcount<8;bitcount++){ if(transmitt[bytecount]&(1<<bitcount)) PORTB |= 0b00000100;
-
Thread
Struct ins EEPROM schreiben
cli(); eeprom_write_block(&state, adresse, sizeof(state)); sei(); ^^
0x05; Sebastian B. schrieb im Beitrag #2620278: > cli(); > eeprom_write_block(state, adresse, sizeof(state)); > sei(); warum sich alle bei eeprom immer so auf den Kopf stellen müssen und alles künstlich verkomplizieren?! https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEPROM
-
Thread
strstr?
PGM_P p; memcpy_P(&p, &placeholders[index], sizeof(PGM_P)); ??? Du glaubst dass du ins Flash *schreiben* kannst? Ne, memcpy_P liest aus dem Flash und kopiert ins RAM.
void GetPlaceHolder(char* buffer, int index) { PGM_P p; memcpy_P(&p, &placeholders[index], sizeof(PGM_P)); ... (Katrierter) Prototyp von memcpy: memcpy(ziel, quelle, länge); Darum
-
Thread
ByteArray Kopieren ab Byte X
fifo_rx2 [receivedByte]; Funktion switch (fifo_rx[0]) { case 0x41: //Q memcpy(fifo_rx2,fifo_rx,sizeof(fifo_rx2)); udi_cdc_putc(sizeof(fifo_rx2)); udi_cdc_write_buf(fifo_rx2, sizeof(fifo_rx2)); break; } Danke für eure Hilfe
sind, kann durchaus sein, dass HEADER_LEN != sizeof (header) oder COMMAND_LEN != sizeof (command).
-
Thread
NMEA von GPS-Modul mit PIC18f8520 auswerten, klappt nicht richtig.
da passiert: sizeof(string) - 1 und string[i] = '\0'. Weiß der Compiler dass das eine Nullterminierung vom kompletten String[i] ist? Trotzdem wo liegt der Unterschied zwischen deinem und meinem Code (klar professioneller
sizeof(string) - 1 -> verstehe ich jetzt. Ich freu mich, dass es funktioniert. Wär nur schöner gewesen, wenn es auf meinem Misst gewachsen wäre :-) Trotzdem wo liegt der Unterschied zwischen deinem
-
Thread
Taschenrechner Selbstbau: Programmstrukturfrage
mit jedem zeichen einzeln } void buttonPressed(input){ if(input=="("){ stackOperator[sizeof stackOperator]+="("; }else if(input==")"){ while(last operator on stack != "("){ calculate last operator on stack with last to numbers//Auf Deutsch? replace with result } stackOperator[sizeof stackOperator-1]+=""; }else if(isNumber(input)){ stack[sizeof stack]+=input; }else if(isOperator(input)){ while(prio is lower than or equal to last operator on stack){//Was meint das
-
Thread
Daten aus uint32_t Array als int auslesen
berechtigter Einwand, da muss man dann mal den C-Standard fragen wie groß int sein sollte. Den sizeof-Operator gibts auch, wenn man zur Laufzeit prüfen muss ob Datentypen ineinanderpassen. Achso und die Pointer-Arithmetik ist nur für ein 32-bit System richtig wenn ich mich nicht irre. Du zählst
direkt als int auslesen? Im Allgemeinen nicht. Im Speziellen wird es halbwegs funktionieren, wenn sizeof(int) == sizeof(uint32_t) ist. Denn nur in diesem Fall ist das Inkrementieren des Pointers äquivalent zum Zugriff auf das nächste Element des Arrays. Aber auch dann geht es in die Hose, wenn ein Eintrag
-
Thread
uC führt Code nicht aus, wenn in if-Abfrage zuvor zu viel Code ist?
eeprom_w8(0, code_len); for (uint8_t i=0; i<code_len; i++) eeprom_w32(1+sizeof(uint32_t)*i, code[i]); } new_code_pos = 0; state &= ~STATE_ENTER_NEW_CODE; } else if (res.value == KEY_POWER || new_code_pos == CODE_MAX_LEN) {
Wahrscheinlich fehlt Dir hier for (uint8_t i=0; i<code_len; i++) eeprom_w32(1+sizeof(uint32_t)*i, code[i]); noch ein eeprom_busy_wait nach der Schleife
-
Thread
Schrittmotor mit Arduino
lcd.clear(); lcd.print("Eingabe:"); lcd.setCursor(0, 1); memset(eingabe, 0, sizeof eingabe); stelle = 0; mode = 1; } if (mode == 1 && key != '\0') { if (key != 'A' && key != 'B' && key != 'C' && key != 'D' && key != '#' && stelle < 15) { lcd.print
lcd.clear(); lcd.print("Eingabe:"); lcd.setCursor(0, 1); memset(eingabe, 0, sizeof eingabe); stelle = 0; mode = 1; } if (key == '#' && stelle > 0) { eingabe[stelle] = NULL; stelle--; lcd.setCursor(stelle,1); lcd.print(' ')
-
Thread
Treiberprogrammierung READ_PORT_UCHAR WINXP
break; case IOCTL_WRITE_SDA: RtlCopyMemory(&BufferUSER,Irp->AssociatedIrp.SystemBuffer,sizeof(UCHAR)); BufferWRITE=READ_PORT_UCHAR(MCR); if(BufferUSER==1) //Set SDA { DebugPrint("SetSDA"); BufferWRITE|=(1<<DTR); WRITE_PORT_UCHAR(MCR,BufferWRITE
{ GETBuffer=1; RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,&GETBuffer,sizeof(UCHAR)); DebugPrint("ReadHighSDA"); } else //Bit is Clear { GETBuffer=0; RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,&GETBuffer,sizeof(UCHAR
-
Thread
C: Instanzierung von Funktionen
uint8_t State; .... }; struct MachineState Machines[5] = { .... }; #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) void handleMachine( struct MachineState* pMachine ) { switch( pMachine->State ) { case .... } } void work() { while( 1 ) { for( uint8_t i = 0; i < ARRAY_SIZE
State ) { case .... } }; class MachineState Machines[5]; #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) void work() { while( 1 ) { for( uint8_t i = 0; i < ARRAY_SIZE(Machines); i++ ) Machines[i].handleMachine(); } } [/c] ist erst mal kein so großer Unterschied
-
Thread
Array mit Längen von verschiedenen Strukturen
Anzahl der Strukturen jedes Arrays anlegen lassen. Also in etwa so [c] uint8_t ArrayLength[] = { sizeof(Array1)/sizeof(struct x),sizeof(Array2)/sizeof(struct x), ... [/c] Das funktioniert aber nur, wenn ich die Liste im gleichen c-file generiere in dem die Arrays definiert sind. Sind die Arrays über
wäre die c files in ein übergeordnetes File zu includieren. Dort könnte man dann alle längen mit sizeof berechnen.
-
Thread
ATmega328P - Input liefert keinen Wert
Serial.println(data.humidity); // Serial.println(); // printf("Now sending "); // printf("",sizeof(data)); //unsigned long time = millis(); radio.stopListening(); //bool ok = radio.write( &time, sizeof(unsigned long) ); bool ok = radio.write(&data,sizeof(data)); radio.startListening
-
Thread
STM32F4 USART DMA-Transmit Probleme
GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; memset( &GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef) ); memset( &USART_InitStructure, 0, sizeof(USART_InitTypeDef) ); // Connect the pin to the desired peripherals' alternate function. // Wiederrum GPIOA, die TX-Source ist
GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; memset( &GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef) ); memset( &USART_InitStructure, 0, sizeof(USART_InitTypeDef) ); // Connect the pin to the desired peripherals' alternate function. // Wiederrum GPIOA, die TX-Source ist
-
Thread
Integer auf serieller Schnittstelle ausgeben
Leut Beschreibung setzt sprintf(); automatisch ein "\0" am Ende. Aber da ich das Array von 0 bis sizeof(message) lese, ist das wohl nicht wirksam?
Beschreibung setzt sprintf(); automatisch ein "\0" am Ende. Aber da > ich das Array von 0 bis sizeof(message) lese, ist das wohl nicht > wirksam? richtig, dann lese doch nur bis zu 0.
-
Thread
Arduino Code klemmt / Anfänger
Beitrag #3059211: > ledPins[]={2,3,4} > pincount = 3 Mach dir das Leben einfach... pincount=sizeof(ledPins)/sizeof(int);
interval 500 int fadingMode = 0; //Beginn mit TLC Reset int ledPins[] = {2,3,4}; int pinCount = sizeof(ledPins)/sizeof(int); int max = 100; unsigned char x; unsigned long startTime = 0; unsigned long waitUntil=0; //TLC_CHANNEL_TYPE channel; void setup() { Tlc.init()
-
Thread
Speicher Leak lwip netconn
netbuf_data(inbuf, (void**) &buf, &buflen); netconn_write(conn, http_html_hdr, sizeof(http_html_hdr) - 1, NETCONN_NOCOPY); netconn_write(conn, http_index_html, sizeof(http_index_html) - 1, NETCONN_NOCOPY); LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE
Pointer: %x</h1></body></html>\0", getHeapPointer()); netconn_write(conn, http_html_hdr, sizeof(http_html_hdr) - 1, NETCONN_NOCOPY); netconn_write(conn, buffer, sizeof(buffer) - 1, NETCONN_COPY); LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("HTTPD: Got URI %s\r\n", buf)); } catch
-
Thread
uint32 Array in uint8 Array wandeln
t i[24]; } A; typedef union { uint8_t i[24]; uint64_t j[3]; } B; static_assert(sizeof(A) == sizeof(B)); static_assert(alignof(A) == 1); static_assert(alignof(B) == 8); [/c]
HildeK schrieb im Beitrag #7199922: > for (i=0; i<40; i++) Statt "40" würde ich da "sizeof var32" hinschreiben.
-
Thread
Struktur mit Pointer "durchlaufen"
lassen und das 16er Array "daten16" (byte daten16[16];) mit diesen Daten zu befüllen. for(i=0;i<sizeof(Strukt);i++) { ... daten16[i]= ...; } 1.) Ist meine Idee prinzipiell korrekt? 2.) Wie sind die "..." zu befüllen? 3.) Wie kann ich grundsätzlich auf das erste Element einer Struktur zugreifen
short a; unsigned char b; unsigned char c[3]; }; union { Mystruct s; unsigned char arr[sizeof(Mystruct)]; } gConv; void struct_to_eeprom(Mystruct *ps, unsigned int eeadr) { gConv.s=*ps; eeprom_write_block(gConv.arr,&eeadr,sizeof(Mystruct)); } Im Code mag der ein oder andere Syntaxfehler
-
Thread
avr-gcc und .noinit
Und default ld-Script setzt __bss_end vor den Anfang von .noinit: [code] .bss ADDR(.data) + SIZEOF (.data) : AT (ADDR (.bss)) { PROVIDE (__bss_start = .) ; *(.bss) *(.bss*) *(COMMON) PROVIDE (__bss_end = .) ; } > data __data_load_start = LOADADDR(.data); __data_load_end = __data_load_start + SIZEOF(.data); /* Global data not cleared after reset. */ .noinit ADDR(.bss) + SIZEOF (.bss) : AT (ADDR (.noinit)) { PROVIDE (__noinit_start = .) ; *(.noinit .noinit.* .gnu.linkonce.n
-
Thread
Temp. Sensor
habe beispielweise HAL_I2C_Master_Transmit(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &txData, sizeof(txData), 10); und HAL_I2C_Master_Receive(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &rxData, sizeof(rxData), 10); Die Adressen, die ich beispielweise durchgeben müsste, wären 0x90 zum schreiben
t_ByteArray tempBytes; HAL_I2C_Master_Receive(&hi2c1, TEMP_SENSOR_ADRESS_8_BIT, resultBuf, sizeof(resultBuf), 10); // Shift is necessary because of i2C function description tempBytes.HByte = (int8_t)resultBuf[0]; tempBytes.LByte = resultBuf[1]; return tempBytes; } [/c]
-
Thread
ATSAM4E8C SPI Hilfe
); while(1) { sprintf(dataTx,"0x00"); status = spi_write_packet(SPI, &dataTx, sizeof(dataTx)); spi_read_packet(SPI,&dataRx, sizeof(dataTx)); }
spi_write_packet(SPI, &dataTx, 5); /*sprintf(dataTx,"0x00"); status = spi_write_packet(SPI, &dataTx, sizeof(dataTx)); spi_read_packet(SPI,&dataRx, sizeof(dataTx));*/ //SPI_Transfer(data_TX,data_RX,3,0xD1); } } [/c] Vielen Dank für deine Hilfe. VG
-
Thread
Vektor "Rechnung" mit C
++) a[index_V][index_U] = (double)(index_U * index_V); memcpy(b, a, 50*50*sizeof(double)); for(size_t index_U = 0; index_U < 50 ; index_U ++) for(size_t index_V = 0; index_V < 50 ; index_V ++) printf("%d %d %f %f\n", index_V,index_U,b[index_V][index_U
Elemente mit den Indizes 2 bis 9 zu kopieren, schreibst du: [c] memcpy(ziel, array+2, 8*sizeof array[0]); [/c] Falls du kein Freund von Zeigerarithmetik bist, kannst du statt array+2 auch &array[2] schreiben, was exakt dasselbe ist. Das funktioniert unabhängig vom Elementyp des Arrays
-
Thread
libusb Bulk Transfer - Linux
mal den Bulk-Transfer angeguckt: Zum Schreiben: if (usb_bulk_write(dev, EP_OUT, tmp, sizeof(tmp), 5000) != sizeof(tmp)) { printf("error: bulk write failed\n"); } dev = ist das USB Gerät EP_Out = ist der ausgehende Endpunkt tmp = sind die Daten die
2 Byte übertragen, dann ist diese Funktion erledigt. if (usb_bulk_read(dev, EP_IN, tmp1, sizeof(tmp), 5000) != sizeof(tmp)) { printf("error: bulk read failed\n"); } dev = ist das USB Gerät EP_IN = ist der eingehende Endpunkt tmp1 = ist der Puffer für eingehende
-
Thread
Zeiger Umwandlung
@Besserwisser: Du meinst sicherlich printf("%i", *sizeof*(bool)); ;-) Mit strlen kannst Du nur die Länge eines NULL-terminierten Strings ermitteln. Karsten
Ein paar Poster wissen es bereits, aber der Rückgabetyp von sizeof ist eine Ganzzahl in Bytes.... ;-)
-
Thread
avr-g++ kennt new-Operator nicht
Und wie viel Speicher reserviert dir deine "new[]" Implementierung? Ganz sich nicht "count*sizeof(CRectangle)" ;-) Grüsse
Markus M. schrieb im Beitrag #3168436: > Ganz sich nicht "count*sizeof(CRectangle)" ;-) Ok. Darüber habe ich auch vorhin nachgedacht. Meinst Du es wird die Länge des ersten Array-Elements reserviert? Hast Du einen Tip?
-
Thread
C/Zeichen aus Array vergleichen?
string.h> int main() { char code []="AABCAEE"; char element; int i=0; while (i<sizeof(code)-1) { element = code[i]; printf("Element %d: %c\n",i,element); if(strcmp(element, "A") == 0) { printf("Ausgang A Schalten\n"); } if(strcmp(element
Ausdrücke berechnet der Compiler beim Kompilieren, das Programm wird also nicht größer. [c]while (i<sizeof(program)-1)[/c] "sizeof" ist in C mit Vorsicht zu genießen. Hier funktioniert es, aber wie wäre es so: [c]for (uint8_t i = 0; program[i] != '\0'; i++) {[/c] Schließlich wird der String, den du oben
-
Thread
C: dynamischer Variablenname
0x56, 0x83 }; [/C] das Array mit allen Ausgabmustern [C] struct Pattern AllPatterns[] = { sizeof( Pattern1 ), Pattern1 }, { sizeof( Pattern2 ), Pattern2 } }; [/C]
durchspringen der Patterns einfach mit array[1] statt [0] beginnen. Ansonsten müsste es natürlich mit sizeof(Pattern1)/(Länge eines Wertes, also 8 Bit) eigentlich auch gehen. Weil oben auf ein C-Buch verwiesen wurde: Das hätte mir auch nicht großartig geholfen, da ich nicht auf die Logik gekommen bin,