-
Thread
Linux C "free(): double free detected in tcache2
[c] while( 1){ size = sizeof( a1); fd = accept( s, (struct sockaddr*) &a1, &size); if ( ( pid = fork()) < 0) { printf( "\nfork err %s", strerror( errno));
A alloc err tmp"); size = GetRecData( fd, &tmp, ip); memset( http_header, 0, sizeof( http_header)); mopen( tmp, strlen( tmp)); st = 0; while ( mgetstrim( str)){ if ( ! *str) break; appsprintf( http_header
-
Thread
ATMega8 und Servo völlig merkwürdiges Verhalten
START_CYCLE_SLEEP); // RUNLEDs and Servo movement for(char i=0;i<=sizeof(servoPattern)-1;i++) { #ifdef RUNLED PORTD=ledPattern[mapLedPosFromServoPos(servoPattern[i])]; #endif #ifdef SERVO_UP OCR1A = servoPattern
-
Thread
ESP8266 D1 Mini zeigt immer HIGH an obwohl nix angeschlossen ist
0b11100110 // = 9 }; // assert(digit < 10); const size_t ENTRY_COUNT = sizeof(seven_seg_digits)/sizeof(seven_seg_digits[0]); if(digit >= ENTRY_COUNT) { Serial.println("sevenSegWrite, argument out of range!"); return; } digitalWrite(latchPin
-
Thread
SAM C21 Harmony3 ADC Konfiguration
*/ adc_count = ADC0_ConversionResultGet(); // SERCOM3_USART_Write(&text[0], sizeof(text)-1); sprintf(txData, "ADC Count = 0x%03x, ADC Input Voltage = %d.%02d V \r\n", adc_count, adc_count,adc_count); SERCOM1_USART_Write(txData, strlen(txData)); ADC0
-
Thread
STM32: SPI - HAL durch eigenen code ersetzen
"); uint8_t data = 0; if (dataOut) { data = *dataOut; dataOut += sizeof(uint8_t); } *(__IO uint8_t *)g_spi->DR = data; txLen -= 1; } if (g_spi->SR & SPI_SR_RXNE) { //something to receive printf("RX1\r\n"); uint8_t data = *(_
*)g_spi->DR; if ((dataIn) && (rxLen >= 1)) { *dataIn = data; dataIn += sizeof(uint8_t); rxLen -= 1; } } } //while (g_spi->SR & SPI_FLAG_BSY); #else if ((dataIn) && (dataOut)) { HAL_SPI_TransmitReceive(&hspi2, (uint8_t*)dataOut, dataIn, len
-
Thread
STM32, Verstrichene Zeit mittels SysTick ermitteln, wie Overflow/Rollover berücksichtigen?
sein müssen, verwende ich nur den. Dann tut es die beschriebene MOD Variante. Die sich bei Typen ab sizeof(unsigned) ganz von selbst ergibt, da die Arithmetik vorzeichenloser Typen in C so definiert ist.
-
Thread
CAN STM32F7xx
(&hcan2, &TxHeader, TxData, &TxMailbox); //HAL_UART_Transmit(&huart3,RxHeader.StdId,sizeof(RxHeader.StdId),1); //HAL_UART_Transmit(&huart3,"Loop",5,1); lastMillis1 = millis(); } if( ( millis()-lastMillis3 ) > 1){ HAL_CAN_GetRxMessage
-
Thread
Problem mit Websever, Port unklar und ändert sich
sockaddr_in a, a1; static int port = 8001; s = socket( AF_INET, SOCK_STREAM, 0); memset( &a, 0, sizeof( a)); a.sin_family = AF_INET; a.sin_port = htons( port); a.sin_addr.s_addr = htonl( INADDR_ANY); bind( s, (struct sockaddr*) &a, sizeof( a)); listen( s, 100); printf( "\nlistening
kriegst du es mit [c] int flagvalue = 1; setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &flagvalue, sizeof(int)); [/c] vor dem "bind".
-
Thread
Linux, accept() file handle
void show_fd0() { char buf[256]; ssize_t n; n = readlink("/proc/self/fd/0", buf, sizeof(buf)-1); if (n >= 0) { buf[n] = 0; puts(buf); } else perror("readlink"); } [/c]
liegenden FD-Parameter mit 0. Kann z.B. bei einem memset() oder bzero() passieren, wenn man nicht sizeof benutzt.
-
Thread
ESP-01 Relay und Arduino IDE
Serial.begin(9600); //loop byte close[] = { 0xA0, 0x01, 0x01, 0xA2 }; Serial.write(close, sizeof(close)); delay(2000); byte open[] = { 0xA0, 0x01, 0x00, 0xA1 }; Serial.write(open, sizeof(open)); delay(2000); [/c] Ich habe auch schon versucht den Code mehrfach einzugeben.
-
Thread
STM32 Header
uint32_t SR; // 1; // 0 Early Wakeup Interrupt Flag } wwdg_struct; _Static_assert (sizeof(wwdg_struct) == 12, " wwdg_struct: bad size"); static wwdg_struct * const WWDG = (wwdg_struct *)0x40002c00;[/c] Dass hier kein #define auftaucht ist kein Zufall. Dank der struct mit Bitfeldern
uint32_t SR; // 1; // 0 Early Wakeup Interrupt Flag > } wwdg_struct; > _Static_assert (sizeof(wwdg_struct) == 12, " wwdg_struct: bad size"); > static wwdg_struct * const WWDG = (wwdg_struct *)0x40002c00; > Dass hier kein #define auftaucht ist kein Zufall. Dank der struct mit > Bitfeldern
-
Thread
FreeRTOS TaskB von TaskA triggern und ausführen
message_ts sendMessage_s; message_ts receiveMessage_s; sendQueue = xQueueCreate(10, sizeof(message_ts)); if(NULL == sendQueue) { ESP_LOGE(TAG, "failed xQueueCreate"); return; } portBASE_TYPE xStatus; while(1) { xStatus = xQueueReceive
-
Thread
array element in struktur beschreiben
const uint8_t id; }info_ts; const info_ts info_s = { .paddress = address, .addrLen = sizeof(address), .id = 0x85 }; [/c]
-
Thread
ESP32 andauern reset
ESP_LOGI(TAG, "sendData"); result = esp_now_send(broadcastAddress, (uint8_t*)&message_s, sizeof(message_s)); message_s.x++; message_s.y--; vTaskDelay(2000 / portTICK_PERIOD_MS); } } void initMasterTask(void) { xTaskCreate(masterTask, "masterTask", 100000
-
Thread
float nach string mit einer nachkommastelle
Irgend W. schrieb im Beitrag #7002112: >> sprintf(result,"%f",num) > > eher: sprintf_s(result, sizeof(resault), "%.1f", num); oder noch eher: sprintf_s(result, sizeof(resault), "%.1f", num/10.);
return target; } int main() { char buf[5]; printf("%s\n", toString(buf, sizeof buf, 1)); printf("%s\n", toString(buf, sizeof buf, 10)); printf("%s\n", toString(buf, sizeof buf, 100)); } [/c] Newbie schrieb im Beitrag #7002943: > In anderen Programmiersprachen
-
Thread
LoadImage findet BMP nicht
hBitmap) { err = GetLastError(); return 1; } BITMAP bmp; GetObject(hBitmap, sizeof(bmp), &bmp); HWND hwnd = FindWindow(L"ConsoleWindowClass", NULL); if (!hwnd) return 2; HDC hDC = GetDC(hwnd); if (!hDC) return 3; HDC hBitmapDC = CreateCompatibleDC(hDC); if
-
Thread
bin2bcd, effektiverer Code ?1?
stdio.h> #include <stdlib.h> int main () { char* t; uint32_t i=12345690; char buffer [sizeof(unsigned long)*8+1]; sprintf (buffer,"%lu",i); i=0; for (t = buffer; *t != '\0'; t++) i |= (i<<4)|(((uint8_t)*t-48) & 0xff); return 0; } [/c]
-
Thread
Retro-Projekt: NE555 basierter Elektronischer Würfel in THT
* Deklarationen ********** // // ---------- Konstanten ------------- // #define countof(a) (sizeof(a) / sizeof(a[0])) const unsigned int debugLevelA = 9 ; // auf Ebene: SchleifeEINgangsBeschaltung() const unsigned int debugLevelB = 8 ; // auf Ebene: SchleifeAUSgangsBeschaltung() const unsigned
-
Thread
LED durch "Toggeln" aufleuchten lassen
verändert hat { static byte previousState = 0; byte currentState = 0; for (size_t i = 0; i < sizeof(buttonPin); i++ ) { if (digitalRead(buttonPin[i]) == LOW) currentState += 1 << i; } bool result = false; if (previousState != currentState) result = true; previousState = currentState
-
Thread
ESP32 - Hue-Stream
size) { int c = stream->readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size)); USE_SERIAL.write(buff, c); deserializeJson(doc, buff);
-
Thread
Frage zu typedef bei Strukturen
des Typs und kann sich anschauen, wie groß er ist. Oder man startet den Debugger und lässt sich sizeof(Typ) ausgeben, wenn man es ganz genau wissen will.
definiert, dass du den Speicher byte (oder Char?) weise ab der Start-Adresse lesen kannst so gross wie sizeof() das angibt, und du hast die gesammte Struktur gelesen. Es können alignment gaps in dem Speicher auftauchen, die von den einzelnem Elementen nicht belegt werden. aber die müssen in sizeof() enthalten
-
Thread
pic32 +cc1101
uint8_t status[2]; SYS_DEBUG_PRINT(SYS_ERROR_DEBUG, " packetLength = 0x%2x\r\n", sizeof (NoMo4_Packet_t)); SYS_DEBUG_PRINT(SYS_ERROR_DEBUG, " RXBYTES = 0x%2x\r\n", CC1101_RXBYTES); //////RXBYTES--->Number of bytes in RX FIFO if (_CCRadio_SpiReadStatusReg(CC1101_RXBYTES
RXBYTES, &RxBytes); /////if (RxBytes & BYTES_IN_RXFIFO) { size = sizeof (NoMo4_Packet_t); SYS_DEBUG_PRINT(SYS_ERROR_DEBUG, " size1 = 0x%2x\r\n", size); _CCRadio_SpiReadBurstReg(CC1101_RXFIFO, rxBuffer, size); SYS_DEBUG_PRINT
-
Thread
Wir haben ihn noch nicht gefeiert!
rückwärts. Wenn man dann auch noch auf bestehendem Code aufbaute, der in alter Unix-Tradition von sizeof(int) == sizeof(char *) ausging, war 16-Bit x86 jenseits der Small+Medium Models einfach bloss übel.
-
Thread
Strings kopieren in "Arduinoumgebung" mit strncpy
Prinzip die Komma durch \0 ersetzen und die Positionen merken Z.B. so:[c] #define NELEM(x) (sizeof(x) / sizeof(*(x))) // split str at delim (in place) // stores substrings in res[], returns nr of delim found int split(char *str, char delim, char **res, int nres) { int n = 0; res
-
Thread
Const- rocord-Array in ASM zuweisen.
begin p := @Rgb_Line[Line]; asm CLI end; for byteCount := 0 to sizeof(Rgb_Line[Line]) - 1 do begin RGBdata := p^; inc(p[1]); for bitCount := 0 to 7 do if RGBdata and $80 > 0 then begin asm {$if defined (ATTiny25
-
Thread
Evaluating the address of the parameter
_t type; uint32_t data; }msgType void videoTransmit(msgType msg) { (void)cam_Transmit(sizeof(pfm_msg_st),(uint8*)(&msg)); } [/c] Die Warnung ist: Evaluating the address of the parameter 'msg' [c] uint8_t cam_Transmit(uint16_t window_size, uint8_t* sendWindow); [/c] Aber was
Marcel schrieb im Beitrag #6971029: > (void)cam_Transmit(sizeof(pfm_msg_st),(uint8*)(&msg)); (uint8*) Hast du dich da vertippt oder meckert dein Compiler da etwa nicht? edit: Sonst sollte der cast eigentlich funktionieren. Aber was ist mit dem Allignment
-
Thread
Kein Ton! STM32H743 I2S Salve mit DMA
HAL_NVIC_EnableIRQ (SPI2_IRQn); // Dann das Handle erzeugen und füllen memset( & m_HandleI2S,0,sizeof(m_HandleI2S) ); m_HandleI2S.Instance = p_I2SBus; m_HandleI2S.Init.Mode = I2S_MODE_MASTER_TX; m_HandleI2S.Init.Standard = I2S_STANDARD_MSB; m_HandleI2S.Init.DataFormat
-
Thread
Mit C mehrstufige Verzeichnisstruktur durchsuchen;
Mit "next = (set*) calloc(1, sizeof(set));" statt "next=calloc(1,sizeof(set));" in Zeile 45 klappt das Compilieren.
interrupt schrieb im Beitrag #6979086: > Mit > "next = (set*) calloc(1, sizeof(set));" > statt "next=calloc(1,sizeof(set));" > > in Zeile 45 klappt das Compilieren. Das deutet darauf hin, dass du den Code als C++ statt als C kompiliert hast. In C++ geht es nicht ohne den
-
Thread
Probleme beim STM32H743 & SPI
IPC_SPIcfg.hSPI); [/c] kommt sofort der Transfer Error Interrupt. Anmerkung: "HalfBufSize" ist "sizeof(MEAS_values_TDS)" = 40 Byte; Der Rx und Tx Buffer sind doppelt so groß wie die Transfer-Size, ich nutze abwechselnd den High- und den Low-Buffer. Noch nicht implementiert ist, die Behandlung der empfangenen
-
Thread
Tabelle mit Zeiger auf Variablen
Power-Fail Interrupt ins Eeprom gerettet werden sollen. Das möchte ich in einer Schleife über den sizeof Operator der Zeigertabelle machen. Es soll nicht jedesmal das Save und Restore nachgebessert werden wenn eine Variable entfällt oder neu erforderlich wird. Ein anderer Ansatz wäre über den Linker ein
-
Thread
immer verrücktere Anschreiben von Recruitern
[c]memset(&EDAG, 0, sizeof(EDAG));[/c]
(any.Arbeitgeber) { Claus.bewerben(&EDAG); } else { Claus.weiterhartzen(); memset(&Claus, 0, sizeof(Claus)); } return 0; }
-
Thread
read data from file
was da gelesen wird. [c] fd = open(test.txt, O_RDONLY); bytesRead = read(fd, &buffer[0], 256*sizeof(uint16_t)); samples = bytesRead / sizeof(uint16_t); printf("numBytes: %d numSamples: %d\r\n", bytesRead, samples); for(uint16_t x=0; x<samples; x++) { printf("x: %d buffer: %d\
-
Thread
Arduino: Formatierung von Binärzahl
uint8_t zahl=2; // uint16_t zahl=2; // uint32_t zahl=2147483647; int bits = sizeof(zahl)*8; for (int i=0; i<bits; i++) { bool msb = zahl & (1<<bits-1); putchar('0'+msb); zahl = zahl<<1; } putchar('\n'); } [/c] Alternativ, aber
-
Thread
array Zeigerarithmetik
Data[i] = Data_init[0][i]; }[/c] Oder einfacher mit memcpy: [c]memcpy (Data, Data_init[0], sizeof(Data));[/c] Oder wenn du doch was mit Zeigern machen möchtest, kannst du Data als Zeiger deklarieren und auf die Zeile zeigen lassen. Dadurch werden keine Daten kopiert, sondern Data verweist einfach
20,30,40,50,60}, {25,35,45,55,65}}; uint8_t Data[5]; memcpy (Data, Matrix[1], sizeof(Data))[/c] Ergibt in Data: 15 0 25 0 35 sollte ergeben: 15 25 35 45 55 Offenbar wird zwischen 2 Elmenten immer eine 0 mit eingefügt- warum? alternativ [c] int Matrix[4][5] = { {10,20,30,40,50
-
Thread
Frage an die Netzwerker (default route)
tcpip_adapter_option_id_t)50, //#mb this is rfc2132 REQUESTED_IP_ADDRESS, (void*)&lease, sizeof(dhcps_lease_t) ); return tcpip_adapter_dhcps_start(TCPIP_ADAPTER_IF_AP) == ESP_OK; } return false; [/c] Bin mal gespannt ob der code formatiert ist, in der Vorschau
-
Thread
STM32F030xx > TIMx->CCRx Register
, { TIM17, TIMER_CH_1}, }; pTim->CCR1 = 0b111UL; for ( uint8_t i = 0; i < ( sizeof(TIMER_PreloadCfg) / sizeof(TIMER_PreloadCfg[0] ) ); i++ ) { if ( pTim == TIMER_PreloadCfg[i].pTim ) { if ( eCHn <= TIMER_PreloadCfg[i].eCHn ) { pTim->CCR1 += ( 0x04
-
Thread
crc-Berechnung Codezeile Erklärung
Matthias S. schrieb im Beitrag #6939311: > crc16((uint8_t *) buff, sizeof(buff), 0x1021, 0, 0, > false, false) uint8_t meineVariable = crc16((uint8_t *) buff, sizeof(buff), 0x1021, 0, 0, false, false)
ob eine solche Plattform überhaupt uint8_t kennt Den kann sie nicht kennen, denn was wäre dann sizeof(uint8_t)? sizeof arbeitet in Vielfachen von char, d.h. es kann keinen kleineren (in Sachen Speicherverbrauch) Datentyp als char geben.
-
Thread
array copy in c?
Leute! sizeof(a)/sizeof(a[0]) kann man verkürzen zu sizeof(a)/sizeof(*a) Spart wertvolle Bildschirmtinte! LG, Sebastian
nicht explizit in meinen Code schreiben. Sebastian schrieb im Beitrag #6940358: > Leute! > > sizeof(a)/sizeof(a[0]) kann man verkürzen zu sizeof(a)/sizeof(*a) > > Spart wertvolle Bildschirmtinte! Man kann es sogar verkürzen zu sizeof a/sizeof*a