-
Thread
avr-gcc: Warnung bei fehlendem Cast aktivieren?
wäre korrekterweise folgendes: [c] for(uint8_t i{}; i < 33; i++) { assert(i < (sizeof(uint32_t) * 8)); uint32_t mask = uint32_t{1} << i; } [/c] Das schreibt zwar so keiner hin, wäre aber der korrekte Ansatz, denn der gültige Wertebereich für den BitShift kann durch
-
Thread
PetitFS SD DatenLogger
test file. if (pf_open("TEST.TXT")) errorHalt("pf_open"); UINT nr; pf_write("Hallo",sizeof("Test"),&nr); // Dump test file to Serial. /*while (1) { if (pf_read(buf, sizeof(buf), &nr)) errorHalt("pf_read"); if (nr == 0) break; Serial.write(buf, nr); }*/ } //---
-
Thread
double Ausgabe
NULL, 0); if (temp & 2048) { temp |= 0xfffff000UL; } len = snprintf (buf, sizeof buf, "%+06d", temp * 625); bp = buf; for (bc = 0; bc < 9 - len; bc++) { putchar (' '); } for (bc = 0; bc < len - 4; bc++) { putchar (*bp++); } putchar ('.');
-
Thread
C -> UART -> Übertragen von Strukturen
Struktur? Aufgrund von Padding nicht sinnvoll auf die dargestellte Weise. Man kann offsetof() und sizeof() auf die Elemente ansetzen. Beschreibt man dann jedes Element als sizeof()/offsetof() Pärchen z.B. in einem Array, kann man sich eine generische Funktion bauen, die Strukturen "verschicken" kann.
MSG_TYPE_EOL }; static const ITEM msg_type_1[] = { {offsetof(Filter_t::uiParameter), sizeof(Filter_t::uiParameter)}, //... }; static const MSG messages[] = { { sizeof(msg_type_1)/sizeof(msg_type_1[0]), msg_type_1 }, //... }; [/code] Dann kann man eine generische Funktion
-
Thread
C++ Mc gcc Object löschen
void *alloc(size_t bytes) { // einfacher Fall, keine bzw. leere freelist heaptop-=bytes+sizeof(bytes); *(size_t *)heaptop=bytes; return heaptop+sizeof(bytes); } void free(void * ptr) { if(ptr==heaptop+sizeof(size_t)) heaptop+=*(size_t *)heaptop; else // aufwändiger } [
Elementen. Bei unterschiedlich grossen kann man nicht berechnen, dass das dritte Element bei 2+sizeof(element) steht. Man braucht Pointer, geht aber auch, gern gemacht um strings in Worte zu zerlegen oder so: [c] element ** mem=malloc(elementanzahl*sizeof(element *)+elementgesamtgrösse); for(
-
Thread
C -> enum -> Speicher
Die Größe könnte man mit 'sizeof' abfragen, ich bin nicht sicher, je nach Maschine ist das auch Mal int32 oder so.
-
Thread
uart raspberry pi, warum neuer pointer zum senden?
Muss natürlich "sizeof(str)-1" heißen :-/
#5980571: > Du merkst den Unterschied, wenn du den Variablen Werte zuweisen willst > oder per sizeof die Größe abfragst ;-) Ach ja, logisch. Also kenne ich den Unterschied ja doch, war mir nur nicht bewusst.
-
Thread
Datenformat interpretieren
year: 7; } s; } u; u.b = b; char result[20]; snprintf(result, sizeof(result), "%04d-%02d-%02d", u.s.year + year_offset, u.s.month, u.s.day); return result; } [/c]
; month = (b & 0x01e0) >> 5; day = b & 0x001f; char result[20]; snprintf(result, sizeof(result), "%04d-%02d-%02d", year + year_offset, month, day); return result; } [/c]
-
Thread
tlc5947 spi programmieren, lauflicht
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0)); digitalWrite(9, 0); memcpy(buffer, muster, sizeof(muster)); channel[i] = 4095; SPI.transfer(buffer, 36); digitalWrite(9, 1); SPI.endTransaction(); delay(3000); i++; } ############## kann mir hier jemand helfen und sagen warum
die Umwandlung von muster in buffer rein, kein einfaches kopieren. > memcpy(buffer, muster, sizeof(muster)); Das fliegt raus. > channel[i] = 4095; > SPI.transfer(buffer, 36); > digitalWrite(9, 1); > SPI.endTransaction(); Ich glaube die beiden Zeilen müssen vertauscht werden,
-
Thread
Mehrfache if.Verkleinern
char str1[] = "ledaus"; char str2[7] = "ledaus"; len = strlen(ptr); size = sizeof(ptr); printf("%s %d %d\n", ptr , len, size); len = strlen(str1); size = sizeof(str1); printf("%s %d %d\n", str1 , len, size); len = strlen(str2); size = sizeof(str2);
-
Thread
C Struct arbeiten
offsetof(x, speedL), offsetof(x, encR), offsetof(x, encL) }; for (int i = 0; i < sizeof(at)/sizeof(at[0]); ++i) { int element = ((const int*)&x)[at[i]/sizeof(int)]; printf("%d\n", element); } [/code]
-
Thread
Basic Interpreter für uC ?
end\"\n\ 70 end\n\ 100 print \"subroutine\"\n\ 110 return\n"; static uint32_t BASIC_ROM_SIZE = sizeof(basic_prg); } [/c]
-
Thread
PCAN-Basic API in C# verwenden
= PCANBasic.GetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_CHANNEL_CONDITION, out iBuffer, sizeof(UInt32)); bool available = ((stsResult == TPCANStatus.PCAN_ERROR_OK) && ((iBuffer & PCANBasic.PCAN_CHANNEL_AVAILABLE) == PCANBasic.PCAN_CHANNEL_AVAILABLE)); if( available ) { stsResult
-
Thread
TWI Status auslesen
addr_length = 1 .chip = device_address, .buffer = 0xFF, .length = sizeof(char), .no_wait = false, }; twi_options_t m_test = { .speed = MASTER_SPEED, .chip = MASTER_ADDR }; while
-
Thread
ATMega Flash wird langsam knapp. Upgrade o. Plattformwechsel?
replace, char *string) { // Speicher reservieren tempString = (char*) malloc(strlen(string) * sizeof(char)); [/c] Naja, theoretisch korrekt, praktisch eher ungünstig. Du hast so oder so nur wenig Speicher, da reicht es, eine lokale, temporäre Variable (Array) anzulegen. Mit ein wenig Nachdenken
-
Thread
SPI Register auslesen Raspberry Pi
auf einmal übermitteln kann, sende ich das ganze Array mit [code]bcm2835_spi_transfern(spiOut,sizeof(spiOut));[/code] an den IC. Das funktionierte auch auf Anhieb und ich konnte den Pin mit dem Multimeter als HIGH messen. Soweit so gut. Wie lese ich nun aber den Register wieder ein um ihn mit
-
Thread
ARM Cortex M3/M4: Software-Breakpoints
CoreDebug_DEMCR_VC_MMERR_Pos) ; } // Flag RTOS Stack memories memset(tcp_stack , 0xcc, sizeof(tcp_stack )); memset(timer_stack , 0xcc, sizeof(timer_stack )); memset(..._stack , 0xcc, sizeof(..._stack )); #else JTAG_Lock(); #endif [/c]
CoreDebug_DEMCR_VC_MMERR_Pos) ; } // Flag RTOS Stack memories memset(tcp_stack , 0xcc, sizeof(tcp_stack )); memset(timer_stack , 0xcc, sizeof(timer_stack )); memset(..._stack , 0xcc, sizeof(..._stack )); #else JTAG_Lock(); #endif [/c]
-
Thread
Segmentation fault
Student; struct bestenote *NOTE; void Einlesen() { Student = (struct Studenten *) malloc(sizeof(struct Studenten)); printf("Wieviele Studierende sind es?\n"); scanf("%d", &Anzahl); for(N=0; N<Anzahl; N++) { printf("\nWie lautet der Name des %d. Studierenden?\n", N+1
Student; struct bestenote *NOTE; void Einlesen() { Student = (struct Studenten *) malloc(sizeof(struct Studenten)); printf("Wieviele Studierende sind es?\n"); scanf("%d", &Anzahl); for(N=0; N<Anzahl; N++) { printf("\nWie lautet der Name des %d. Studierenden?\n", N+1
-
Thread
Arduino und char-Tabelle
] = {"Sonntag ","Monday","Dien ","Mi ","Do ","Friday!!! ","Sa ","--"}; size_t arr_len=sizeof(text)/sizeof(text[0]); for(size_t i=0; i<arr_len; i++){ size_t str_len=strlen(text[i]); for(size_t j=0; j<str_len; j++){ printf("%c", text[i][j]);
es 20 Zeichen mit den /0 am ende ? Na teste das doch selbst aus: [c] printf("%zd\n", sizeof(text)); [/c] Du hast ein Array von Zeigern, die auf Strings zeigen. (die wiederum char-Array sind). Also [][].
-
Thread
C: Unterwartetes Vorzeichen
type ‘int’, but argument 2 has type ‘long unsigned int’ [-Wformat=] printf("size=%i,%i ", sizeof(*enc), sizeof(enc)); ^ mi.c:41:22: warning: format ‘%i’ expects argument of type ‘int’, but argument 3 has type ‘long unsigned int’ [-Wformat=] printf("size=%i,%i ", sizeof
mit dem falschen Format %i > aus. Hier solltest Du %lu verwenden. printf("size=%lu,%lu ", > sizeof(*enc), sizeof(enc)); Nein. Wie ich schon schrieb, ist %zu (hatte nur %z geschrieben) das richtige. sizeof gibt einen size_t zurück, der ein Typedef für unsigned long sein _kann_, aber nicht _muss
-
Thread
Atmel SAM - USB iso Endpoint Funktionsweise
the data received on endpoint OUT buf_ptr = &main_buf_loopback[ main_buf_iso_sel *(sizeof(main_buf_loopback)/2) ]; udi_vendor_iso_in_run( buf_ptr, nb_transfered, main_vendor_iso_in_received); } // Switch of buffer main_buf_iso_sel = main_buf_iso_sel? 0:1; buf_ptr = &main_buf_loopback[ main_buf_iso_sel *(sizeof(main_buf_loopback)/2) ]; // Send on IN endpoint the data received on endpoint OUT udi_vendor_iso_out_run( buf_ptr, udd_is_high_speed()? UDI_VENDOR_EPS_SIZE_ISO_FS,
-
Thread
Problem mit while()
Noch ein Hinweis, je nach Zielsystem ist sizeof(double) = sizeof(float).
-
Thread
PIN-Code Algorithmus von Blaupunkt Radio
*fo) { int r = 0; lzo_bytep buf = NULL; lzo_uint buf_len; unsigned char m [ sizeof(magic) ]; lzo_uint32_t flags; int method; int compression_level; lzo_uint block_size; lzo_uint32_t checksum; lzo_uint32_t dummy; total_in = total_out = 0; /* * Step 1: check magic header, read flags & block size, init checksum */ if (xread(fi, m, sizeof(magic), 1) != sizeof(magic) || memcmp(m, magic, sizeof(magic)) != 0) { printf("%s: header error - this file is not compressed by lzopack\n", progname); r = 1;
-
Thread
PROGMEM in C++
KeyboardClass::SetFromPROGMEM (uint8_t Value) { tButton Result; memcpy_P (&Result, &KeyButton[Value], sizeof (Result)); return Result; }[/c]
-
Thread
Probleme mit Call by Reference
GEKU schrieb im Beitrag #5915645: > Das hieße doch, dass es keine Plattform gibt, bei der sizeof (char) != 1 > ist oder? Richtig. sizeof liefert die Größe in Vielfachen von char. char ist genau 1 char groß, daher sizeof(char)=1. char ist aber eben nicht unbedingt 8 bit groß. Die Anzahl an Bits in einem Datentyp bestimmt man mit sizeof (X)*CHAR_BIT.
-
Thread
strstr() gibt keinen NULL pointer zurück? (atmega 2560)
uart_char; char_counter++; } uart_string[char_counter] = '\0'; for(int i = 0;i<sizeof(uart_string);i++){ USART_Transmit(uart_string[i]); } char *hier; char x_values[50][7]; char y_values[50][7]; int number_of_coordinates = 0; USART_Transmit(sizeof(uart_string
uart_char; char_counter++; } uart_string[char_counter] = '\0'; for(int i = 0;i<sizeof(uart_string);i++){ USART_Transmit(uart_string[i]); } char *hier; char x_values[50][7]; char y_values[50][7]; int number_of_coordinates = 0; USART_Transmit(sizeof(uart_string
-
Thread
STM32 I2S mit DMA
eingehenden Daten gespeichert werden. HAL_I2SEx_TransmitReceive_DMA(&handler_i2s, buf_out, buf_in, sizeof(buf_out)/2); Ich finde die Beschreibung der Funktion etwas dürftig: pTxData a 16-bit pointer to the Transmit data buffer. pRxData a 16-bit pointer to the Receive data buffer. Füllt der DMA
-
Thread
frage zu sizeof() in c
Hallo, ich habe ein verständnisproblem zu dem Befehl sizeof() in c. z.B. const uint8_t x[] = {0x00, 0x01, 0x02}; sizeof(x) ergibt 24. Um die Anzahl der elemente im array zu ermittlen, mache ich sizeof(x)/(sizeof(uint8_t)); Jetzt habe ich zwei arrays
Das sizeof(x) sollte 3 ergeben. Die Anzahl der Elemente bekommst du besser mit sizeof(x)/sizeof(x[0]) Dann spielt der Typ keine Rolle mehr. Mach das nicht bei Funktionsparametern. Die Länge eines Strings
-
Thread
Implementierung FIR in C
zu bilden memmove( &(State->lastValues[1]), &(State->lastValues[0]), (DERIVATIVE_N_VALUES-1)*sizeof(int64_t)); State->lastValues[0] = u; // FIR-Koeffizienten-Array bestuecken (erste Haelfte) // Das Koeffizienten-Array ist antisymmetrisch, deswegen wird nur ueber die Haelfte iteriert