-
Thread
(HID) Gerät unter Linux ansteuern
EXIT_FAILURE; } while(1){ struct input_event ie; size_t ret_code = fread(&ie, sizeof ie, 1, fp); printf("time: %ld \ntype: %u\ncode: %u\nvalue: %u\n\n", ie.time, ie.type, ie.code, ie.value); } fclose(fp); return EXIT_SUCCESS; } [/c]
-
Thread
Zähl-Algorithmus
// Erlaubte Summanden. static const int parts[] = { 1, 2 }; #define ARRAY_SIZE(X) (int) (sizeof(X) / sizeof(*X)) #define MAX_PARTS 100 // Tatsaechlich verwendete Summanden. int a[MAX_PARTS]; void output (int n_parts) { for (int i = 0; i < n_parts; ++i) printf (" %d",
-
Thread
Copy struct to uint32_t array
kopiert werden, kann aber von Alignment abhängig sein, und sozeof(Objekt) sollte teilbar sein durch sizeof(uint32_t).
-
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
FT813 / BRT815 Display-Controller Sonderzeichen
TEST_UTF8 != 0..." drin ist kann man durch das hier ersetzen: [code] EVE_cmd_inflate(0, flash, sizeof(flash)); EVE_memWrite32(61376UL + 32UL, 4096UL); [/code] Das ist jetzt speziell für das flash-image das ich in tft_data.c habe. unified.blob : 0 : 4096 Funtype_24_ASTC.glyph : 4096
-
Thread
GCC Preprozessor Berechnungen und Forced Errors
dem Compiler voran läuft und keine intime Kenntnis vom dem hat, was erst der Compiler weiss. Und sizeof kennt erst der Compiler.
Vollständigkeit halber, mit diesem Makro funktioniert es auch: [c]#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) char some_array[10]; BUILD_BUG_ON(sizeof(some_array) != 10);[/c]
-
Thread
RL78/G14 Renesas - Free Linux Toolchain
tem)) { //spill_indirect_levels++; spill_indirect_levels=spill_indirect_levels+(sizeof(default_target_reload)); // modifizierte Code Zeile tem = gen_rtx_MEM (Pmode, tem); } [/c] Nun bekomme ich einen anderen Fehler, den ich nicht ganz verstehe. [c] cfns.gperf:
-
Thread
c volatile -> wann bracht mans wirklich?
struct? Eigentlich meistens memcpy: [code] struct Foo kopie; (void) memcpy(&kopie, (void*)blub, sizeof(struct Foo)); [/code] Wobei ich mir nicht ganz sicher bin, ob das memcpy hier wirklich in jedem Fall gut gehen würde (memcpy weiß ja nix mehr von volatile). Und niemand garantiert, dass während
-
Thread
Frage zu struct in c
ziemlich schwach definiert sind, ist das aber nicht garantiert. Vorsichtshalber sollte man dann auf sizeof(date_t)==4 prüfen, um keine Überraschungen zu erleben. Einem Compiler eines 16-Bitters könnte sauer aufstossen, dass year über einer 16-Bit Grenze liegt, mit Bitlöchern als Folge. In dem Fall würde
-
Thread
GCC [STM32] -> wie sehen wie ein struct realisiert wird?
Assemblerlisting auffindbar sind (oder einfach laufen lassen). - https://en.cppreference.com/w/cpp/language/sizeof - https://en.cppreference.com/w/cpp/types/offsetof
} printf("\r\n"); bp += 16; line += 16; } } ... hexdump(tu, sizeof(tu)); [/c]
-
Thread
SD-Karte formatieren(f_mkfs) geht nur mit 4096 Bytes großem Puffer
SD work area. SD is already mounted and initialized FRESULT res = f_mkfs("", 0, formatBuffer, sizeof(formatBuffer)); //Format the SD card to FAT32 if(res != FR_OK) { return res; //If f_mkfs fails to format the SD Card the error code of f_mkfs will returned here
-
Thread
Struct alias
] #include "temp.h" .align 4 .bss .global Temp1 .global Temp2 Temp1: Temp2: .space sizeof(Temp_t) [/asm]
verwendenten Dateien: [c] /* mrtm.c */ #include "mrtm.h" #include "temp.h" static_assert( sizeof(MrtmTemp_t) <= sizeof(GlTemp), "Temp-Variable zu klein"); extern MrtmTemp_t MrtmTemp; [/c] Insgesamt spart die Aktion nicht ganz 400 Bytes gegenüber dem vorherigen Stand. Ob ich die jetzt als
-
Thread
Serial Communiction uint8_t* Arduino
mqtt_connect_configuration mqtt_connect_configuration) { char *msg_mqtt_clean = (char*) malloc(sizeof(char)*21); if(msg_mqtt_clean == NULL) { return EXIT_ERROR; } sprintf(msg_mqtt_clean,"AT+MQTTCLEAN=%d\r\n",mqtt_connect_configuration.LinkID); HAL_UART_Transmit(&huart1, (uint8
findender Fehler, da man sich sicher ist, dass das schon mal so (oder so ähnlich) geklappt hat. sizeof() strlen() mblen() Ich rate da zu ein klein wenig Aufmerksamkeit/Sorgfalt. Émile schrieb im Beitrag #7268048: > Ob char selbst wiederum signed oder unsigned ist, ist nicht festgelegt
-
Thread
Konstanter Zeiger auf ein Array der Größe 2 eines volatile structs
Wenn &arr schon keine Warnung bringt, sind Warnungen wohl aus. Was ist sizeof(Mystruct_t)? Und wofür die Klammern und *const arrp?
A. S. schrieb im Beitrag #7260695: > Was ist sizeof(Mystruct_t)? 8, wie erwartet. A. S. schrieb im Beitrag #7260695: > Wenn &arr schon keine Warnung bringt, sind Warnungen wohl aus. Hm, stimmt, ich referenziere eine Ebene zu tief. Da muss
-
Thread
Problem EEPROM nutzung
void readSetandInitStepper(){ cli(); eeprom_read_block(&stepperSetXYZ, &eestepperSetXYZ, sizeof(stepperSetXYZ)); sei(); } void writeStepperSettingstoEEPROM(){ cli(); eeprom_update_block(&stepperSetXYZ, &eestepperSetXYZ, sizeof(stepperSetXYZ)); sei(); } [/c] Nun ist mein Problem
readSetandInitStepper(){ > cli(); > eeprom_read_block(&stepperSetXYZ, &eestepperSetXYZ, > sizeof(stepperSetXYZ)); > sei(); > } > void writeStepperSettingstoEEPROM(){ > cli(); > eeprom_update_block(&stepperSetXYZ, &eestepperSetXYZ, > sizeof(stepperSetXYZ)); > sei(); > } eehm
-
Thread
Mikrocontroller: Frage zu fprintf
einen buffer in den man den Text generiert, dazu eignet sich dann snprintf: [c] snprintf(buffer, sizeof(buffer), "udata: %p\n", udata); [/c]
-
Thread
Cpp17 - Copy assignment (array member)
Korrekt macht man das mit memcpy. [code] memcpy (_data. *source._data, source._size * sizeof (int)); [/code] Ist ein schlechter Beispiel Code für Deep-Copy, den Du hier zeigst. Deep-Copy bedeutet, das beim kopieren des Objektes eine komplett eigenständige Kopie der Daten angelegt werden
-
Thread
liste c adreese vom vorigen knoten problem
NULL) { counter_u8++; liste = &(*liste)->next; } newNode = malloc(sizeof(*newNode)); if(NULL != newNode) { newNode->number_u16 = counter_u8; newNode->data_u16 = data_u16; newNode->next = NULL; } *liste = newNode; }[/c]
-
Thread
Einheitliche Regel für in C erstellte Variablen, Typen etc
b = (int16_t)a; c = (int_fast16_t)a; printf("%d %d\n%d %d %d\n", sizeof(b), sizeof(c), (int)a, (int)b, (int)c); } [/c] Ausgabe: [code] 2 8 65535 -1 65535 [/code] Wenn jetzt eine Plattform sich entscheiden würde int_fast16_t tatsächlich als int16_t zu implementieren
> b = (int16_t)a; > c = (int_fast16_t)a; > printf("%d %d\n%d %d %d\n", sizeof(b), sizeof(c), (int)a, > (int)b, (int)c); > } > > Ausgabe:2 8 > 65535 -1 65535 > > Wenn jetzt eine Plattform sich entscheiden würde int_fast16_t > tatsächlich als int16_t zu implementieren
-
Thread
memory von uint8_t werten in einer Struktur
zusätzliche Füllbytes > erweitert werden. Was auch passiert. Die Struktur wäre 12 Byte groß, was mit sizeof verifiziert werden kann. Je nach Compiler-Options kann die Struktur auch 6 oder 8 Byte groß sein.
Füllbytes >> erweitert werden. > > Was auch passiert. Die Struktur wäre 12 Byte groß, was mit sizeof > verifiziert werden kann. > > Je nach Compiler-Options kann die Struktur auch 6 oder 8 Byte groß sein. Es ist schön, wenn jetzt alles gesagt worden ist, und sogar von jedem ;-)
-
Thread
Pointer ist in der Funktion beschrieben, außerhalb wieder NULL
printList(list); } static void initList(node* list, uint8_t data_u8) { node* newList = malloc(sizeof(node)); if(NULL != newList) { newList->data_u8 = data_u8; newList->next = NULL; list = newList; printf("address: %p\tvalue: %i\r\n", newList, newList->
-
Thread
RAM speicherverbrauch von int16 arrays im ESP8266
Alt G. schrieb im Beitrag #7238848: > Wieviel speicher braucht obige deklaration? Ein sizeof() könnte Aufschluss geben. https://learn.microsoft.com/de-de/cpp/c-language/sizeof-operator-c
Johnny B. schrieb im Beitrag #7238872: > Ein sizeof() könnte Aufschluss geben. Size of array: 7200 bei 4 devices TY
-
Thread
Flexible Array Member initialisieren in C
; uint8_t MusterA_Werte[3] = { }; uint8_t MusterB_Werte[1000] = { }; Muster_t MusterA = { sizeof(MusterA_Werte), MusterA_Werte }; Muster_t MusterB = { sizeof(MusterB_Werte), MusterB_Werte }; [/c] Aber schöner wird das alles nicht.
MasterPtrCreate(unsigned char *p, unsigned n) { Master_t *m = (Master_t *) p; m->Anzahl= n-sizeof m->Anzahl; return m; } ... void x(void) { static unsigned char buf[1234]; Master_t *m=MasterPtrCreate(buf, sizeof buf); ... } [/c]
-
Thread
Ergebnisse einer FFT zusammen fassen
0; i < num_bands; i++) { float fc = bands[i]; float *coeff_b = (float *)malloc(sizeof(float) * order); float *coeff_a = (float *)malloc(sizeof(float) * order); calculate_coefficients(order, fc, coeff_b, coeff_a); filtered_signal[i] = filter(signal,coeff_b,
-
Thread
Einzelbits in Byte Namen zuweisen und auswerten
Zeit auch verändert). Wenn der z.B. als "typedef { false, true } bool;" definiert ist, liefert "sizeof Status_t" ohne /packed/ 4, mit /packed/ 1. Wo die Bits dabei landen, weiß der Deibel.
-
Thread
STM32 Timer PWM Periode dynamisch anpassen
100 }, }; int pwm_tx_finished = 0; int16_t pwm_tx_array_counter = 0; int pwm_tx_array_size = sizeof(pwm_tx_array)/sizeof(pwm_tx_array[0]); int16_t pwm_tx_period = 0; int16_t pwm_tx_pulse = 0; /* USER CODE END PV */ [/code] Im CallBack für den jeweils aktuellen Puls bereite ich den nächsten
100 }, }; int pwm_tx_finished = 0; int16_t pwm_tx_array_counter = 0; int pwm_tx_array_size = sizeof(pwm_tx_array)/sizeof(pwm_tx_array[0]); int16_t pwm_tx_period = 0; int16_t pwm_tx_pulse = 0; /* USER CODE END PV */ [/code] Der Main Loop ist leer und der µC erzeugt momentan nur diese PWM. Ich
-
Thread
Messdatenerfassung von Oszilloskop
if ((s=socket(AF_INET, SOCK_STREAM, 0))==-1) err("kein socket"); memset((char *) &si_me, 0, sizeof(si_me)); si_me.sin_family = AF_INET; si_me.sin_port = htons(5025); //Port für SCPI-Kommando über TCP inet_aton("192.168.12.220", (struct in_addr *) &si_me.sin_addr.s_addr ); if ( connect(s,(struct sockaddr *) &si_me , sizeof(si_me))==-1) err("keinconnect"); sprintf(buf,"*IDN?\n"); write(s,buf,strlen(buf)); [/c] Mit anderen Worten man kann oftmals direkt SCPI in TCP/IP Paketen versenden und sich den ganzen
-
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
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
C/C++, Linux: Veriegelung das ein Prozess nur genau 1 mal läuft
SOCK_STREAM, 0); struct sockaddr_un tmp = { .sun_family = AF_UNIX }; snprintf(tmp.sun_path+1, sizeof(tmp.sun_path)-1, "%s", "MeinProgrammName"); tmp.sun_path[0]='\0'; // "abstrakter"-Socket. int ret=bind(sock, (struct sockaddr *)&tmp, sizeof(tmp)); if (ret) { perror("Programm läuft
-
Thread
Mehrere Werte über RS485 versenden
in eine Zahl zu zerlegen. Der Vorteil: * Egal welche Endian ein System hat oder welche sizeof(int) * Mitlesen der Daten funktioniert im Klartext, man muss nicht extra ein Tool dafür basteln. * Für die Sicherheit reicht es oft, Parity einzuschalten, Framing-Errors auszuwerten und daraufhin
sensors.getTempC(Thermometer2); txData.dritterWert = wasAuchImmer(); crc8.restart(); crc8.add(txData, sizeof(txData) - sizeof(txData.crc)); txData.crc = crc8.getCRC(); serial.write((char *) &txData, sizeof(txData)); delay(1000); } [/c] Durch die Pause (die durchaus auch noch länger sein dürfte