-
Thread
welche FP-LIB für hochaufgelöstes Rechnen beim 16 BIT uc
"%3d %.54f \n", i, d); printf("%3d %.65Lf \n", i, ld); quadmath_snprintf(buf, sizeof buf, "%.114Qf", f128); printf("%3d %s \n", i, buf); if (f128 >= f128end) break; f += fi; fi /= 2.0; d += di; di /= 2.0; ld
-
Bild
Terminal-Fenster mit C-Code und Prozessliste
to run on (0-indexed) CPU_SET(core_id, &cpuset); pid_t pid = getpid(); if (sched_setaffinity(pid, sizeof(cpu_set_t), &cpuset) == -1) { perror("sched_setaffinity"); exit(EXIT_FAILURE); } setup(); // Your program logic here printf("Running on core %d\n", core_id); while (1) { loop(); sleep(1); } return
-
Thread
Raspi real time pin toggle
pid_t pid = getpid(); // Get the PID of the current process if (sched_setaffinity(pid, sizeof(cpu_set_t), &cpuset) == -1) { perror("sched_setaffinity"); exit(EXIT_FAILURE); } // Your program logic here while (1) { printf("Running on core %d\n", core_id
-
Thread
Arduino analog channel index?
setup() { Serial.begin(115200); } void loop() { delay(1000); for (int n = 0; n < sizeof(adcChannels); n++) { Serial.println(adcChannels[n]); } Serial.println("========"); } [/c]
-
Thread
ESP32 HTTP Client: Fehlercode -1 nach einiger Zeit?
/* Datensicherung im EEPROM rolierend */ void SafeToEE(tables_t* data) { const int len = sizeof(*data); /* Erzeuge eine zufällige Blockadresse */ const int max_blocks = EESIZE / len; int newBlock = random(0, max_blocks); EE_WritePtr = newBlock * len; // Zieladresse im EEPROM
const uint32_t blknrOffs = (uintptr_t) & (data->blknr) - (uintptr_t) & (*data); const int len = sizeof(*data); /* EE durcchsuchen nach gültigem valid */ int16_t marke, id; while (EE_AdrPtr < (EESIZE - len)) { myMem.get(EE_AdrPtr + validOffs, marke); // Valid Marke auslesen als int16
-
Thread
DMX - kein Empfang
UCSZ10); UCSR1B = (1<<RXEN1)|(1<<RXCIE1); gDmxState= IDLE; uint16_t i; for (i=0; i<sizeof(DmxRxField); i++) { DmxRxField[i]= 0; } DmxAddress = 1; } ISR (USART1_RX_vect) { uint8_t USARTstate= UCSR1A; //get state uint8_t DmxByte= (UDR1); //
_t *DmxPnt; DmxPnt= gDmxPnt; *DmxPnt= DmxByte; if (++DmxPnt >= (DmxRxField +sizeof(DmxRxField))) //all ch received? { gDmxState= IDLE; IndFlags |= (1<<VALID_DMX); } else gDmxPnt= DmxPnt; //PORTD &= ~( 1 << PD7 ); } //PORTD
-
Thread
Allgemeine Fragen zu Eigenbau-libc
heute 17:36 ist fehlerhaft, funktioniert nicht korrekt, wenn num kein ganzzahlig Vielfaches von sizeof(unsigned long) ist. Und auf manchen CPUs kracht es oder die Daten werden falsch kopiert (auch wenn num ein ganzzahlig Vielfaches von sizeof(unsigned long) ist). Undefined Behavior eben. Außerdem scheint
Schau nochmal in Ruhe drauf. Es gibt übrigens auch noch andere BS als Linux, und nicht überall ist sizeof(long) == 8.
-
Thread
Arduino UIPEthernet: client.read() geht nicht in String
> String buf(cbuf); cbuf ist nicht nullterminiert. Versuch mal [c] String buf(cbuf,min(cnt,sizeof(cbuf))); [/c] LG, Sebastian
schrieb im Beitrag #7674034: > cbuf ist nicht nullterminiert. Versuch malString > buf(cbuf,min(cnt,sizeof(cbuf))); > LG, Sebastian Moin. Danke für den Tip, hat aber leider auch nichts gebracht. Nach endlosen Versuchen funzt nun dieser Code stabil. Es geht darum, aus dem HTTP-Request des Browsers einen
-
Thread
MCP23017 und UDN2981A
Bit5, U2_Bit6, U2_Bit7 }; uint8_t HC595_Data[Last_SR] = { 0 }; update_SPI_Chips(HC595_Data, sizeof(HC595_Data)); void update_SPI_Chips(uint8_t *pdata, uint8_t size) { for (uint8_t i = 0; i < size; i++) { SPDR = pdata[i]; WAIT_SPI_SEND_COMPLETE } UPDATE_STROBE_SPI }
-
Thread
Fehlerhafte Kommunikation über LTC4332
false; SPI.attachInterrupt(); } ISR(SPI_STC_vect) { byte c = SPDR; if (pos < (sizeof (buf) - 1)) buf [pos++] = c; if (c == '\n') process_it = true; } void loop (void) { if(process_it) { buf [pos] = 0; Serial.println(buf); pos = 0; process_it
-
Thread
ESP8266 SPIFFS lazy delete möglich
file_idx], "w"); if (!f) { continue; } f.write(reinterpret_cast<uint8_t*>(&data), sizeof(Measurement)); f.close(); } } [/c] obwohl jede Datei NUM_MEASUREMENTS_IN_RAM * sizeof(Measurement) bytes groß ist schreibe ich also nur die ersten 16 Bytes - das geht deutlich schneller
-
Thread
Effizienter Running Median
median_t sorted[NN]; timebased[idx++] = neu; idx %= NN; memcpy(sorted, timebased, sizeof(sorted)); qsort(sorted, NN, sizeof(median_t), cmpfunc); return (sorted[(NN - 1) / 2]); } [/c]
-
Thread
ESPNOW senden mit ESP12 geht schief, warum ?
Helmut H. schrieb im Beitrag #7664806: > esp_now_send(broadcastAddress, (uint8_t *)&Puffer, sizeof(Puffer)); sizeof() gibt die Größe des gesamten Puffers zurück. Ist denn die Nachricht auch wirklich exakt so lang, oder ist sie kürzer, so daß dahinter Mumpitz gesendet wird? Für Textnachrichten
Anscheinend sendest du zu viel, da kann sich der Empfänger dran verschlucken. memcpy(&Puffer, &myData, sizeof(myData)); esp_now_send(broadcastAddress, (uint8_t *)&Puffer, sizeof(Puffer)); Müsste es in der zweiten Zeile nicht sizeof(myData) heißen?
-
Thread
Problem mit scanf und zu kurzem Befehl
hängt sich meine Anwendung auf. char commandBuffer[COMMAND_LENGTH]; memset(commandBuffer, 0, sizeof(commandBuffer)); if (rx_counter0) { scanf("%8s", commandBuffer); } Wie kannn ich möglichst einfach die scanf-abändern, damit das Gerät nicht in einer Dauerschleife bleibt? Anscheind
-
Thread
ESP 32: Smarthome Beet über MQTT: FAST fertig
mit dem Schalter sein, das überprüfe ich am WE [c] void setupPins() { for (int i = 0; i < sizeof(ausgangspins) / sizeof(ausgangspins[0]); i++) { pinMode(ausgangspins[i], OUTPUT); digitalWrite(ausgangspins[i], LOW); } pinMode(waterSensorPin, INPUT); // Eingangspin für Wasserstandssensor
Serial.println("-- Subscribe to properties"); client.setCallback(callback); for (int i = 0; i < sizeof(properties) / sizeof(properties[0]); i++) { if (client.connected()) { String topic = String(MQTT_BASE_TOPIC) + "/" + String(properties[i]); if (client.subscribe(topic.c_str())) {
-
Thread
STM32F030C6T6 SPI DMA Alignment Problem
Nachrichten alle 12 Byte lang sind, legt man besser einen Puffer mit genau dieser Länge an und nimmt sizeof() für die Längenangaben. Oder zumindest eine Konstante oder ein #define für die "Standard"-Länge.
-
Thread
DCC Singal auslesen
((Befehls_Byte & B00001111) << 1) + ((Befehls_Byte & 0x10) >> 4) - 3; for (int a = 0; a < sizeof(arry); a++) { if(arry[a] == speed) { direction = 1; break; } else { direction = 0; } } if (direction == 0) { arry[
-
Thread
String funken, die Tausendste.
Serial.println(Ausgabe); esp_now_send(broadcastAddress, (uint8_t *)&Ausgabe, sizeof(Ausgabe)); delay(1000); } } } } } //*************************************** void Auswertung() { Strom = analogRead(A0); Ampere = ((Strom.toInt()
-
Thread
C++ forward declaraion
sind?! std::optional<> enthält aber schon ein Bool, ist also mindestens 1 Byte groß. Dann wäre: sizeof(Node1)=sizeof(Node2)+1 und sizeof(Node2)=sizeof(Node1)+1 Das ist somit rekursiv und unendlich.
sind?! std::optional enthält aber schon ein Bool, ist also mindestens 1 Byte groß. Dann wäre: sizeof(Node1)=sizeof(Node2)+1 und sizeof(Node2)=sizeof(Node1)+1 Das ist somit rekursiv und unendlich.
-
Thread
ESP8266 sendet Daten nach Initialisierung
packetSize = UDP.parsePacket(); if (packetSize > 0) { memset(packetBuffer, 0, sizeof(packetBuffer)); inCome = UDP.read(packetBuffer, sizeof(packetBuffer)); Serial.write(packetBuffer, inCome); } while (Serial.available() > 0) { processIncomingByte
-
Thread
Probleme mit nRF24L01+ in kombination mit RC5 RF522 (Arduino UNO)
int receivedData; // Variable zur Speicherung der empfangenen Daten radio.read(&receivedData, sizeof(receivedData)); // Liest die empfangenen Daten Serial.print("Empfangene Daten: "); Serial.println(receivedData); // Gibt die empfangenen Daten aus } } [/c] Code zum Senden [c] #
sendData() { for(int i = 0; i<100; i++){ // Daten senden bool success = radio.write(&i, sizeof(i)); if (success) { Serial.print("Daten gesendet: "); Serial.println(i); // Wert der gesendeten Daten ausgeben } else { Serial.println("Fehler beim Senden der Daten.");
-
Bild
Screenshot eines Code-Editors mit C-Quelltext und Assembly
shc-2023 #include <stdio.h> #include <limits.h> #define INDEX_COUNT(x) (sizeof(x)/sizeof(x[0])) char buffer[] = {1,2,3}; int sucheGroessten() int ret = INT_MIN; for (int i = 0; i < INDEX_COUNT(buffer); ++i) { if (ret >= buffer[i]) continue; ret = buffer[i]; } return ret; main
-
Thread
Rückgabewerte von va_list auf einem Arduino Mega2560
}) void RangeCheck_MOD (uint16_t ZeilenNr, uint8_t MOD_ix) { char jou[30]; snprintf(jou,sizeof(jou),P("MOD RangeErr in %d: %d"),ZeilenNr,MOD_ix); println(jou); } [/c] Verwende ich stattdessen [c] snprintf_P(jou,sizeof(jou),"MOD RangeErr in %d: %d",ZeilenNr,MOD_ix); [/c] wird mehr RAM verbraucht. Logisch. Mache ich [c] snprintf_P(jou,sizeof(jou),PSTR("MOD RangeErr in %d: %d"),ZeilenNr,MOD_ix); [/c] dann ist die RAM-Nutzung auch wie bei meiner Lösung. Dann bleibt es Geschmacksache oder eine Stilfrage.
-
Thread
volatile -- Anwendung auf Arrays
]; txr = (txr + 1) % sizeof(txbuf); wakeup("uart_tx"); } else UCSR0B &= ~B(UDRIE0); } u8 uart_getc(void) { sleep_while (rxr == rxw); // sleep while rxbuf empty u8 c = rxbuf[rxr]; barrier("read rxbuf before changing rxr"); rxr = (rxr + 1) % sizeof(rxbuf); return c; } void uart_putc(u8 c) { u8 w = (txw + 1) % sizeof(txbuf); sleep_while (w == txr); // sleep while txbuf full txbuf[txw] = c; barrier("write txbuf
-
Thread
exFAT mit "-t msdos" mounten?
char unix[32]; unsigned u1; for (u1 = 0; *vfat; u1++, vfat++) { if (u1 >= sizeof unix - 1) { errno = ENAMETOOLONG; return NULL; } if (*vfat == '\0') { unix[u1] = '\0'; break; } if (*vfat <= ' ' || *vfat >= 127
-
Thread
Grow R503 Fingerprintsensor Imagedaten auslesen
lineBuffer[2*x] = val1; lineBuffer[2*x + 1] = val2; } imageFile.write(lineBuffer, sizeof(lineBuffer)); } [/c] Bleibt noch eine Unschärfe mit der Farbpalette, aber das finde ich auch noch. hier ist noch der Teil zum Image lesen, da ist noch Debugzeug drin das raus muss. Und die
-
Thread
C Frage zu Array Initialisierung mit Festtext
bleibt ja nur eine Schleife bei der > Initialsierung, oder? Sollte mit einem memset(&test, 0, sizeof(test)) machbar sein. Allerdings würde ich dir perspektivisch empfehlen, die C++-Notationen zu nutzen, anstatt das gute alte Herumgepointere. Arduino mag zwar eingeschränkt sein, was die Container
-
Thread
Diverse Variablen remanent machen
Speicherroutine aufrufen indem du ihr die Adresse der Struktur und die Länge übergibst (mit dem sizeof-Operator). Natürlich prüft man die Länge nach, vor dem Schreiben. Dann kümmert sich der compiler darum, wo was steht. Eventuell habe ich dein Problem aber nicht verstanden, das ist durchaus drin
größe sizeof(struktur) ab der Adresse der Struktur. Man kann z.B. Dinge wie memcpy oder memset für eine Struktur verwenden. Oder sie auch einfach ins Flash schreiben (mit den Flash-Spezialfunktionen natürlich)
