-
Thread
cin char variable eine Zahl eingeben.
&var); // 5 eingeben var = 5 Der richtige Formatspecifier dafür ist "%hhd" Bei %d werden sizeof(int) Bytes überschrieben. Und dann steht in var nur bei little Endian Maschinen der richtige Wert. Nachfolgende Variablen werden evtl. (abhängig vom Alignement) überschrieben.
// 5 eingeben var = 5 > > Der richtige Formatspecifier dafür ist "%hhd" > > Bei %d werden sizeof(int) Bytes überschrieben. Und dann steht in var nur > bei little Endian Maschinen der richtige Wert. > Nachfolgende Variablen werden evtl. (abhängig vom Alignement) > überschrieben. Oder anders
-
Thread
Frage Timing Cortex-M7
t vectorTable[128] __attribute__ ((aligned(256))); memcpy(vectorTable, (uint32_t*)0x00400000, sizeof(uint32_t) * 128); SCB->VTOR = (uint32_t) vectorTable; [/code] zu Beginn der Mainroutine. Das funktioniert auch. Würde es nicht, käme es zum Totalabsturz weil ich ja VTOR umgeleitet habe.
-
Thread
C - Struct macht mich wahnsinnig
im Beitrag #5413599: > LightsTick % (lights[i].time_dark + lights[i].time_bright) Wenn 1ull<<sizeof(LightsTick) nicht durch time_dark + time_bright teilbar ist, also time_dark + time_bright keine zweierpotenz ist, kommt es beim overflow von LightsTick zu einer zu kurzen Wartezeit. Ausserdem, ist
-
Thread
Bitstatusabfrage Macro - ist das sicher?
den Nachteil, dass ein Rechtsshift recht wahrscheinlich eine Optimierung auf Operationen unterhalb sizeof(int) verhindert, zumindest wenn x nicht einfach bloss ein Port oder eine Variable ist, da Bits vom auf int erweiterten Zwischenergebnis nach unten rutschen.
-
Thread
Webradio basteln
WiFi.forceSleepBegin(); Serial.begin(115200); delay(1000); file = new AudioFileSourcePROGMEM( enigma_mod, sizeof(enigma_mod) ); // out = new AudioOutputI2S(); out = new AudioOutputI2SNoDAC(0); // I2S 0 interface, wird für Sigma Delta bentutzt, Pins: 22,25,26 out->SetGain(0.9); mod = new AudioGeneratorMOD
-
Thread
Location Adress in STM via SPI
stdio.h> #include <stdint.h> int main () { char message [20]; int count = snprintf (message, sizeof (message), "Adresse: 0x%08" PRIXPTR, (uintptr_t) message); if (count < sizeof(message)) { HAL_SPI_Transmit(&spi2, (uint8_t *)message, count, HAL_MAX_DELAY); } else { // Error ...
-
Thread
Mehrere vorhandene Funktionen für bis zu 4 UART's nutzen?
lassen. Also z.B. in main [c] static unsigned char buf[128]; Uart0.init(9600, 8, 1, buf, sizeof(buf)); [/c] > 2. > Die Formatierungsroutinen bekommen dann alle eine Erweiterung bei der > Übergabe, welche auf die entsprochene z.B. UART0 Struct zeigt? > Uart_str(&Uart0, "Auch mal an die
-
Thread
Warum wird aus einem right-shift eines uint8_t ein 16-Bit arithm.-shift beim avr-gcc
populäreren Architektur reproduziert werden kann. Hier nach Möglichkeit auf einer, welche wie avr sizeof(int) > sizeof(word) erfüllt, d.h. >> promotet zu int.
-
Artikel
C Makros
Bitmanipulation. Sonstiges. Dies funktioniert bei Ganzzahlen und Pointern gleicher Größe (gemäß sizeof()) und Endianess sowie Representation (was meist der Fall ist). Eine weitere (harmlose) Voraussetzung ist, dass die beiden nicht überlappen. Darüber hinaus sind aber ganz allgemein Makros, die eines
-
Thread
SAM C20 DMA Irritation
den DMA übergeben. Das Beispiel meint: [c]descriptor.destination_address = (uint32_t)(array + sizeof(array));[/c] Was für mich nicht die letzte Addresse ist, sondern die "erste Addresse hinter dem array" wäre. Gemäß Datenblatt hätte ich geschrieben/erwartet: [c]descriptor.destination_address = (uint32_t)(array + sizeof(array) - 1 * BEATSIZE);[/c] Hat das jemand durchschaut und kann mir sagen, warum die Addressangabe so ungewöhnlich ist und ob ich einen Denkfehler mache?
-
Thread
Durchschnitt von 16-bit Farbwerten berechnen
; float hitDistance = 1e20f; struct Sphere hitObject = {}; for(int i = 0; i < (sizeof(spheres) / sizeof(spheres[0])); i++) { float dist = intersectSphere(spheres[i], ry); if(dist != -1.0 && dist < hitDistance) { hitDistance = dist; hitObject
{ return a * b; } int main (void) { uint16_t a = 300, b = 400; printf ("// sizeof (int) = %d\n", (int) sizeof (int)); printf ("// Ausgabe: %" PRIu16 " * %" PRIu16 " = %" PRIu32 "\n", a, b, mul (a, b)); } // sizeof (int) = 2 // Ausgabe: 300 * 400 = 54464
-
Thread
[Nucleo-F103] memset hängt
gefragt: memset Parameter nicht verwechselt? Passiert mir nämlich manchmal ;) [c] memset(p,sizeof(p),-1); [/c] Versucht 2^32 bytes zu schreiben.
-
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
Verständnisfrage zur Ablage von Variablen beim ARM M3
Fälle sicher zu gehen könntest Du ein statisches assert auf die von Hand ausgerechnete zu erwartete sizeof() des ungepacken structs mit einbauen, so knallt es beim Kompilieren sofort wenn versehentlich was verrutscht ist oder sich auf einem neuen Prozessor andere Alignment-Regeln ergeben (unwahrscheinlich
-
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
Buch für C-Einstieg
Compiler dies nicht unterstützt. Sicherer wäre die folgende Möglichkeit: > > memcpy(&werte2, &wert1, sizeof(werte1)); rollen sich mir die Fußnägel auf. Das ist 1. Blödsinn und 2. ist in der "Empfehlung" auch noch ein Tippfehler. Keine besonders gute Empfehlung, m.E. (auch wenn's umsonst ist)
-
Thread
static const PROGMEM in eigenes File auslagern
= — Die Daten können static bzw. lokal sein. — Bei Daten wie vom TO gebraucht funktioniert sizeof. — Kein extra Modul .c im Makefile erforderlich. — Passt gut zu Anwendungsfall, bei dem modul.c handgeschrieben und data.def auto-generiert ist. — C-Quelle modul.c bleibt kleiner und somit
-
Thread
Python für wissenschaftliche Projekte?
viele Beispiele: [c] double *cholesky(double *A, int n) { double *L = (double*)calloc(n * n, sizeof(double)); if (L == NULL) exit(EXIT_FAILURE); for (int i = 0; i < n; i++) for (int j = 0; j < (i+1); j++) { double s = 0; for (int k = 0; k <
-
Thread
Kapazität messen, 400-700pF
TODO:: Please write your application code static int i; for (i = 0 ; i < sizeof(captures); i++) captures[i] = startCapture(); result = 0; for (i = 0 ; i < sizeof(captures); i++) result += captures[i]; result /= sizeof(captures); sprintf(buff, "%05u", (uint16_t)result); buff[sizeof(buff) - 1] = '\n'; for (i = 0; i < sizeof(buff); i++) uart_putc(buff[i]); } }[/c]
-
Thread
IR Sender ATTINY85
Eingang //Taster } void loop() { int onoff[]={4500,4500,560 .. . .. . }; int laenge = sizeof(onoff) / sizeof(onoff[0]); DDRB &= ~(1<<PB0); // Pin PB0 auf low if (digitalRead(1) == HIGH) { for(int i=0; i<laenge;i=i+2){ DDRB |= (1<<PB0); //
-
Thread
Hellsichtige Funktionsausführung?
with 0s message[i] = byte(0x00); } Serial.println("2"); for(int x = 0; x < (sizeof(message) / sizeof(message[0])); x++){ Serial.print(message[x]); Serial.print(","); } Serial.println("ended"); } [/code] Leider sehe Ich im seriellen Monitor wenn das Programm läuft
-
Thread
Ladekurve Kondensator, Analog Comparator, ACI
_t tifr; uart_putc(0xFF); while(1) { for (actual_value = 0; actual_value < sizeof(average); actual_value++) { // discharge C discharge_c(); // wait until C is discharged if (actual_value == sizeof(average) - 1) _delay_ms
actual_value] = ICR1; PORTD &= ~( 1 << PD5 ); if (actual_value == sizeof(average) - 1) { uint32_t sum = 0; for (int loop = 0; loop < sizeof(average); loop++) sum = sum + average[loop]; sum /= sizeof(average
-
Thread
STM32L433, Keil mdk und Mailversand beim RTX
MailTestQueue_Id, osWaitForever); if (outgoingMail != NULL){ memcpy(outgoingMail, &data, sizeof(MailTest_t)); osMailPut(MailTestQueue_Id,outgoingMail); return 0; } return -1; } int32_t fetchMailfromTestQueue(MailTest_t* data){ osEvent evt = osMailGet(MailTestQueue_Id,
osEventMail){ MailTest_p receivedData = (MailTest_p) evt.value.p; memcpy(data, receivedData, sizeof(MailTest_t)); osMailFree(MailTestQueue_Id, receivedData); return 0; } return -1; } [/c] Sie funktionieren - aber nicht aus der HAL-Callback. Vielen Dank im Voraus, Rahul
-
Thread
C - libpng unter Windows verwenden
will just use the constant 14 we know we have fwrite(&bfh, 1, 14, image); fwrite(&bih, 1, sizeof(bih), image); // write out pixel data, one last important this to know is the ordering is backwards // we have to go BGR as opposed to RGB int i = 0; for(unsigned y = 0; y < height; y
buffer[i * 3 + 2] / samples); char color[] = {b,g,r}; fwrite(color, 1, sizeof(color), image); i++; } fclose(image); } [/c]
-
Thread
Programm läuft nur bei angestecktem AVR ISP mkII
Rueckgabe geplant*/ } void Pause_in_Sek( unsigned short int x_sek_pause){ if( x_sek_pause < sizeof( unsigned short int ) && ( x_sek_pause >= 0) ){ #define YES 1 } else { #define NO 0 } #ifdef YES for( unsigned short int i =0; i < x_sek_pause; i ++ ){ _delay_ms(
-
Thread
Struct Arduino dynamisches Array verarbeiten
executeAction(actionOne, sizeof(actionOne) /sizeof(actionOne[0])); HTH
Ausführung. Die ist einleuchtend. Ist ja nicht PHP. :) Verfahre ich dann damit "falsch"? [code] sizeof(actionOne) / sizeof(ServoLoop) [/code] Ich habe jetzt [code] sizeof(actionOne) / sizeof(actionOne[0]) [/code] in Verwendung.
-
Thread
Feldgrösse eines Array
die gewünschte "Feldgröße"... Damit könnte die Größe eines Elements gemeint sein. Simpel: sizeof float Umständlich: sizeof array[0][0] Nur wozu?
Hmpf... [pre] (6 * 4 * sizeof(float)) [/pre]
-
Thread
Programmiergrundlagen: array=array?
natürlich optimal %p ist nicht nur optimal - sondern eher zwingend Denn manchmal ist sogar: sizeof(int*) != sizeof(char*)
Hunsbuckel schrieb im Beitrag #5367515: > Denn manchmal ist sogar: > > sizeof(int*) != sizeof(char*) Das leuchtet mir jetzt aber irgendwie nicht ein... Wenn ich ein 32-bit Adressraum habe, in diesem kann ich char sowie int ablegen - Wenn sizeof(char*) nun 2 wäre...
-
Thread
nRF24L01 interrupt am Arduino
"); Serial.print(Empfangen[0]); Serial.print(" empfangen: "); for (int i = 1; i < sizeof(Empfangen); i++) { Serial.print(Empfangen[i]); Serial.print("\t"); } Serial.println(); neueNachrichtEmpfangen = false; } if (aktuelleMillis % 1000 == 1)
1); } void AnkommendeNachricht() { Serial.println("Interrupt"); radio.read(Empfangen, sizeof(Empfangen)); neueNachrichtEmpfangen = true; // Variable setzen, dass eine neue Nachricht zur Auswertung bereit steht } [/code] Das Programm läuft ca 5 Sekunden einwandfrei und dann kommt
-
Thread
NotifyIcon verschwindet beim drüberfahren mit der Maus
0, 0, LR_DEFAULTCOLOR | LR_SHARED | LR_DEFAULTSIZE | LR_LOADFROMFILE)); nid.cbSize = sizeof(nid); nid.hIcon = ico; nid.hWnd = hWnd; //wcscpy_s(Tray.szTip, (wchar_t *)"My Application"); //Tray.uCallbackMessage = WM_LBUTTONDOWN; nid.uFlags = NIF_ICON; nid.uID = 100; /
-
Thread
lwIP TCP Timeout bei fehlerhafter Verbindung
&interval); if( ret < 0 ) { goto out; } else { int opt; int lon = sizeof(int); getsockopt(stream->sock, SOL_SOCKET, SO_ERROR, (void*)(&opt), (socklen_t*)&lon); if (opt) { goto out; } if (FD_ISSET(stream->sock, &readset)) { int rxlen = lwip_recv(
-
Thread
enum in einem struct Wieso?!
einer Kompileroption beeinflussen aber wenn Du sowas vor hast würd ich ein compile time assert auf sizeof(sTime) dahinter schreiben so daß es beim Kompilieren sofort kracht wenn jemand den falschen Compiler oder falsche Optionen benutzt.
-
Thread
STM32F103: Problem mit ChanFat und SD karte
= f_mount(&FatFs, "", 0); fr = f_open(&Fil,"test.txt",FA_WRITE); fr = f_write(&Fil,buf,sizeof(buf),&res); fr = f_close(&Fil); [/c] f_mount wird zwar mit OK bestätigt aber danach steht nichts in FatFs drin. Nur Nullen. f_open erzeugt Fehlermeldung FR_NOT_READY".
-
Thread
64 Stall- Laternen mit dimmbarer LED ansteuern
pwm_values[64],i; dword pwm_tmp,pwm_val; dword pwm_vals[10]; pwm_setup() { memset(pwm_vals,0,sizeof(pwm_vals)); for(i=63;pwm_tmp=0x80000000;pwm_tmp;pwm_tmp>>=1,i--) { if(pwm_values[i]&0x80) pwm_vals[7]|=pwm_tmp; if(pwm_values[i]&0x40) pwm_vals[6]|=pwm_tmp; if(pwm_values[i]&0x20
-
Thread
Struct-Typ erkennen
{ Fixedstruct_t Fixed; Piggyback_t Piggyback; } Genericunion_t; //static_assert( sizeof(Fixedstruct_t) == sizeof(Piggyback_t) ); //static_assert( sizeof(Fixedstruct_t) == sizeof(Genericunion_t) ); enum { magic0 = INT_MIN, magic1 = 0xFF, magic2 = 0xFF, magic3 =
magic3 ) return 1; else return 0; } int main(void) { assert( sizeof(Fixedstruct_t) >= sizeof(Piggyback_t) ); assert( sizeof(Fixedstruct_t) == sizeof(Genericunion_t) ); uint8_t somethingToPointTo; Payload_t Pl; Fixedstruct_t A = {.a = &somethingToPointTo
-
Thread
C: try this, then this, then this, then this, then this.
int foo(int prm, char c) { char chars[] = { c, '@', '#', 'A', '0' }; for(int i = 0; i < sizeof(chars); i++) { if(tryToDoWhatIWantYouToDo(chars[i]) == EXIT_SUCCESS) { continueWithTheStuffYouStarted(prm); return i ? fail() : EXIT_SUCCESS; } return fail
-
Thread
Ansi-C 4d Array
memset( relais , 255, (sizeof(Switchpoint)*NOF_SWITCHPOINTS)*NOF_RELAIS );
einträge mit 0xff for( i = 0; i< NOF_SWITCHPOINTS ; i++ ){ memset( &relais[0][i].on , 0xff , sizeof( Timestamp )) ; memset( &relais[1][i].on , 0xff , sizeof( Timestamp )) ; } // alle OFF einträge mit 0 for( i = 0; i< NOF_SWITCHPOINTS ; i++ ){ memset( &relais[0][i].off , 0 , sizeof(