-
Thread
Arduino Pro Mini Software RTC
/* Ziehe von allen Zeichen '0' ab = Offset der Zahlen in ACII */ for (uint8_t i = 0; i < sizeof(answer)-1; i++) answer[i] = answer[i]- '0'; timestamp->year = (answer[10] * 10 + answer[11]); timestamp->month = (answer[13] * 10 + answer[14]); timestamp->day = (answer[16
-
Thread
Arraylänge falsch?
Sizeof kennt keine Sonderbehandlung einer 0. Strlen hingegen hört vor einer 0 auf.
Unterschied, wenn du ein globales uninitialisiertes Array hast. Dann liefert strlen 0 Und sizeof den reservierten Speicher in Bytes.
-
Thread
meine while Schleife funktioniert nicht ;) Gesperrt
[c] name = xml_value (buf, "name"); attr = xml_value (buf, "value"); ball = calloc (1, sizeof(pin_struct)); ball->next = chip->balls; chip->balls = ball; ball->name = name; for (si = 0; si < SIGMAX; si++) { st = strchr (attr, ' '); if (st) { *st++ = '\0';
-
Thread
Receive UDP - Thread verzögert Empfang?
SOCKADDR_IN echoClntAddr; // Set the size of the in-out parameter int clntAddrLen = sizeof(echoClntAddr); // Block until receive message from a client recvMsgSize = echoServer.ReceiveFrom(echoBuffer, 128, (SOCKADDR*)&echoClntAddr, &clntAddrLen, 0); if (recvMsgSize > 0)
-
Thread
ESP32 Wrover 4MB SPI-RAM mit Arduino nutzen
nutze ich es falsch. [c] const int N = 128*1024; byte* buff; if (buff = (byte*)ps_malloc(sizeof(byte)*N)) Serial.println("ps_malloc succeeded"); else Serial.println("ps_malloc failed"); [/c] Ergibt [c] -> ps_malloc failed [/c] Hier nochmal mein geändertes Testprogramm:
Serial.printf("\n%d Bytes free.\n\n", ESP.getFreeHeap()); // ps_malloc if (buff = (byte*)ps_malloc(sizeof(byte)*N)) Serial.println("ps_malloc succeeded"); else Serial.println("ps_malloc failed"); // heap_caps_malloc if (buff = (byte*)heap_caps_malloc(sizeof(byte)*N, MALLOC_CAP_8BIT)
-
Thread
STM32F4: SPI TX DMA (ohne HAL) Problem
PAR = (uint32_t) &(SPI1->DR); DMA2_Stream3->M0AR = (uint32_t) SPI_Data; DMA2_Stream3->NDTR = sizeof(SPI_Data); DMA2_Stream3->CR = (3<<DMA_SxCR_CHSEL_Pos)|DMA_SxCR_MINC_Msk|DMA_SxCR_CIRC_Msk| (0b01<<DMA_SxCR_DIR_Pos); DMA2_Stream3->CR |= DMA_SxCR_EN_Msk; [/c] Der SPI funktioniert
-
Thread
Wärmebildkamera mit dem MLX90640 und Arduino Due
{ i2c_eeprom_updateUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0])); // Zaehler zuruecksetzen } else { i2c_eeprom_readUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(
, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0])); i2c_eeprom_readUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0])); Serial.println();
-
Thread
Lebensdauer von lokalen Variablen
Frank M. schrieb im Beitrag #5667993: > if (strlen(text) + strlen(MsgToSend) >= sizeof(MsgToSend)) { Danke für den Hinweis auf den Fehler!
angeblich auch einfach so gehen: [c]serialSIM800.print(F(atc));[/c] Erspart die Kopie komplett. sizeof(char) ist übrigens /immer/ 1, denn die Einheit, in welcher sizeof die Größe angibt, ist in Vielfachen von char. Und da char immer genau 1 char groß ist, ist sizeof(char)=1. Gilt analog auf für signed
-
Thread
Struct als Argument (C++)
@ A. S. Danke, aber das 'sizeof(myStruct)' ist ungeil. Es muss ohne gehen.
Rahald schrieb im Beitrag #5665832: > Danke, aber das 'sizeof(myStruct)' ist ungeil. Es muss ohne gehen. Dann macht man das in C mit einem Makro: [c] #define myDoUpdate(s) DoUpdate(&s, sizeof(s)) ... myDoUpdate(myStruct); ... [/c] (Hier
-
Thread
Einstieg in die µC-Welt
client.connected()) { buffer[0]=0; append_until(client,buffer,sizeof(buffer),'\n'); // Find the Date header and display its value, example: // Date: Tue, 18 Dec 2018 09:35:00 GMT if (strstr(buffer, "Date: "))
-
Thread
Atmega Dynamische Portzuweisung in Schleife
ports[] = { &PORTA, &PORTC, &PORTD, &PORTE, /* ... */ } for (uint8_t i=0; i<(sizeof(ports)/sizeof(ports[0]); i++) { *(ports[i]) |= /* ... */; } [/c] Wie man drauf kommt? Man liest die Dokumentation: https://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass
&PORTA, > &PORTC, > &PORTD, > &PORTE, > /* ... */ > } > > for (uint8_t i=0; i<(sizeof(ports)/sizeof(ports[0]); i++) > { > *(ports[i]) |= /* ... */; > } > [/c] > > Wie man drauf kommt? Man liest die Dokumentation: > > https://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass
-
Thread
STM32 CUBEMX und Printf() über UART
schätzt die maximale Größe schnell mal falsch ein. Da ist es doch viel einfacher, immer snprintf+sizeof zu nutzen. Das funktioniert dann auch nach Änderung der Puffer-Größe, Format-String oder Eingaben noch. Als schlampige Programmierung würde ich es sehen, wenn die Sicherheit der Anwendung davon abhängt
as "in use" txComplete=0; // copy the string into the buffer (with size limit) if (len>sizeof(buffer)) { len=sizeof(buffer) } memcpy(buffer,ptr,len); // send the buffer HAL_UART_Transmit_IT(&huart1, buffer, len); return len; } [/c] Bei diesem Code dürfen die Strings
-
Thread
UART auslesen funktioniert nicht
gesetzt ist. Daher: [code] // Set flags to a defined starting point memset(&SerialPortSettings, 0, sizeof(SerialPortSettings)); [/code] Übrigens, der Variablenname SerialPortSettings nervt. Das ist eine temporäre Variable, die man kurzzeitig braucht, also warum der Roman? > /* Setting the
-
Thread
incompatible types when returning type ‘int *’ but
name; // // arr_##name alloc_arr_##name(int len) { // arr_##name a = {len, len > 0 ? malloc(sizeof(type) * len) : NULL}; // return a; // } // // arr_integer guno(int playercount, arr_string moves) { } [/code] Anzahl der Player ist klar und die Anzahl der moves und die Karten sind auch
-
Thread
Bytes einsammeln, Überlauf Problem?
Hansi schrieb im Beitrag #5650105: > if ( index > sizeof(inStream) ) index darf nicht grösser als (sizeof(inStream)) - 1) werden.
@Stefanus Wo ist oben? Ich sehe nirgends ein sizeof(stream).
-
Thread
Probleme mit selbstgebautem rudimentären IP-Stack mit Pcap
eingesetzt hat. Versuch mal dashier: [code] ip_header->ip_sum = in_cksum((u_int16_t *) ip_header, sizeof(struct struct_ip)); // Header checksum ip_header->ip_src = global.emul_ip; // Source address ip_header->ip_dst = global.caller_ip; // Destination address
change later checksum calculation. icmp_header->icmp_sum = in_cksum((u_int16_t *) icmp_header, sizeof(struct struct_icmp)+global.datalen); // ip-Parameter [/code]
-
Thread
GCC section für string
Variablen geht es: [c]#include <cstdio> #define EEPROM_STR(literal) ([] () -> const char (&) [sizeof(literal)] { static constexpr char str [] __attribute__((section(".eepromSection"))) = literal; return str; } ()) void test (const char* str) { puts (str); } int main () { test (EEPROM_STR
geht es: > > [c]#include <cstdio> > > #define EEPROM_STR(literal) ([] () -> const char (&) [sizeof(literal)] { > static constexpr char str [] __attribute__((section(".eepromSection"))) > = literal; return str; } ()) > > void test (const char* str) { > puts (str); > } > > int main (
-
Thread
Prüfen ob ein Wert in Variadic Template Liste vorkommt?
template<typename ...Types> bool contains(const int type_id) { static constexpr int AllIds [sizeof...(Types)] { Types::Id () ... }; return std::find (std::begin (AllIds), std::end(AllIds), type_id) != std::end(AllIds); }[/c]
template<typename ...Types> > bool contains(const int type_id) > { > static constexpr int AllIds [sizeof...(Types)] { Types::Id () ... }; > return std::find (std::begin (AllIds), std::end(AllIds), type_id) != > std::end(AllIds); > } constexpr mit VS2015 ist leider nicht so prickelnd :(
-
Thread
wer kann codesys programmieren
format MEMUtils.MemCpy(pbyDest := ADR(dwAbortCode), pbySrc := ADR(SDOWrite.ERRORINFO), dwSize := SIZEOF(dwAbortCode)); MEMUtils.SwapLocalToIntel(pAddress := ADR(dwAbortCode), iSize := TO_INT(SIZEOF(dwAbortCode))); //function only swaps on big endian systems END_IF xEnable := FALSE; END_IF
-
Thread
Atmega328P Receive Interrupt - Code Review
|= (1 << TXCIE); } void sbus_timer_init() { //memset( (void*)transmit_data_per_slot, 0, sizeof(transmit_data_per_slot)); for(uint8_t i = 0; i < 32; i++) { transmit_data_per_slot_status[i] = EMPTY; } TCCR2B = 0x00; //disable Timer2 while we set it up TCNT2
-
Thread
Array als pointer in Funktion übergeben, dort beschreiben und wieder zurück
include <stdint.h> #include <stdio.h> #define NUMBER_OF_ELEMENTS 110 #define ARRAY_SIZE(a) (sizeof (a) / sizeof (a[0])) uint8_t array [NUMBER_OF_ELEMENTS] = {0}; void generate_stuff (uint8_t* array_ptr, size_t array_size) { for (size_t i = 0; i < array_size; ++i) { uint8_t fancy_value_to_assign
-
Thread
Mikrocontroller über Ethernet verbinden
Serial.print(mymac[i], HEX); if (i < 5) Serial.print(':'); } Serial.println(); if (ether.begin(sizeof Ethernet::buffer, mymac, 8) == 0) { Serial.println( "Failed to access Ethernet controller"); } else { Serial.println("Ethernet controller access: OK"); } ; #if STATIC Serial.println( "Getting
digitalWrite(ledPin10, LOW); } // show some data to the user memcpy_P(ether.tcpOffset(), page, sizeof page); ether.httpServerReply(sizeof page - 1); } void blinkLed(){ while (true){ digitalWrite(ledPin10, HIGH); delay(500); digitalWrite(ledPin10, LOW); delay(500); } }[/c]
-
Thread
CubeMX und HAL - I2C hängt sich auf
in der Art: [c] HAL_I2C_Master_Transmit(&hi2c1,(uint16_t)OLED_I2C_ADDR,(uint8_t*)init_sequence,sizeof(init_sequence),100); [/c]
0x00, 0xAF, }; HAL_I2C_Master_Transmit(&hi2c1,(uint16_t)OLED_I2C_ADDR,uint8_t*)disp_on,sizeof(disp_on),100); }[/c]
-
Thread
C/C++ Funktionspointer
remainArgs.takeFirst()); auto firstTuple = std::tuple<std::decay<First>::type>(first); if constexpr ( sizeof...(Args) == 0 ) { return firstTuple; } return std::tuple_cat(firstTuple, deserialize<Args...>(remainArgs)); } [/c] Meine alte Variante macht es mit Function Template specialization
-
Thread
MINOS - Minos Is No Operating System
cmd_cd }, ... { "umount", cmd_umount }, }; ... uint_fast8_t n_cmds = sizeof (intern_cmd_table) / sizeof (INTERN_CMD_TABLE); for (idx = 0; idx < n_cmds; idx++) { if (! strcmp (command, intern_cmd_table[idx].cmd)) { rtc = (* intern_cmd_table
-
Thread
SIM800 GSM: Welche Library für Arduino?
serialSIM800.print(atc); delay(500); while (serialSIM800.available() && (cnt < sizeof(response))) { *(p++) = serialSIM800.read(); cnt++; } if (cnt >= sizeof(response)-1) /*Buffer Überlauf? */ return 0; *p = '\0'; /* String Null terminieren
/* Hole die Zeichen langsam ab */ delay(50); while (serialSIM800.available() && (cnt < sizeof(response))) { *(p++) = serialSIM800.read(); cnt++; delay(5); yield(); } if (cnt >= sizeof(response)-1) /*Buffer Überlauf? */ return 0; *p = '\0';
-
Thread
Übergang LInux Consolen-Programm -> Daemon
PC-tastatur-Eingaben verarbeitet, so etwas: [c] if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)); listen(sockfd,5); while (TRUE) { newsockfd= accept(sockfd,(struct sockaddr*)&cli_addr,&clilen); n = read(newsockfd,buffer,256,0); ... n = write(newsockfd,"...",n2,0);
-
Thread
C++ Objekt mit Array
definieren template<typename Array> constexpr size_t arrayCount(const Array &array) { return sizeof(array)/sizeof(array[0]); } class Symbol { private: static const PROGMEM Character zeichen; public: void schreiben() const; }; const Character PROGMEM Symbol::zeichen
#5622256: > template<typename Array> constexpr size_t arrayCount(const Array &array) > { > return sizeof(array)/sizeof(array[0]); > } Das würde ich dann aber eher so schreiben: [C] template<typename Array, size_t N> constexpr size_t arrayCount(const Array (&array)[N]) { return sizeof(array
-
Thread
uC für 0,20€ CH552 / CH554 von WCH Billig Micro mit USB Funktion, Chip vorstellung
sollte aber problemlos auf einem CH552 laufen. [c] const uint8_t code ConfigDesc[98] = { sizeof(ConfigurationDescriptor), USB_CONFIGURATION_DESCRIPTOR, sizeof(ConfigDesc),0, 3, // 3 interfaces 1, // one config USB_STRING_UNDEFINED,
, sizeof(EndpointDescriptor), USB_ENDPOINT_DESCRIPTOR, 0x2, EP_BULK, 0x40,0x00, 0, sizeof(EndpointDescriptor), USB_ENDPOINT_DESCRIPTOR, 0x82, EP_BULK, 0x40,0x00,
-
Thread
JPG format kurios - tjpgdec oder libjpeg funktionieren nicht
case 0xDA: /* SOS */ if( huff == 0 ){ rc = create_huffman_tbl(jd, huffman1 , sizeof(huffman1)/sizeof(unsigned char) ); rc = create_huffman_tbl(jd, huffman2 , sizeof(huffman2)/sizeof(unsigned char)); rc = create_huffman_tbl(jd, huffman3 , sizeof(huffman3)/sizeof(unsigned char)); rc = create_huffman_tbl(jd, huffman4 , sizeof(huffman4)/sizeof(unsigned char)); } [/c] ja ich suche schon 2 tage ... bin gerade per zufall auf einen hinweis gestoßen und hab das mal probiert. ist Quick and dirty .. aber läuft
-
Thread
UDP-Pakete mit lwip senden
ip_addr_t ip_addr_Src; struct pbuf *p_out; uint8_t test3[100] = "Hallo\n\r"; uint16_t lenght = sizeof(test3); //uint8_t test4[7] = "Hallo\n\r"; //p->payload = &test3; IP4_ADDR(&ip_addr_Src, 192, 168, 0, 23); IP4_ADDR(&ip_addr_Dest, 192, 168, 0, 10); /* get new pcb */ pcb_TX
-
Thread
Wie kann ich ein Array über I2C übertragen?
header und CRC data.crc = 0x00 // wer lust hat kann es selber berechnen i2c.send(i2c_addr, &data, sizeof(struct _data); [/c] jetzt kannst du dir noch überlegen, ob 1024 Byte immer sauber über den Bus gehen. Wenn nicht, dann kannst du mit Chunks arbeiten und ggf. das im Typ kodieren oder die Daten nochmals
es! int test[10]; // und in einer Funktion dann: Wire.write(reinterpret_cast<byte*>(test),sizeof(test));