-
Thread
Arduino nrf24l01 Daten senden UND empfangen
RF24_250KBPS); radio.setPALevel(RF24_PA_MAX); radio.setChannel(50); radio.setPayloadSize(sizeof(data)); radio.setRetries(15,10); radio.setCRCLength(RF24_CRC_8); radio.openWritingPipe(TXADDRESS); if (radio.write(&data,sizeof(data))) { digitalWrite(LED_GLB,1); data.nr
-
Thread
sizeof in C und C++
sizeof(char) ist per Definition = 1 egal wie viel bit es hat.
von der Größe eines char zurück. Somit ist sizeof(char) *immer* 1, denn char ist nunmal genau 1 char groß. Mit CHAR_BIT * sizeof(X) erhält man die genaue Größe eines jeden Datentyps in bits.
-
Thread
Viele logische Verknüpfungen.
19200, 28800, 38400, 57600, 115200, 230400 }; return std::any_of (baudrates, baudrates + (sizeof(baudrates) / sizeof (baudrates [0])), [&](uint32_t x) { return x == baud; }); } // Variante 2 bool isbaud2 (uint32_t baud) { static const std::array<uint32_t,13> baudrates {{ 300,
4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200, 230400}; static const size_t length = sizeof (baudrates) / sizeof (baudrates [0]); for (size_t i = 0; i < length; ++i) if (baudrates [i] == baud) return true; return false; }[/c] Solche Konstrukte nach Schema F können Compiler
-
Thread
while( ) >>> mit Bedingungen
stdio.h> int main(){ int gesucht = 2; int list[] = {1,2,3}; int*const list_end = list + sizeof(list) / sizeof(*list); int* it; for( it=list; it<list_end; it++ ) if( *it == gesucht ) break; if( it == list_end ){ printf("Not found\n"); }else{ printf("Found
-
Thread
MSP430G2553 als Schnittstelle zwischen MODBUS und I2C
der zu sendenden Bytes. Und dann sieht der Aufruf von "send" so aus: [c] send(BATT_VOLTAGE, sizeof (BATT_VOLTAGE)); [/c] Nein, der sizeof-Operator muss beim Aufruf der Funktion angewandt werden, /in/ der Funktion selbst funktioniert das nicht, da liefert sizeof nicht die Größe des (vermeintlich
sendenden Bytes. > > Und dann sieht der Aufruf von "send" so aus: > > [c] > send(BATT_VOLTAGE, sizeof (BATT_VOLTAGE)); > [/c] > > Nein, der sizeof-Operator muss beim Aufruf der Funktion angewandt > werden, /in/ der Funktion selbst funktioniert das nicht, da liefert > sizeof nicht die Größe
-
Thread
Custom Linkerscript: eigene Text-Section
Gegensatz zu einem separaten Bootloader. Weiters brauchst du nur die länge der Sequenz, die hier per sizeof zur Verfügung steht. Auch wenn's ein paar Byte mehr kostet, kann diese Size in eine globale Variable geschrieben werden, die der Bootloader lesen kann. Geht natürlich auch über Symbole, die du
-
Thread
Arduino 2560 Serial Signale invertieren
begin(9600, SERIAL_8N2); } void loop() { while(true){ Serial1.write(Buffer,sizeof(btest)); delay(500); Serial.println(""); while(Serial2.available()){ Serial.print(Serial2.read(),HEX); } } } [/c] Beste Grüße Alex
-
Thread
Send response (Action *Var)
MY_ACTION_TYPE_INVALID = MY_ACTION_TYPE_COUNT }; #undef X void handleAction(Action *a) { memset( a, 0, sizeof(*a) ); const char* location = (const char*)parserBuffer; enum my_action_type action; for( action = 0; action < MY_ACTION_TYPE_COUNT; action++ ) if( !strcmp( my_action_info[action]
action ein char oder uint8_t array, könnte man mit "strncpy((char*)a->action,(char*)parserBuffer,sizeof(a->action));" mehrere Zeichen in dieses Array kopieren. Ich glaube aber nicht, dass dies sinnvoll ist, da schlussendlich ja nur die Auswertung woanders stattfindet, oder brauchst du wirklich diese
-
Thread
User Sections GCC
} SECTIONS { ... .text : { ... } > text .data : AT (ADDR (.text) + SIZEOF (.text)) { PROVIDE (__data_start = .) ; ... PROVIDE (__data_end = .) ; } > data .bss : AT (ADDR (.bss)) { PROVIDE (__bss_start = .) ; *(.bss) *(.bss
} > data __data_load_start = LOADADDR(.data); __data_load_end = __data_load_start + SIZEOF(.data); /* Global data not cleared after reset. */ .noinit : { PROVIDE (__noinit_start = .) ; *(.noinit*) PROVIDE (__noinit_end = .) ; _end = . ; PROVIDE (__
-
Thread
Arduino: NRF24L01 2.4Ghz maniacbug Library
ACK kam? Da steht nur was von write, writeStart, WriteBlocking usw. also radio.write(&data, sizeof(data),0); Und nun? Warten? Was abfragen? Hat da mal jemand Code? PS: Ab und zu hängt sich der Empfänger auf, behauptet dass Datenpakete da wären, obwohl keine mehr kommen. Seltsam, da
RF24_CRC_8); radio.openWritingPipe(TXADDRESS); radio.powerUp(); if (radio.write(&data,sizeof(data))) { digitalWrite(LED_GLB,1); data.nr++; } else { digitalWrite(LED_ROT,1); data.errors++; } radio.powerDown(); [/c]
-
Thread
Verständnisfrage zu diesem Microcontroller
das macht es verständlich, dass ein '''char''' == '''int''' == 16 Bit ist. Mit allen Konsequenzen: sizeof(char) == 1 (per Definition) und sizeof(long) == 2! Bytes (Oktetts) sind schlicht nicht adressierbar. Das gab es IMHO auch beim Z800, den 16-Bit-Nachfolger des Z80. Man hatte damals beschlossen, die
-
Thread
in_addr_t - Datentypen Umwandlung Sinnfrage
: die kleinste Speichereinheit ist dort 16 bit. Ein char hat also 16 Bit. Ein long hat 32 Bit. sizeof(char) -> 1 sizeof(long) -> 2 Soviel dazu, dass es immer 8-Bit Zugriff geben muss.
-
Thread
ESP8266 und WS2812-Streifen
rufe ich wie folgt auf: [c] uint8_t ledBuf[180]; //... noInterrupts(); ws2812_write( ledBuf, sizeof(ledBuf) ); interrupts(); [/c] Das funktioniert meistens. Leider kommen treten sporadisch LED-Glitches auf, bei denen Farbwerte teilweise in die Farbe der nächsten LED rutschen (also blau 1->grün2
einfach einen statischen Buffer mit 100Hz sende, Hardcore-Test mit: [c] memset(ledBuf, 0xAA, sizeof(ledBuf)); noInterrupts(); ws2812_write( ledBuf, sizeof(ledBuf) ); interrupts(); memset(ledBuf, 0x55, sizeof(ledBuf)); noInterrupts(); ws2812_write( ledBuf, sizeof(ledBuf) ); interrupts(); [/c]
-
Thread
PROGMEM Array an Funktion übergeben
_t step = 0; uint8_t sizePattern = sizeof(pattern)/sizeof(pattern[0]); ledValue1 = pgm_read_byte(patter[step]); step++; } [/c]
kann ich mit sizeof(pattern) nicht die Größe auslesen. > Ergebnis ist immer 1. Siehe oben.
-
Thread
Suffix für uint8_t
Array-Größe mal nicht 256 sein sollte. Wenn schon, denn schon: [c]Array[(ZaehlVariable + 20) % (sizeof(Array) / sizeof(*Array))];[/c]
Grössenangaben, also z.B. für einen Index eines Arrays, würde ich jedoch size_t empfehlen. Da der Operator sizeof auf jedes Objekt angewandt werden kann und sein Ergebnis als size_t liefert, kann kein Objekt im Speicher, auch kein Array, mehr als SIZE_MAX Bytes belegen.
-
Thread
Frage zur float Darstellung - Prozessor unbekannt
, 0.001, 1.000, 1.998, 1.999, 2.000, 3, 4, 5, 10, 33 }; for (int i = 0; i < sizeof numbers / sizeof *numbers; ++i) { double n = numbers[i]; printf("%f:", n); for (int j = 0; j < 8; ++j) { printf(" %.02X", ((unsigned char*)&n)[
-
Thread
Was tun wenn der Stack überschrieben wird?
anderen > Situationen auch schon funktionierte. > ... >Die übergebene Länge, ermittelt mit sizeof > ist 132... Autsch. Ich befürchte es gibt konkurrierende Definitionen der > Struktur die ich kopieren möchtes (fd_set), einmal vom Netzwerkstack und > einmal vom Betriebssystem. > Oder
Inhalt übergeben wurde. So wäre dann der Stack das Ziel und damit kaputt sobald die Kopierlänge > sizeof(void*).
-
Thread
WordClock mit WS2812
Mit dem Projekt "WordClock mit WS2812" kann sowohl die klassische 11x10 WordClock als auch die neue minutengenaue 16x18 WordClock24h realisiert werden - mit ein und derselben Hard- sowie Software. Link zum Artikel: [[WordClock_mit_WS2812]] Lauffähig ist die Software auf den Nucleo-Boards STM32F401RE und STM32F411RE für 11 EUR und (brandneu!) jetzt auch auf dem 4 EUR günstigen STM32F103C8T6 Mini Development Board. Auch diese Variante wird in den nächsten Tagen zum Download verfügbar sein und im Artikel beschrieben werden. Bereits implementierte Features der Software: - Lauffähig auf STM32F401
-
Thread
STM32: Drama mit "Hard Fault Error"
gefunden wo die Ursache liegt. Sie liegt im Aufrufer tls_74HCT595_SendData((uint8_t*)&Work, sizeof(Work)); Tauscht man das gegen tls_74HCT595_SendData((uint8_t*)&Time, sizeof(Time)); aus, läuft sie einwandfrei durch, auch auf dem Logic Analyzer. Der Unterschied zwischen Work und Time
-
Thread
String Array verarbeiten / Arduino
D3 { 0, 0 , "free" }, //D4 ... { 0, 0 , "free" } //D80 }; const size_t iomodus_count = sizeof(iomodus)/sizeof(*iomodus); ... //all Ports for (int i = 0; i<iomodus_count; i++){ //present(uint8_t childSensorId, uint8_t sensorType, const char *description, bool enableAck) present(
-
Thread
string tutorial für STM32 ?
leider nichts. Und wenn das Zielfeld eine feste Länge hat, dann besser: [c]snprintf(parameter[150],sizeof(parameter[150]),"PD15");[/c] Außerdem will printf, das bei der Ausgabe, bei "%s" einen String, d.h. mit hex 0 am Ende. Kommandos über 11 Zeichen Länge führen dann zu lustigen Fehlern.
-
Thread
C Effekte Algorithmen gesucht
} else printf("o"); } printf("\n"); } if(++(*pos)>= sizeof(pattern0)/3) {*pos = 0;} } show_pattern(ledsHsv, &pos, patter0); [/c] Hab es so gelöst, soweit okay?
-
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
[c] dynamische Speicherverwaltung mit malloc
freigeben?? D.h. [c] size+=more; free(value); value = malloc(size * sizeof(int)); [/c] Temp muss auch noch freigeben werden, aber da ist die Sachlage klar. Vielen Dank.
du willst ein Speicherleck. Am2302 schrieb im Beitrag #4397649: > value = (int *)malloc(size*sizeof(int)); Den Cast nach int * sollte man auch weglassen, der ist unnötig. Ausserdem bevorzuge ich folgende Schreibweise: [c]int * Var = malloc(Size * sizeof(*Var));[/c] So kann sich der Datentyp
-
Thread
Eingang Zeit versetzt einschalten
zeit%1000; int minuten=sekunden/60; sekunden=sekunden%60; if (endzeit) snprintf(buf,sizeof(buf),"%2d:%02d,%03d",minuten,sekunden,tausendstel); else snprintf(buf,sizeof(buf),"%2d:%02d",minuten,sekunden); lcd.setCursor(6,0); lcd.print(buf); } void loop() { while (digitalRead
-
Thread
Präprozessor(?): Zeichen in Zeichenkette ersetzen
> struct IntegerSequence { using value_type = T; static constexpr size_t size () { return sizeof... (I); } }; namespace Helper { template <typename T, typename S1, typename S2> struct ConcatSequence; template <typename T, T... S1, T... S2> struct ConcatSequence<T, IntegerSequence<T, S1...>, IntegerSequence<T, S2...>> { using type = IntegerSequence<T, S1..., (sizeof...(S1) + S2)...>; }; template <typename T, T N, bool isZero, bool isOne> struct GenSeqI; } template <typename T, T N> using GenSeq = typename Helper::GenSeqI<T, N, N == 0, N == 1>::type
-
Thread
AVR-GCC selbst bauen - Unter Linux für Windows?
Lapsus in csmith, oder eine falsche Konfiguration von csmith. Ist doch wohl das mindeste, dass sizeof(int) eingestellt werden kann? Funktioniert LTO mit Leerzeichen im Installationspfad(*) und ähnliche Scherze? Prefix würd ich immer ohne solche Kapriolen wählen. Die Installierte Toolchain lässt
Lapsus in csmith, oder eine falsche > Konfiguration von csmith. Ist doch wohl das mindeste, dass sizeof(int) > eingestellt werden kann? Keine Ahnung, fiel bei mir auch direkt unter "schlechter Stil", aber ist ja nicht wirklich von belang Johann L. schrieb im Beitrag #4395615: > Funktioniert
-
Thread
Problem bei Funkübertragung: Arduino mit nRF24L01
0xE8E8F0F0E1LL? Ist dies immer so oder kann das bei mir anders sein 2) radio.write( joystick, sizeof(joystick) ); Damit bestimme ich was übertragen werden soll? Welche Übergabewerte besitzt diese Funktion? 3) radio.openWritingPipe(pipe); radio.openReadingPipe(1,pipe); Hiermit
-
Thread
Vereinfachung einer "C" Funktion
128, 256}; //parameter ausserhalb des zulaessigen Wertebereichs Kurve--; if ( Kurve > sizeof(dummy) ) { return 0; } return dummy[ Kurve ]; } [/c]
-
Thread
Fragen zu ESP8266
queuesize=200; queue.front=0; queue.count=0; queue.objs=(qobject_t*) malloc(queuesize * sizeof(qobject_t)); queue.size=queuesize; // enable queue for (i=0;i<queue.size;i++) queue.objs[i]=0; os_memset( irmp_data,0,sizeof irmp_data); irmp_init(); gpioinit(); lua_pushinteger
-
Thread
Audio MSP430
1355, 1415, 1477, 1539, 1601, 1664, 1728, 1791, 1855, 1919, 1984}; int laenge_melody = (sizeof(melody) / sizeof(int)); int laenge_array = (sizeof(sin_vector) / sizeof(int)); //------------- Interrupt --------------------- #pragma vector = TIMER0_A0_VECTOR __interrupt void TIMERA0(void) { DAC12_0DAT = sin_vector[z]; if(z<(sizeof(sin_vector) / sizeof(int))) { z++; } else { z=0; dieseNote++; setup(); } TACTL &= ~TAIFG; } //-----------------------------
-
Thread
Empfangene Daten der UART vergleichen
den Buffer und somit // den String aufbauen { if( receivedCnt < sizeof(receivedString) ) { receivedString[receivedCnt++] = c; } } } // end if( ukbhit0() ) } // end while } [/c]
-
Thread
Hinweis: C++ Core Guidelines
> >[c] char ch = 7; void* pv = &ch; int* pi = pv; // not C++ *pi = 999; // overwrite sizeof(int) bytes near &ch [/c] >Enforcement > >Use a C++ compiler. Ich wusste gar nicht das C++ Code generiert? Meines Wissens macht das der Compiler, und da kommts vor allem darauf an welchen ich
>>char ch = 7; > void* pv = &ch; > int* pi = pv; // not C++ > *pi = 999; // overwrite sizeof(int) bytes near &ch >>Enforcement >> >>Use a C++ compiler. > > Ich wusste gar nicht das C++ Code generiert? Meines Wissens macht das > der Compiler, Steht doch auch so da >>Use a C++ *