-
Thread
C Anfängerfrage (static innerhalb einer Funktion)
fill; }; struct RingBuffer* RingBuffer_New (size_t size) { struct RingBuffer* rb = malloc (sizeof (struct RingBuffer)); if (!rb) return NULL; rb->data = ...; return rb; }[/c] [c]// main.c static struct RingBuffer* globalRB; int main () { struct RingBuffer* localRB = RingBuffer_New
-
Thread
Datenlogger: Zeitstempel wie speichern?
es ein 32-Bit Wert sei? [c] #include <stdio.h> #include <time.h> int main() { printf("sizeof(time_t): %u\n", (unsigned int)sizeof(time_t)); } [/c] [code] $ ./a.out sizeof(time_t): 8 [/code] Wer heute noch Sekunden seit Epoch in einem 32-Bit-Wert zählen will, hat aus dem Y2K-Problem
-
Thread
Türklingel per ESP32 (WLAN, SIP) an Fritzbox
.. ein memset... wie folgt einfügen: [c] wifi_config_t wifi_config; memset(&wifi_config, 0, sizeof(wifi_config)); // insert this line to set memmory of struct to 0 strncpy((char*)wifi_config.sta.ssid, CONFIG_WIFI_SSID, sizeof(wifi_config.sta.ssid)); strncpy((char*)wifi_config.sta.password, CONFIG_WIFI_PASSWORD, sizeof(wifi_config.sta.password)); wifi_config.sta.bssid_set = false; [/c] Ansonsten eine tolle Idee und Umsetzung. VG Didi
-
Thread
[STM32F4] PWM mit variablem DutyCycle mit DMA generieren
*/ MX_GPIO_Init(); MX_DMA_Init(); MX_TIM3_Init(); /* USER CODE BEGIN 2 */ len = sizeof(buffer); buffer[0] = 26; buffer[1] = 26; buffer[2] = 26; buffer[3] = 26; buffer[4] = 26; buffer[5] = 26; buffer[6] = 26; buffer[7] = 26; //HAL_TIM_Base_Start(&htim3);
/ 16 Bit?) [/code] Code-Stelle 2: [code] /* USER CODE BEGIN 2 */ len = sizeof(buffer); // VERDACHT: Du erwartest len=8 ? // aber Du bekommst vermutlich len=32 ... // korrekt wäre: len = sizeof(buffer)/sizeof(buffer[0]); buffer[0] = 26; buffer[1
-
Thread
ISR Code schneller machen?
void send_Nachricht () { uint8_t data = 0; sendDaten.crc = calc_CRC16(sendDaten.asArray, (sizeof(Nachricht)-sizeof(sendDaten.crc)) ) ; MAX487_Sendemodus(); uart0_putc(STX); for (uint8_t i=0; i < sizeof(Nachricht); i++) { data = sendDaten.asArray[i]; if (data == ESC || data
void send_Nachricht () { uint8_t data = 0; sendDaten.crc = calc_CRC16(sendDaten.asArray, (sizeof(Nachricht)-sizeof(sendDaten.crc)) ) ; MAX487_Sendemodus(); uart0_putc(STX); for (uint8_t i=0; i < sizeof(Nachricht); i++) { data = sendDaten.asArray[i]; if (data == ESC || data
-
Thread
STM32F7 - DCache & DMA
x[] = {'a', 'b', 'c', 'd'}; SCB_CleanInvalidateDCache_by_Addr(reinterpret_cast<uint32_t*>(&x), sizeof(x)); cmd::Serial::transmitDma(&x[0], sizeof(x)); [/c] bzw. [c] uint8_t x[] = {'a', 'b', 'c', 'd'}; SCB_CleanDCache(); cmd::Serial::transmitDma(&x[0], sizeof(x)); [/c] Eine reine DSB
schrieb im Beitrag #5256749: > SCB_CleanInvalidateDCache_by_Addr(reinterpret_cast<uint32_t*>(&x), > sizeof(x)); > cmd::Serial::transmitDma(&x[0], sizeof(x)); So ist's sauberer: [c]SCB_CleanInvalidateDCache_by_Addr(reinterpret_cast<uint32_t*>(x), sizeof(x)); cmd::Serial::transmitDma(x, sizeof(x));[
-
Thread
ESP8226 mit Bad Request
} //Unabhängig der Antwort, alles zurücksetzten memset(_uart_string, '\0', sizeof(_uart_string)); //Inhalte vom Array löschen _uart_str_complete = false; //String komplett zurücksetzten } return rueckgabe; } [/c] Das ist die esp8266.h: [c]
uart_str_complete = true; //String komplett } //Arraylänge erreicht if (count >= sizeof(_uart_string) - 1) { count = 0; //Zähler zurücksetzten } } } [/c]
-
Thread
Wie Messwerte im Programm verfügbar machen ohne globale Variablen
also entweder als static, oder im main loop (das man ja nie verlässt). Oder sogar nur mit malloc(sizeof(type)); Eines sollte klar sein: Im Prinzip ist durch die Deklarierung als "typedef" nur eine Maske definiert, die über einen Speicherbereich gelegt werden kann. Konkret Speicher belgt man erst
-
Thread
NXP K64, GCC, Variablenspeicher nach Reset nicht überschreiben. Wie?
+ SIZEOF(.data); /* Global data not cleared after reset. */ .noinit ADDR(.bss) + SIZEOF (.bss) : AT (ADDR (.noinit)) { PROVIDE (__noinit_start = .) ; *(.noinit*) PROVIDE (__noinit_end
Johann L. schrieb im Beitrag #5251571: > .bss ADDR(.data) + SIZEOF (.data) : AT (ADDR (.bss)) > { > PROVIDE (__bss_start = .) ; > ... > PROVIDE (__bss_end = .) ; > } > data Hm, was ist hier der Unterschied zum einfacheren: [code] .bss
-
Thread
sprintf in C - Nullen dynamisch auffüllen
evtl. char fmt[32]; snprintf(fmt, sizeof(fmt) "%%0%ui", X); snprintf(MyCharArray, sizeof(MyCharArray), MyInt);
evtl so (korrigiert). char fmt[32]; snprintf(fmt, sizeof(fmt) "%%0%ui", X); snprintf(MyCharArray, sizeof(MyCharArray), fmt, MyInt);
-
Thread
Arduino - 2 dimensionales Array an Funktion übergeben
{0, 1, 1, 1, 0}}; void tuWasMitFeld(const DatenFeld & feld) { const size_t dim1count = sizeof(feld)/sizeof(feld[0]); const size_t dim2count = sizeof(feld[0])/sizeof(feld[0][0]); for (int i=0; i<dim2count; i++) { for (int ii=0; ii<dim1count; ii++) { if (feld[ii
-
Thread
lwIP UDP Pakete senden
char msg1[]="testingUDPtransmit"; struct pbuf *ppp; ppp = pbuf_alloc(PBUF_TRANSPORT,sizeof(msg1),PBUF_RAM); memcpy (ppp->payload, msg1, sizeof(msg1)); udp_sendto(pcb_tr,ppp,&ip_computer,TRANSMIT_PORT_DESTINATION); pbuf_free(ppp); }
sys_check_timeouts(); } } void UserIRQHandler(void) { ppp = pbuf_alloc(PBUF_TRANSPORT,sizeof(msg1),PBUF_RAM); memcpy (ppp->payload, msg1, sizeof(msg1)); udp_sendto(pcb_tr,ppp,&ip_computer,TRANSMIT_PORT_DESTINATION); pbuf_free(ppp); }
-
Thread
Arduino - Serieller Empfang
} else { Serial.println(F("serBUF ov-> DEL")); memset(&serial_in_command[0], 0, sizeof(serial_in_command)); // 30.554 Bytes inputString = ""; } // if(chr_cnt<(MAXBUFFER-1)) } // while (Serial.available()) [/c]
-
Thread
c++ Datenströme
auslesen, ohne Kopiervorgang [c] char buffer[8]; // irgentwie füllen for (uint8_t i = 0; i < sizeof(buffer); ++i) buffer[i] = ReadSPIByte(); // uminterpretieren, C version Message *ptr1 = (Message *)buffer; // uminterpretiere, C++ version Message *ptr2 = reinterpret_cast<Message
-
Thread
MEGA32U4 und malloc -> App stürzt ab :(
Jan H. schrieb im Beitrag #5241609: > (char*)malloc(sizeof(char)*10); Der typecast ist überflüssig, und sizeof char ist per Definition immer 1.
Rufus Τ. F. schrieb im Beitrag #5241689: > Jan H. schrieb im Beitrag #5241609: >> (char*)malloc(sizeof(char)*10); > > Der typecast ist überflüssig, und sizeof char ist per Definition immer > 1. Danke für den Hinweis.
-
Thread
TxD buffer beim ATXMega32E5 mehr als ein Byte?
DMA_TX_ESP_CHANNEL.CTRLB |= (EDMA_CH_TRNIF_bm | EDMA_CH_ERRIF_bm); memset(send_buffer, '\0', sizeof(send_buffer)); send = true; } void DMA_TX_ESP_init() // DMA vorbereiten der Trigger ist hier auf D0 gelegt. { // reset source address DMA_TX_ESP_CHANNEL.ADDRL = 0; DMA_TX_ESP_CHANNEL.ADDRH
-
Thread
i2C uint8_t *data
ACCESS_CONFIG; HAL_I2C_Master_Transmit(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &txData, sizeof(txData), 10); // Shift is necessary because of i2C function description HAL_I2C_Master_Receive(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &rxData, sizeof(rxData), 10); // Shift is necessary
ByteArray; HAL_I2C_Master_Transmit(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &txData, sizeof(txData), 10); // Shift is necessary because of i2C function description HAL_I2C_Master_Receive(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, rxData, sizeof(rxData), 10); // Shift is necessary
-
Thread
C: Überkreuzabhängigkeiten structs in Headerfiles
typedef struct MyStructA > { > uint8 x; > uint8 y; > MyStructB z; > } MyStructA; also: sizeof(MyStructA) >= 2 + sizeof(MyStructB); > typedef struct MyStructB > { > uint8 af; > uint8 fe; > MyStructA be; > MyStructA af; > } MyStructB; also: sizeof(MyStructB) >= 2 + 2 * sizeof
(const B *b) { return b->wert; } B* B_construct (double value) { B *b = malloc (sizeof (B)); b->wert = value; b->pA = NULL; b->pB = NULL; return b; }[/c] Alles, was Module außer a.c über B zu wissen brauchen, ist der Name der Struktur, und alle Module außer
-
Thread
Temp. Sensor
habe beispielweise HAL_I2C_Master_Transmit(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &txData, sizeof(txData), 10); und HAL_I2C_Master_Receive(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &rxData, sizeof(rxData), 10); Die Adressen, die ich beispielweise durchgeben müsste, wären 0x90 zum schreiben
t_ByteArray tempBytes; HAL_I2C_Master_Receive(&hi2c1, TEMP_SENSOR_ADRESS_8_BIT, resultBuf, sizeof(resultBuf), 10); // Shift is necessary because of i2C function description tempBytes.HByte = (int8_t)resultBuf[0]; tempBytes.LByte = resultBuf[1]; return tempBytes; } [/c]
-
Thread
constexpr Argument-Wrapper
Argumente diesen Typs zu übergeben? Da kann man doch einfach den Typ selbst nutzen? So wie wenn ich sizeof verwende. [c]size_t get_size (int i) { return sizeof (i); }[/c] Hier brauch ich gar kein Objekt und kein Argument, da die Info im Typ selber steckt: [c]size_t get_size (void) { return sizeof (int); }[/c] Irgendwie versteh ich die ganze Denke nicht, und da werden wohl Probleme gelöst, die durch ein Übermaß an Sprachmitteln erste entstehen, und durch noch kompliziertere — Verzeihung,
-
Thread
Peter Flury´s UART Routinen
Veit D. schrieb im Beitrag #5226755: > uint8_t length = sizeof(Nachricht)-1; Moin. Vielen Dank, dass du dir die Zeit nimmst. Was jedoch ist "Nachricht"? soll das etwa die 32 Bits vom Buffer sein? Oder soll da die Länge, von dem drin stehen was ich erwarte
Hallo, [c] uint8_t length = sizeof(Nachricht)-1; [/c] Nachricht ist der Name meiner Datenstruktur zum senden und empfangen. Hier kannst du den Namen deines Empfangsarrays eintragen. Also deinen Buffer.
-
Thread
esp8266: keine Verbindung zu Apache-Server
/ Daten an Server senden connectAndSendData(); delay(500); memset(email, 0, sizeof(email)); memset(vorname, 0, sizeof(vorname)); memset(nachname, 0, sizeof(nachname)); } } } [/c] Das Problem ist, dass der ESP8266 keine Verbindung zum Apache-Server
-
Thread
Pointer übergabe führt zum Absturz?
Speicher reserviere, klappt es! [C] int main(int argc, char *argv[]){ char *inBuff = malloc(sizeof(char)*50); strcpy(inBuff,"+ADDR:1234:56:abcdef"); printf("Function Result.: %d\r\n",srchCmd(inBuff,"+ADDR:xxxxxxxxxxxxxx")); printf(getBlthAddr(inBuff)); return 0; } [/C]
Steffen W. schrieb im Beitrag #5224221: > char *cmdBeginn_ = malloc(sizeof(char)*cmdStrLen); > strcpy(cmdBeginn_,srchCmd); Da ist kein Platz für die 0-Terminierung ... Du brauchst 1 Byte mehr als der String lang ist. Sicherheitshalber sollte man eh kein strcpy verwenden
-
Thread
0-pointer in c
memset() und vergleiche ihn dann mit einem richtigen Nullpointer. [c] char *x; memset(&x, 0, sizeof(x)); if (x != (char *)0) { printf("Nullpointer != 0\n"); } [/c]
-
Thread
AVR EEMEM Initialisierung C++14
Speicherobjekte" im Block schreiben oder lesen. [c] eeprom_update_block (&dataRAM, &dataEEP, sizeof (DATABLOCK)); eeprom_read_block (&dataRAM, &dataEEP, sizeof (DATABLOCK)); [/c] Das muss doch im Sprachstandard von C++ erlaubt sein? Die Sprache kann mir doch nicht den direkten Zugriff
Entweder gibt man seinem EEProm-Typ einen Typumwandlungs-Ctor von etwa std::array<std::byte, sizeof(DT)>: dieses Array muss natürlich schon im RAM liegen, d.h. man muss es vorher durch plattformspezifische Funktionen wie etwa eeprom_read_block(...) füllen, oder man benutzt ein placement-new, oder
-
Thread
Universelles Diagramobjekt erstellen
return (NULL); /* Reserviere Speicher für Infostruct*/ DiaParam_t* dest = malloc(sizeof(DiaParam_t)); if (dest == NULL) return(NULL); /* Kopiere Infos in neuen Struct */ memcpy(dest,src,sizeof(DiaParam_t)); /* Reserviere Speicher für Wertetabelle */ size_t len; switch (src->DataFormat) { case t_float : len = sizeof(float); break; case t_int8 : len = sizeof(int8_t); break; case t_uint8 : len = sizeof(uint8_t);
-
Thread
Absturz bei Fehler auf Struktur
struct temp { char buf[50]; }; int main(){ struct temp *x[5]; while((fgets(x[i]->buf, sizeof(x[i]->buf), file)) != NULL){ //Hier ist der Fehler i++; } [/c] Es hat irgendwas mit der Adressierung, weil wenn ich kein Pointer verwenden funktioniert es: [c] int main(){ struct temp x[5]; while((fgets(x[i].buf, sizeof(x[i].buf), file)) != NULL){ //Hier ist der Fehler i++; } [/c] So funktionierts komischerweiße. Ich habe die Funktionen bezüglich dem Öffnen des Files nicht angegeben, weil da nicht der Fehler
-
Thread
AVR-gcc kennt keine Adresslimits?
(2); _edata = . ; PROVIDE (__data_end = .) ; } > data ASSERT((ADDR(.calram) + SIZEOF(.calram)) <= ADDR(.data), ".calram exceeds page size") [/c] Grüße
) ; *(.stack*) . = stacksize; PROVIDE (__stack_end = .) ; } > data ASSERT(SIZEOF(.stack) <= (stacksize), "stack size exceeded") .eeprom : [/c] Aber Recht hast Du sicher: Der "normale" User wird das nicht unbedingt benötigen...
-
Thread
CRC16 auf CRC32 erweitern (C)
[256] = {0}; uint8_t message[3] = {0xA1, 0xDE, 0x2B}; create_crc32_table(Crc32Table, sizeof(Crc32Table)/sizeof(uint32_t)); uint32_t crc = Compute_CRC32(message, sizeof(message), Crc32Table); printf("CRC_32-Code ist: %x\n", crc); return 0; } /*********************
-
Thread
8bit Datentransfer von int16-Werten
verdächtigen foo( uint8_t *ptr , uint32_t len ) { foo( (uint8_t *)&daten16bit , 2 /*sizeof(datatype)*/ ) } beim empfang auch in einen 16bit oder in 8bit array[2] empfangen mit 8bit *ptr weil bei jedem byte der pointer incrementiert wird sind die daten immer in der gleichen reihenfolge
-
Thread
Helix MP3 Decoder für x86 Linux
(int64_t) y) >> 32ll; } static __inline int FASTABS(int x) { int sign; sign = x >> (sizeof(int) * 8 - 1); x ^= sign; x -= sign; return x; } static __inline int CLZ(int x) { int numZeros; if (!x) return (sizeof(int) * 8); numZeros = 0; while (!(x & 0x80000000
-
Thread
Parameter in Funktion speichern. Geht das überhaupt? C
, pActualParameters, sizeof(paramsTypeDef)); } } void main() { paramsTypeDef paramsA; paramsTypeDef paramsB; paramsTypeDef paramsC; paramsTypeDef actualFaders; actualFunctionTypeDef actualFunction = isFunctionA
Stefan K. schrieb im Beitrag #5212161: > memcpy (pSavedparameters, pActualParameters, sizeof(paramsTypeDef)); wieso nicht [c] *pSavedParameters = *pActualParameters; [/c] ?? Das reduziert (mindestens) eine Fehlerquelle und erlaubt dem Compiler, so zu optimieren, wie er das für richtig