-
Thread
Wärmezähler über optische M-Bus-Schnittstelle auslesen
0; } void set_blocking(int fd, int should_block) { struct termios tty; memset(&tty, 0, sizeof tty); if (tcgetattr(fd, &tty) != 0) { printf("error %d from tggetattr", errno); return; } tty.c_cc[VMIN] = should_block ? 1 : 0; tty.c_cc[VTIME] = 5; // 0.5 seconds
set_blocking(fd, 1); // set blocking for (uint8_t i = 0; i < 10; i++) { memset(init_seq, 0x00, sizeof(init_seq)); uint32_t transmission_len = 0; transmission_len = 140; ret_out = write(fd, init_seq, transmission_len); // sent wakeup if (ret_out != transmission_len) return
-
Thread
Registerbereich als array of structs betrachten
DIEPCTL = 42; in[1].DIEPTSIZ = 21;[/c] Beim Zugriff auf "in[i].DIEPCTL" wird auf die Adresse "in + sizeof(USB_OTG_INEndpointTypeDef)*i" zugegriffen. Da USB_OTG_INEndpointTypeDef praktischerweise so definiert ist dass es 32 Bytes groß ist, und der Abstand zwischen DIEPCTL0 und DIEPCTL1 genau 32 Bytes ist
-
Thread
Zeiger auf array-Element: Inkrement WTF?
enthalten, was sich auch in sizeof() niederschlägt.
ist cursorBitmap ein Zeiger auf uint8_t, entsprechend wird bei der Adressberechnung die 10 mit sizeof(uint8_t)=1 multipliziert. In &cursorBitmap+10 ist cursorBitmap ein Zeiger auf uint8_t[20] (das Array hat auf Grund der Initialisierung 20 Werte). Die 10 wird nun nicht mit 1, sondern mit sizeof
-
Thread
Programm mit einem Taster steuern
; digitalWrite(LED_BUILTIN,!digitalRead(LED_BUILTIN)); timer.start(); if(++index>=sizeof(muster)) index = 0; } } [/c]
-
Thread
32 Bitter: Einen Array packen
kannst du (bei Verwendung von C++) prüfen dass es wirklich nur 1024 Bytes sind: [c]static_assert(sizeof(feld) == 1024, "Feld hat falsche Groesse!");[/c] Chris J. schrieb im Beitrag #5190619: > Wie löse ich mein Problem mit dem GCC, so dass ich auch nachschauen kann > was er gemacht hat? Was hast
vermutest, dass ein Array irgendwie ein bisschen größer ist als gedacht. Eigentlich 4 Mal so groß, aber sizeof ist zu kompliziert, deshalb fragst Du hier nach einer Lösung. Für ein Problem, dass Du nicht kennst aber das ja da sein könnte.
-
Thread
Cycle Count auswerten und verstehen anhand von Shifts und Arrays
verstehe nur folgendes nicht so ganz. Es wird definiert: [c] const unsigned int mask = (CHAR_BIT*sizeof(x)-1); // e.g. 31 [/c] (Gefunden habe ich dazu "CHAR_BIT is the number of bits in char", damit ist CHAR_BIT = 4.) und verwendet: [c]n&= mask;[/c] Wenn ich das richtig verstehe, skaliere ich
-
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
C-Funktion: externen Pointer verändern -> Pointer auf Pointer notwendig?
stattfindet. [c] #include <stdio.h> int main(void) { int a[10]; printf("%d %d\n", sizeof(a), sizeof(&a[0])); } [/c]
-
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
STM32 RF24 Kommunikation
printf("%d\r\n",radio.available()); while(radio.available()){ radio.read(&data,sizeof(data)); serial0.printf("Daten \n"); counter++; } } radio.startListening(); t.stop(); } [/c]
radio.enableDynamicPayloads(); // Dynamische Payload Size aktivieren //radio.setPayloadSize(sizeof(data)); radio.setRetries(15,15); // 4ms Pause, 5 Wiederholungen radio.setCRCLength(RF24_CRC_16); // 16 Bit CRC radio.openWritingPipe(TXADDRESS); set_wdt_isr(); /* Struct
-
Thread
Analogwert Senden ?
binär) Werten ist fwrite() Bei deinem Beispiel vom Eröffnugnspost: [c]fwrite(&Ausgabe_Wert, sizeof(Ausgabe_Wert), 1, stdout);[/c]
-
Thread
C - Pointer Arithmethik auf Strukturen?
while(fread(&entry[i], sizeof(HIGHSCORE), 1, highscore_file)) { //printf("Test %s - %d\n", entry[i].owner, entry[i].score); i++; } return entry;
file_size = ftell(highscore_file); rewind(highscore_file); entry_count = file_size / sizeof(HIGHSCORE); // Daten allozieren entrys = malloc(entry_count * sizeof(HIGHSCORE)); // Daten auslesen if(entrys > 0) { fread(entrys, sizeof
-
Thread
csv Datei erstellen / Permutation (Sprache C )
c1++) for (char c2 = '0'; c2 <= '2'; c2++) for (size_t i = 0; i < sizeof (p) / sizeof (*p); i++) printf ("%4d: %s %c%c%c\n", ++n , p[i], c0, c1, c2); return EXIT_SUCCESS; }[/c] Ausgabe: [pre] 1: 012 000 2: 102 000 3: 201 000
-
Thread
16-Bit-Array in 8-Bit-Array zerlegen
deines 16-Bit Arraya hinaus. > das Array> darf auch zerstört werden. [c]for( size_t i = 0; i<sizeof(var1)/sizeof(*var1); i++ ) { var1[i] = ntohs(var1[i]);[/c]
dividiert man nicht durch die Größe vom Typ, sondern durch die Größe eines Elementes vom Array. sizeof(var1)/sizeof(var1[0]); oder sizeof(var1)/sizeof(*var1); Das kann man dann auch als Makro machen [c]#define SIZEOFARRAY(array) (sizeof(array)/sizeof(*array))[/c] Dann braucht man den Typ
-
Thread
atMega memcpy_P liefert unerwartete Ergebnisse
00 panel: data 0x0102 00 00 00 00 00 00 00 00 00 00 00 00 00 memcpy_P(&panel, buffer0, sizeof(panel)); Speicher nach memcpy: buffer0: data 0x01D3 80 00 7f 61 38 7f 34 00 7f 7f 7f 00 00 panel: data 0x0102 91 cf 91 08 95 cf 93 df 93 00 d0 00 d0 Wenn ich per Schleife byte für byte
-
Thread
Commando aus String suchen..
{ Serial.println(F("serBUF ov-> DEL")); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); // 30.554 Bytes memset(&serial_in_command[0], 0, sizeof(serial_in_command)); // 30.554 Bytes // *serial_in_command=0; chr_cnt=0;
} // if( !strcmp(serial_in_command, "hell??") ) memset(&serial_in_command[0], 0, sizeof(serial_in_command)); } // if( !strcmp(serial_in_command, "hell") ) [/c]
-
Thread
Elemente eines Zeiger Arrays ermitteln?
Die Größe des ganzen Arrays im Speicher ist : [c]sizeof(Array)[/c] Die Anzahl der Elemente im Array ist : [c]sizeof(Array)/sizeof(Array[0])[/c]
geht sizeof da nicht?
-
Thread
MEGA32 & Bootloader
buf) { uart_puts("P\n\r"); _delay_ms(100); program_page(page, buf); memset(buf, 0xFF, sizeof(SPM_PAGESIZE)); } int main() { /* Intel-HEX Zieladresse */ uint32_t hex_addr = 0, /* Intel-HEX Zieladress-Offset */ hex_addr_offset = 0, /* Zu schreibende Flash-Page */
(void*)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 = GICR; GICR = temp | (1<<IVCE); GICR = temp | (1<<IVSEL); /* Einstellen
-
Thread
Probleme beim Konvertieren von String to const Char *
die Methode welche Konvertiert sieht so aus: [c]char* to_Cchr( String str ) { char __str[sizeof(str)-1]; str.toCharArray(__str, sizeof(__str)); return __str; }[/c] das Ergebnis (etwa so): >wert_im_ee⸮⸮⸮?⸮b @X⸮⸮?t⸮⸮?⸮⸮⸮?% @⸮⸮? was mach ich Falsch... > auch wenn der Wert nicht
-
Thread
Array initialisieren in Keil
parameter_id[PARAMETER_BUFF_SIZE]; static void my_init_func(void){ memset(parameter_id,0xFF,sizeof(parameter_id)); } [/c]
-
Thread
Zeitmessung mit Funk
buffer) // 24:18 hamming must be included #define transmit() if(id!=-1) { rfpreamble(5); for(i=0;i<sizeof(buffer);i++) rfputch(buffer[i]); } #define enableTx() #else #define send(x) if(id!=-1) rfputch(i=x), sum+=i&0xf, sum+=(i>>4)&0xf, sum&=0xf #define enableTx() if(id!=-1) rfpreamble(5); #define
-
Thread
St7565 128x32 Display nur 1. Zeile beschreibbar
0x81, // electronic volume 0x1B }; void init_display_uartspi(void) { uint8_t byte=sizeof(init_cmd_array); PORTE.DIR|= LCD_BACKLIGHT; PORTE.OUT|= LCD_BACKLIGHT; PORTF.DIR|= LCD_CS; PORTF.OUT|= LCD_CS; PORTA.DIR|= LCD_RES; PORTD.DIR|= (LCD_CLK+LCD_A0+LCD_MOSI)
PORTA.OUT|=LCD_RES; // reset high while(byte) { send_lcd_cmd(init_cmd_array[sizeof(init_cmd_array)-byte]); byte--; } fill_display(LCD_WIDTH+1,LCD_HEIGHT,0x00); } #include <avr/io.h> #include <inttypes.h> #include "init_display_DEM128064K.h" #include
-
Thread
Linkerskript Memoryspaces
PROVIDE(_data_loadaddr = LOADADDR(.data)); PROVIDE(_data_addr_end = ADDR(.data) + SIZEOF(.data)); PROVIDE(_bss_addr = ADDR(.bss)); PROVIDE(_bss_addr_end = ADDR(.bss) + SIZEOF(.bss)); } [/code] und dann im reset handler, oder eventuell auch in der main() ganz am
-
Thread
STM32 Daten kopieren Problem
data>>8)&0xFF; DataArray[5] = (data)&0xFF; oder memcpy( &DataArray[2], (uint8_t*)&data ), sizeof(uint32_t)); [/c] vieleicht hilft es auch das bytearray passend zu alignen __attribute(aligned(4)) oder so ... Thomas schrieb im Beitrag #5136179: > Du nimmst den falschen Controller.
-
Thread
C++ Objektarray im Konstruktor initialisieren?
nein. Denn ein Objekt von einen Type brauch auch eine definierte Größe. was soll denn sizeof( Fahrrad ) liefern? Man könnte es mit Templates lösen.
cbe schrieb im Beitrag #5135691: > reifen = (Reifen*)malloc(sizeof(Reifen[4])); > for(int i = 0; i < 4; ++i) > new (&reifen[i]) Reifen(245); Sorry, aber malloc und new zu mischen ist Gewurschtel.
-
Thread
[C] Namensgebung von 'strchr' oder 'memchr'
hat. Geht nicht. Ein char ist ein Byte gross. Ein Byte darf aber mehr als 8 Bits haben. "The sizeof operator yields the size (in bytes) of its operand," "When sizeof is applied to an operand that has type char, unsigned char, or signed char, (or a qualified version thereof) the result is 1."
sm320f2812-ep?keyMatch=2812&tisearch=Search-EN-Everything Dort hat eine Speicherzelle 16 Bit. sizeof(char) == sizeof(short) == sizeof(int) == 1, alles 16 Bit. Speichert man wirklich nur 8 Bit Zeichen, dann sind die obersten 8 Bit verschwendet. Man kann auch im Speicher kein Byte alleine ansprechen
-
Thread
MemleakErrormeldung
Peter II schrieb im Beitrag #5132297: > char* RecPointer = (char*) malloc(sizeof(char) * strlen(buf)); Das war oben schon falsch. Richtig ist: [c] char* RecPointer = (char*) malloc(strlen(buf) + 1); [/c] Die Multiplikation mit sizeof(char) ist zwar nicht falsch, kann aber weggelassen werden, da sizeof(char) immer 1 ist.
-
Thread
ESP8266 Webradio Stream
); receivezaehler=0; memset(&empfangsbuffer[0], 0, sizeof(empfangsbuffer)); HAL_Delay(1000); HAL_UART_Transmit(&huart6,connect,44,1000); HAL_Delay(1000); printf("An ESP gesendet: %s",connect); printf("ESP Antwort: %s \n\n", empfangsbuffer); receivezaehler=0; memset(&empfangsbuffer[0], 0, sizeof(empfangsbuffer)); /* HAL_Delay(1000); HAL_UART_Transmit(&huart6,sendebuffer13,10,1000); HAL_Delay(1000); printf("An ESP gesendet: %s",sendebuffer13); printf("ESP Antwort: %s \n
-
Thread
Speicherplatz global reservieren?!
Jan H. schrieb im Beitrag #5131491: > uint8_t *buff = (uint8_t *) calloc(11,sizeof(int)); > So versuche ich den Speicherplatz zu reservieren. Ist das falsch? In der > main() klappt es jedoch. Ds geht statisch so nicht ... Du würdest dann einfach uint8_t buff[11*sizeof(
eines calloc(11,sizeof(int)), wobei dann natürlich kein späterer realloc() mehr möglich und ein free() desselben sinnfrei ist.
-
Thread
Queue für verschiedene Events in C
)(struct service1_args*); struct service1_args args; } *result = (struct special*)malloc(sizeof(special)); special->func = &service1; special->args = (struct service1_args){x,y}; return (QueueEntry*)special; } [/c] makeService*Call lassen sich mit ein bisschen #define-Magie mit relativ
diese Information packt man mit in die Datenstruktur und übergibt sie bei der Initialisierung per sizeof. Der Pufferspeicher wird mit einem 8-Bit-Datentyp implementiert, die Grösse der Element sind immer Vielfache davon. Ich wüsste nicht, wozu man da noch einen Callback benötigt.
-
Thread
STM32: Bitbanding für Arrays?
include <stdbool.h> #include <stddef.h> bool getBit (size_t index) { const size_t entrySize = sizeof(ee_fat[0]) * CHAR_BIT; return ee_fat [index / entrySize] & (1 << (index % entrySize)); } void setBit (size_t index, bool value) { const size_t entrySize = sizeof(ee_fat[0]) * CHAR_BIT; const
ne lokale Variable. [c] bool getBit (uint8_t* p, size_t index) { const size_t entrySize = sizeof(p[0]) * CHAR_BIT; return p[index / entrySize] & (1 << (index % entrySize)); } void setBit (uint8_t* p, size_t index, bool value) { const size_t entrySize = sizeof(p[0]) * CHAR_BIT; const
-
Thread
Mikrocontroller: Ringpuffer für UART-Kommunikation
Speicher //reservieren ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)malloc(sizeof(ringbuffer_handler_t)); //Werte des Handler belegen //readIndex und WriteIndex zu Anfang 0 //fuer fifo muss genuegend Speicher reserviert werden, //um size Datenelemente
Parameter) buffer->readIndex=0; buffer->writeIndex=0; buffer->fifo = (userdata_t *)malloc(sizeof(userdata_t) * (size + 1)); buffer->size = size; //Zeiger auf Ringbuffer-Handler zurueckgeben return buffer; } [/c] Schau dir noch einmal an, welche Menge speicher für welchen
-
Thread
Fehlermeldungen, aber erfolgreiches Compilieren und Uploaden
typename... T> struct TypeList { template <typename IT = int> using IndexSeq = GenSeq<IT, sizeof... (T)>; }; int main () { }[/c] GCC und Clang finden hier keine Fehler, eclipse schon (siehe Screenshot). Zum Problem des TO: Eclipse findet gcc & g++ nicht. Die werden aber ja gar nicht gebraucht
-
Thread
C: Variablen und Typen in ihre Basistypen zerlegen (YACC & Co?)
0 | tSet 0 | unsigned char Status 4 | tValue Value | [sizeof=8, align=4] *** Dumping AST Record Layout 0 | tMeasure 0 | const char * name 4 | tSet Set 4 | unsigned char Status 8 | tValue Value | [sizeof=12, align=4] *** Dumping IRgen Record Layout Record: RecordDecl 0x3b8afb0 <asdf.c:3:9, line:7:1> line:3:9 struct definition |-MaxFieldAlignmentAttr 0x3b8b050 <<invalid sloc>> Implicit 32 |-FieldDecl
-
Thread
OpenMilight Neues Protokoll?
void loop() { if (mlr.available()) { uint8_t packet[9]; size_t packet_length = sizeof(packet); Serial.println(); Serial.print("<-- "); if (packet_length<0x10) Serial.print("0"); Serial.print(packet_length,HEX); Serial.print(" "); mlr.read
delay(1000); */ if (mlr.available()) { uint8_t packet[9]; size_t packet_length = sizeof(packet); Serial.println(); Serial.print("<-- "); mlr.read(packet, packet_length); if (packet_length<0x10) Serial.print("0"); Serial.print(packet_length,HEX);
-
Thread
nRF24L01+ und Arduino Nano
// First, stop listening so we can talk radio.write( &got_time, sizeof(unsigned long) ); // Send the final one back. radio.startListening(); // Now, resume listening so we catch the next packets.
[] = "Hello World"; Serial.println("------In der LOOP"); radio.write(&text, sizeof(text)); Serial.println("------Daten geschrieben"); delay(1000); } [/c] Leider bleibt er in der Zeile "radio.write(&text, sizeof(text))" bzw, heißt die Ausgabe: [code]