-
Thread
unterschiedliche Datentyp über einer Variable auslesen
main() { int value; char Command[20]; while(1) { fgets(Command, sizeof(Command), stdin); if (0 == strcmp(Command, "pain\n")) { valeur.pain = VALEUR_PAIN; value = valeur.pain; } else if (0 == strcmp
{ struct tval tval; char Command[20]; while(1) { fgets(Command, sizeof(Command), stdin); if (0 == strcmp(Command, "pain\n")) { tval.typ = TVAL_FLOAT; tval.val.f = VALEUR_PAIN; } else if (0 == strcmp(Command
-
Thread
STM32 NUCLEOF411RE USART1 mit HC-05 verbinden
HAL_Delay(100); > } sollte sein: [c] while (1) { HAL_UART_Transmit(&huart1, bufftx, sizeof[bufftx], 100); HAL_Delay(100); } [/c] Alternativ kannst du auch den bufftx lassen wie er ist und statt sizeof() strlen() nutzen.
im Beitrag #5509042: > sollte sein: > while (1) > { > HAL_UART_Transmit(&huart1, bufftx, sizeof[bufftx], 100); > HAL_Delay(100); > } > > Alternativ kannst du auch den bufftx lassen wie er ist und statt > sizeof() strlen() nutzen. Sorry, die Hitze... natürlich immer strlen()!!!
-
Thread
string mit getchar auslesen
char txt[1000]; char *p=txt; while(p<txt + sizeof txt) statt while(1) *p++=c; statt direkter Ausgabe *p=0; am Ende Und wundern, warum es Abstürzt, wenn man nicht früh genug beendet.
strcpy(in_command, in_buff); // strcpy(in_buff,""); memset(&in_buff[0], 0, sizeof(in_buff)); chr_cnt = 0; } else // Falls kein Enter muss der Text gespeichert werden { if(isprint(c))
-
Thread
C -> Struktur initalisieren
)/sizeof(*table), [/c] Müsste das nicht so lauten? [c] .table_length = sizeof(table)/sizeof(table[0]), [/c]
Jan, C Grundlagen, ist das selben. Jan H. schrieb im Beitrag #5504603: >> .table_length = sizeof(table)/sizeof(*table), > Müsste das nicht so lauten?.table_length = > sizeof(table)/sizeof(table[0]),
-
Thread
Programmlogik bei Einsatz von zwei PCF8574
einer Schleifen im Loop-Teil meines Programms ab. Etwa so: [c] void loop () { for (int i=0; i<sizeof(addresses); i++) { int addr = addresses[i]; -- Rest wie bei normalem Single-Betrieb -- } } [/c] Und genau das ist es, was mich stört. Gibt es keine elegantere Lösung beide PCF8574
-
Thread
Struct Hilfe
|= 0x0002; /* usw */ return tmp; } CFG decode(uint16_t x) { CFG x; memset(&x, 0, sizeof(CFG)); if(uint16_t & 0x0001) x.ENABLE = 1; if(uint16_t & 0x0002) x.RESET = 1; /* usw */ return x; } [/c] Dann kannst du statt einzelnen Bits auch bool benutzen und mit "true"/"false
-
Thread
bool[8] in uint8_t umwandeln
Einsen) enthält Ganz fies kann das das so testen: [c] bool arr[8] =...; if(!memchr(arr, true, sizeof(arr)) { // nur false (Nullen) in arr[] } if(!memchr(arr, false, sizeof(arr)) { // nur true (Einsen) in arr[] } [/c] memchr() benutzt intern eine Schleife die maximal sizeof(arr) pro
Beitrag #5496610: > Ganz fies kann das das so testen:bool arr[8] =...; > > if(!memchr(arr, true, sizeof(arr)) { > // nur false (Nullen) in arr[] > } > > if(!memchr(arr, false, sizeof(arr)) { > // nur true (Einsen) in arr[] > } Und im zweiten Fall fällt man dann je nach Implementierung ganz
-
Thread
ADXL345 und ESP8266: Echtzeitdatenergassung mit konstanter Abtastrate und Interrupts
liegen, dass ich die Werte über ein Array mittels UDP übertrage: [c] Udp.write((byte *) &accels,sizeof(accels)); [/c] Witzigerweise reichen diese Impulsfolgen aus, um die korrekte Frequenzen zu berechnen. Zu Erregung habe ich den Sensor mit einer vorgegebenen Frequenz beaufschlagt. Nun meine Frage
4]; //The Z value is stored in values[4] and values[5]. //(...) Udp.write((byte *) &accels,sizeof(accels)); [/c] Zu deinem Code. Der INT1 (DATA_READY) vom ADXL435 Sensor ist so wie ich das lese solange high, wie noch Mess-Daten im FIFO liegen. Das spricht dafür dieses Signal gar nicht als
-
Thread
dma schreibt nicht ins Datenregister
angeschaut zu haben, sieht deine Grössenberechnung: Sebastian Kaulitz schrieb im Beitrag #5487991: > sizeof(flameBits)/sizeof(flameBits[U8FLAMELED1ST.position]) auch ziemlich "strange" aus.
Beides kannst du testen, indem du in den RAM schreiben lässt. Sebastian Kaulitz schrieb: > sizeof(flameBits)/sizeof(flameBits[U8FLAMELED1ST.position]) > > Wo ist das Problem? Üblicherweise nimmt man sizeof(array)/sizeof(array[0]), wenn man die Größe eines Arrays in Bytes möchte. Per Definition
-
Thread
Enum oder #define?
DistanceModes VL53L1_DISTANCEMODE_SHORT = 1; int main () { fwrite (&VL53L1_DISTANCEMODE_SHORT, sizeof (VL53L1_DISTANCEMODE_SHORT), 1, stdout); }[/c] geht weder mit enums noch Makros. In C++ kann man es sich leicht machen und immer "const" nehmen. In C muss man zwischen enum und const abwägen und
// ... // over temperature: flash-dim all LEDs memset(leds, DIM_FLASH, sizeof leds); [/c] Das Ganze funktionierte ohne „__attribute__((packed))“ nicht wie gewünscht (nur die Hälfte aller LEDs wurde passend gesetzt), mit dagegen schon. Das widerlegt ganz eindeutig
-
Thread
Funktion mit Pointerübergabe
struct Numbers{ uint8_t data[3]; }; HAL_SPI_Transmit(&hspi1, (uint8_t*) number->data , sizeof(number->data), x_ms); Gruß
Sebastian Kaulitz schrieb im Beitrag #5479482: > HAL_SPI_Transmit(&hspi1, &number , sizeof(number), x_ms); Das &number im Aufruf ist schon falsch, da number bereits ein Pointer ist. Pointer von Pointer ist hier Murks. sizeof() wird ebenso falsch angewendet, weil das der Größe des Pointers
-
Thread
Was beachten bei Umstieg AVR --> Arduino
Safari schrieb im Beitrag #5468396: > funktioniert so etwas wie: > printf("%d", sizeof(analogRead())) > ? Nein! Da fehlt ein Parameter Wenn, dann sizeof(analogRead(A0)) So stimmt wenigstens die Syntax, in soweit, dass der Kompiler durchläuft [c] void test() { auto var = analogRead(A0); Serial.println(sizeof(var)); } [/c] Liefert auf einem UNO: 2 Wird auf dem ESP 4 liefern. *ungetestet*
-
Thread
STM32 lwip UDP Empfang fehlerhaft
PBUF_TRANSPORT,strlen((char*)data), PBUF_RAM); //ethTxBuffer_p = pbuf_alloc(PBUF_TRANSPORT, sizeof(clientMagicPacket_c), PBUF_RAM); if (ethTxBuffer_p == NULL){} memcpy(ethTxBuffer_p->payload, data, sizeof(data)); //memcpy(ethTxBuffer_p->payload, clientMagicPacket_c, sizeof(clientMagicPacket_c
+ SIZEOF_STRUCT_PBUF))); /* restore old payload pointer */ p->payload = payload; /* bail out unsuccessfully */ return 1; } [/c] Das Problem ist, wenn ein Paket versendet
-
Thread
Objekte im Flash mit PROGMEM ablegen
const Word Wort1(12,22,22) PROGMEM; main() { Word Wort1Ram; memcpy_P(&Wort1Ram, &Wort1, sizeof(Word)); } In der Wort1Ram stehen nach dem Kopieren lauter falsche Werte. Nutze ich anstatt einer Klasse eine Struktur passen die Werte. Unterstützt PROGMEM die Ablage von Objekten nicht? Oder stimmt
-
Thread
NRF24L01+ schwache Verbindung
print(inputString); // an die TTL-Schnittstelle schicken und radio.write(&inputString, sizeof(inputString)); zaehler = 0; } digitalWrite(led, LOW); // LED auslöscchen } } [/c] Code Empfänger: [c] #include <SPI.h> #include <nRF24L01.h> #include <RF24.
nRF24L01 Packete empfangen: if (radio.available()) { char text[32] = ""; radio.read(&text, sizeof(text)); Serial.print("From nRF24L01 Data: "); String newString = text; newString.trim(); newString.toUpperCase(); Serial.println(newString); if (newString.startsWith("
-
Thread
Enum zu char array mappen mit verschiedenen Datentypen
printf ("# %d:\n", i + 1); print_sensor (s++); } } #define ARRAY_SIZE(X) (sizeof (X) / sizeof (*X)) int main (void) { print_sensors (sensors, ARRAY_SIZE (sensors)); sensor_t *s = &sensors[3]; s->sensorC.name = "Sensor C.2"; s->sensorC.data[2] = 42;
sensor_list[] = { &light_sensor_1.super, &audio_sensor_1.super }; size_t sensor_count = sizeof(sensor_list)/sizeof(*sensor_list); int main(){ for(size_t i=0; i<sensor_count; i++) printf("sensor: ", sensor_list[i]); } [/c] In go ist das noch etwas schöner. Um von der Liste wieder
-
Thread
IL3829 - E-Paper Display Treiber
auf Ausgang setzen */ IL3829_D_C_DDR |= ( 1 << IL3829_D_C_bp ); il3829WriteCmd( init , sizeof( init ) / sizeof( init[0] ) ); } static inline void il3829WriteCmd( uint8_t *buff , size_t leng ) { /* * Steuerpin "D/C" muss bei einem Kommando auf "low" gezogen
-
Thread
Serielle Schnittstelle auslesen
tty file"); else { while(1) { while(!feof(pFile)) { if(fgets(buffer, sizeof(buffer), pFile) != NULL) { fprintf(pWriteToFile, "%s", buffer); } } } return 0; } } [/c]
-
Thread
8x8 Matrix Laufschrift
funktioniert das nämlich nur genau ein Mal - es sei denn Du hast irgendwo ein [c] memset(VRAM, 0xFF, sizeof(VRAM)); [/c] versteckt.
-
Thread
C++17 initialzer list aus std::array
(sizeof...(AA) == (rows - 1), "wrong number of rows"); static_assert((std::is_same_v<ItemType, typename AA::value_type> && ...)); } template<typename... VV> constexpr auto operator()(VV... rv) { static_assert(sizeof...(VV) == columns, "wrong number of values to form a complete row"); // static_assert((std::is_same_v<ItemType, VV> && ...), "use always the same type"); auto n = [&]<auto... RR>(
-
Thread
Code unleserlich schreiben um Zeilen zu sparen.
char* lastName, size_t lastNameLength, ) { const char a [] = "Hallo, "; char* res = malloc (sizeof (a) + firstNameLength + lastNameLength + 2); if (!res) return NULL; memcpy (res, a, sizeof (a)); memcpy (res+sizeof (a), firstName, firstNameLength); res [sizeof (a)+firstNameLength] =
uint8_t a1[2]; uint8_t a2[4]; uint8_t a3[8]; uint8_t a4[16]; int main(){ protocol_A(a1, sizeof(a1), spi1_put); protocol_A(a2, sizeof(a2), spi1_put); protocol_A(a3, sizeof(a3), spi2_put); protocol_A(a4, sizeof(a4), spi2_put); } [/c] so haben wir (mit LTO für C): C: 272
-
Thread
Arduino digitalWrite durch C-Code ersetzen
COHE_LINE); if(zueep) { my_i2c_eeprom_wait_ready(); my_i2c_eeprom_write_buffer( sizeof(jar_str), (char*)&MY_EEP_VAR, sizeof(MY_EEP_VAR) ); Serial.println(s_out_str); Serial.println(F("EEP_W")); } } // void con_hell_stat(boolean) [/c]
-
Thread
Struc as header einbinden - Compiler dreht durch
FX_MODE_PIXEL_MAP, FX_MODE_PIXEL_MAP, 1, 1, 0, 0 }; void eepromSave() { for (uint16_t t = 0; t < sizeof(deviceSettings); t++) EEPROM.write(CONFIG_START + t, *((char*)&deviceSettings + t)); EEPROM.commit(); } void eepromLoad() { // To make sure there are settings, and they are YOURS
deviceSettings; // Copy data to deviceSettings structure for (uint16_t t = 0; t < sizeof(deviceSettings); t++) *((char*)&deviceSettings + t) = EEPROM.read(CONFIG_START + t); // If we want to restore all our settings if (deviceSettings.resetCounter >= 5 || deviceSettings.wdtCounter
-
Thread
for-Schleife mit else Anweisung
angegebenen Initialisierer anpassen. Die wiederum kannst Du so bestimmen: #define NR_CASES (sizeof Cases / sizeof Cases[0]) Das ist vielleicht etwas weniger fehlerträchtig, wenn Du irgendwann die Anzahl der zu behandelnden Fälle verändern möchtest
-
Thread
megaAVR 0-Series
RODATA_PM_OFFSET__ : 0x4000; ... .text : { ... } > text .rodata ADDR(.text) + SIZEOF (.text) + __RODATA_PM_OFFSET__ : { *(.rodata) *(.rodata*) *(.gnu.linkonce.r*) } AT> text .data : { /* No .rodata in .data! */ ... [/pre] Falls man die crt
-
Thread
Sprache C - > long oder besser immer long long
ist automatisch und plattform-unabhängig so breit wie nötig. Wenn man sich dann noch mit dem sizeof-Operator anfreunden kann, klappt's auch mit dem sprintf.
Frank M. schrieb im Beitrag #5426441: > ptr = malloc(strlen(string) + 1); Warum nicht sizeof()
-
Thread
Neue Frage zu Union in C
auf 4 BYte aufgeblasen, damit sie ohne Problem als Array benutzt werden kann. Teste das mal mit sizeof(S_M_H_Time)
Herzlichen Dank erst mal für die schnellen Antworten! >Teste das mal mit sizeof(S_M_H_Time) Ergibt 3. Der Compiler ist XC8, da habe ich dieses "short long" von irgendwoher einfach abgeschrieben. Mit dem XC8 arbeite ich erst ein halbes Jahr. Vorher hatte ich den CC8e.
-
Thread
Structarray mit Adressproblemen in C
pBuffer) { UINT8 retVal; ..... } [/c] Wenn ich mir die größe in Bytes anschaue, ergibt sizeof(settings) = 160, was plausibel ist. Die Adresse von settings ist bei mir: 0x20003130. Ich würde jetzt erwarten, dass nun Speicher von 0x20003130 bis 0x200031D0 reserviert wird. Allerdings ist die Adresse
-
Thread
strcpy mit automatischer Längenprüfung
Ohne Aufwand ganz simpel: char d[100], *s; strncpy(d, s, sizeof(d))[sizeof(d) - 1] = '\0';
automatisch angefügt wird. [c] char d[100] = {0}; // initialisierung like memset((void*) d, 0, sizeof(d)); char *s; strncpy(d, s, sizeof(d)-1); [/c]
-
Thread
STM32: gcc 5.4.1 vs. 6.3.1 und memset
diese Zeile ist noch gefährlich: [c] for (int i=0; i<sizeof(data_xxx); i++) { data_xxx[i] = 0; [/c] weil du mit sizeof(data_xxx) nicht die Anzahl der Elemente bekommst. In diesem Fall müsste es richtig sein, aber etwas besser ist dafür ein Makro in der Art [c] #define countof(arr) (sizeof(arr) / sizeof(arr[0])) [/c] zu benutzen.