-
Thread
Artikel und Bibliothek zu Serialisierung
void *memcpy(void *dst, const void *src, size_t len) { size_t i; if ((uintptr_t)dst % sizeof(long) == 0 && (uintptr_t)src % sizeof(long) == 0 && len % sizeof(long) == 0) { long *d = dst; const long *s = src; for (i=0; i<len/sizeof(long); i++)
-
Thread
SIM800L Verbindung instabil
delay(1000); Serial.println("Testing SIM800L module"); Serial.println(); Serial.print("Sizeof(mySerial) = "); Serial.println(sizeof(mySerial)); Serial.println(); } void loop() // run over and over { if( mySerial.available() ) { char c = mySerial.read(); Serial.print
-
Thread
warum mecket der gcc nicht wenn der Flash überfüllt wird?
Linkerscript anghängt: [code] /* Check if text + data exceeds Flash limit */ /*ASSERT((SIZEOF(.text) + SIZEOF(.data)) <= LENGTH(FLASH), "region text overflowed")*/ [/code]
schrieb im Beitrag #5328936: > /* Check if text + data exceeds Flash limit */ > /*ASSERT((SIZEOF(.text) + SIZEOF(.data)) <= LENGTH(FLASH), "region > text overflowed")*/ wenn Du das - wie gezeigt - in Kommentarzeichen hast, ist es nutzlos.
-
Thread
Arduino Lauflicht
leuchtdauer); digitalWrite(leds[index],LOW); index++; // eine led weiter schalten index %= sizeof(leds); // wrap around } [/c] *ungetestet* Schätze aber mal, das das Lauflicht läuft.
-
Thread
2D Array an Funktion übergeben?!
Aufruf berücksichtigt, noch kann man sie innerhalb der Funktion wieder irgendwie zurückgewinnen (sizeof gibt dir nur die Größe eines Zeigers). Am Ende ist es also nur eine Art Doku für denjenigen, der diesen Funktionskopf liest.
uint8_t* myPointer; > myPointer[0] = myValue0; Wo zeigt denn myPointer hin? Wie sieht es mit sizeof aus? Kannst du das Array auf einen andere Speicheradresse zeigen lasse? Kannst du die Größe von dem Array ändern? Ähnlich ist nicht gleich. Bei beiden funktioniert Zeigerarithmetik und die
-
Thread
Visual C++ 2010 Express mit FileHandle Gesperrt
(saveFileDialog1->OpenFile()); if(fs) { unsigned int i; for(i=0;i<=sizeof(TestV);++i) fs->WriteByte( TestV[i] ); // Set the stream position to the beginning of the file. //fs->Seek( 1, SeekOrigin::Begin ); fs->Close();
) { char filename[MAX_PATH] = { 0 }; OPENFILENAME ofn = { 0 }; ofn.lStructSize = sizeof(ofn); ofn.lpstrFilter = "Text files (*.txt)\0*.txt\0"; ofn.lpstrFile = filename; ofn.nMaxFile = sizeof(filename); ofn.lpstrDefExt = "txt"; ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY
-
Thread
Sprechende Lampe
client.connected()) { buffer[0]=0; append_until(client,buffer,sizeof(buffer),'\n'); // Find the Date header and display its value if (strstr(buffer, "Date: ")) { foundDate=true;
-
Thread
AVR Comiler Optimazation Crasht den Controller (ATMEGA328P)
if (status_msg[0]) { uart_puts(status_msg); memset(status_msg, 0, sizeof(status_msg)); } if (error_msg[0]) { uart_puts(error_msg); memset(error_msg, 0, sizeof(error_msg)); } } } [/c] Auch das staendige manuelle
-
Thread
Gefahren bei Interrupts
} } } } ISR(TIMER_INTR_NAME) { if(counter == NULL) { counter = calloc(1, sizeof(uint8_t)); } else if(*counter >= 255) { uint8_t i = 1; for(; *(counter + i) >= 255; ++i) ; counter = realloc(counter, (i + 1) * sizeof(uint8_t)); ++*(counter + i
} ISR(TIMER_INTR_NAME) { changed = 1; if(counter == NULL) { counter = malloc(sizeof(uint8_t)); *counter = 1; } else if(*counter >= 255) { uint8_t i = 1; for(; *(counter + i) >= 255; ++i) ; counter = realloc(counter, (i + 1) * sizeof(uint8_t));
-
Thread
Serielle Daten bei Arduino auslesen
] = '\0'; strcpy(serial_in_command, serial_in_buff); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); // 30.554 Bytes chr_cnt = 0; stringComplete = true; } else // Falls kein Enter kommt muss der Text gespeichert werden in dem inText Array { if(isprint
else { Serial.println(F("serBUF ov-> DEL")); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); // 30.554 Bytes memset(&serial_in_command[0], 0, sizeof(serial_in_command)); // 30.554 Bytes // *serial_in_command=0; chr_cnt=0; } // if(chr_cnt
-
Thread
Probleme mit 2d-Matrix auf elemente zugreifen
} arr_##name arr_##name alloc_arr_##name(int len){ arr_##name a = {len, len > 0 ? malloc(sizeof(type) * len) : NULL}; return a; } arr_arr_integer Rotation2D(arr_arr_integer a) { } [/code] Die Aufgabe an sich habe ich schon verstanden, allerdings komme ich nicht klar auf die
ich an den Wert 1 ran? Wie funktioniert genau [code] arr_##name a = {len, len > 0 ? malloc(sizeof(type) * len) : NULL};[/code] Normalerweise kenne ich das mit dem Fragezeicheoperator nur mit einer Bedingung. Jetzt steht vor der Bedingung allerdings noch einmal len. Was bedeutet dies? Das ##
-
Thread
Software-Lib porten, obwohl Feature fehlt
#5317552: > Eine schlechte idee, da nicht portabel. Was ist daran nicht portabel? [c] memset(&x, 0, sizeof(x)); [/c] ob da paddingbytes drin sind ist egal. Werden die halt auch auf 0 gesetzt. Tut nicht weh und macht auch nichts kaputt.
-
Thread
ELM Chan Langer Ordner Name
cfg. */ #if _USE_LFN static char lfn[_MAX_LFN + 1]; fno.lfname = lfn; fno.lfsize = sizeof lfn; #endif res = f_opendir(&dir, path); /* Open the directory */ if (res == FR_OK) { i = strlen(path); for (;;) {
*/ #if _USE_LFN //static char lfn[_MAX_LFN + 1]; fno.lfname = lfn; fno.lfsize = sizeof lfn; #endif res = f_opendir(&dir, path); /* Open the directory */ if (res == FR_OK) { i = strlen(path); for (;;) {
-
Thread
Anleitung: Atmel Studio stdout auf Output umleiten
man damit nicht leben kann einfach: [c](void) debug; [/c] durch: [c]memset((char *)debug, 0, sizeof(debug)); [/c] ersetzen. Jedoch wird auch dann noch jedes Steuerzeichen als Enter interpretiert. Wer das ändern will muss noch die Abfrage (c < 32) in (c == '\n') ändern, dann sollte es eigentlich
-
Thread
Sipdial per ESP8266 an Fritzbox
Udp.parsePacket(); if (packetSize>0) { caSipIn[0]=0; packetSize=Udp.read(caSipIn, sizeof(caSipIn)); if (packetSize>0) { caSipIn[packetSize]=0; #ifdef DEBUGLOG IPAddress remoteIp = Udp.remoteIP(); Serial.printf("\r\n----- read %i bytes from:
SendUdp(); } void Sip::Ack(const char *p) { char ca[32]; bool b = ParseParameter(ca, (int)sizeof(ca), "To: <", p, '>'); if (!b) return; pbuf[0] = 0; AddSipLine("ACK %s SIP/2.0", ca); AddCopySipLine(p, "Call-ID: "); int cseq = GrepInteger(p, "\nCSeq: "); AddSipLine("CSeq
-
Thread
Brauche Unterstützung beim OV7670 (bzw. SCCB)
data[SIZE]={}; for(int p=0; p<SIZE; p++){ data[p] = p; } for(int k=0; k<sizeof(carray); k++){ c=carray[k]; cplus1=(c+1) & MASK; cintplus1=(c+1) & MASK; printf("c=%d\n", c); printf("cplus1=%d\n", cplus1); printf("cintplus1=%d\n", cintplus1
-
Thread
C-Lehrbuch aus dem Rheinwerk-Verlag schlecht? Alternative?
Und für diesen Zweck reicht es aus (da reicht auch ein char, ist ja das Mikrocontrollerforum) (sizeof(anArray)/sizeof(short)) geht auch eleganter: (sizeof(anArray)/sizeof(*anArray))
: comparison between signed and unsigned integer expressions [-Wsign-compare] for (ix=0; ix< (sizeof(anArray)/sizeof(short)); ++ix)[/code] In der konkreten Anwendung kann man sich dann immer noch überlegen ob man's anders macht - immer noch besser, als das original falsch gelernte zu un-lernen.
-
Thread
Terratec (NEC) Fernbedienung mit IRMP
Anwendung RepeatCounter *immer* größer als 0? Weiter unten sehe ich: memcpy(buf, &myIRData, sizeof(myIRData)); USB_HID_SendData(REPORT_ID_IR, buf, sizeof(myIRData)); Die Datenstruktur wird also in einen buffer "buf" kopiert und anschließend die Funktion USB_HID_SendData() aufgerufen, bei der
check_reboot(&myIRData); } /* send IR-data */ memcpy(buf, &myIRData, sizeof(myIRData)); USB_HID_SendData(REPORT_ID_IR, buf, sizeof(myIRData)); }[/c] Dabei ist learn_wakeup irrelevant, da schon vorhanden, macros sind nicht vorhanden, resets auch nicht, wakeups
-
Thread
Raspberry SPI Empfang Problem
Hi, Gordon hat vor dem ioctl-Aufruf so programmiert: ... memset (&spi, 0, sizeof (spi)) ; spi.tx_buf = (unsigned long)data ; spi.rx_buf = (unsigned long)data ; spi.len = len ; ... Das erklärt, wieso Du das "empfangen" kannst, was Du gesendet hast
spidev.h but not used in the original kernel documentation // test program )-: memset (&spi, 0, sizeof (spi)) ; spi.tx_buf = (unsigned long)data ; spi.rx_buf = (unsigned long)data ; spi.len = len ; spi.delay_usecs = spiDelay ; spi.speed_hz = spiSpeeds
-
Thread
SSD1306 clear buffer / display code
Ich hab das ganze so gelöst: [c]void lcd_clrscr(void){ memset(displayBuffer, 0x00, sizeof(displayBuffer)); #if defined SSD1306 lcd_data(displayBuffer, sizeof(displayBuffer)); #elif defined SH1106 for (uint8_t i=0; i <= DISPLAY_HEIGHT/8; i++) { uint8_t actualLine[DISPLAY_WIDTH
actualLine[j]=displayBuffer[i*DISPLAY_WIDTH+j]; } lcd_data(actualLine, sizeof(actualLine)); lcd_gotoxy(0, i); } #endif lcd_home(); // gotoxy(0,0) } ... void lcd_data(uint8_t data[], uint16_t size) { i2c_start(LCD_I2C_ADR); i2c_byte(0x40); //
-
Thread
Doppelten Eintrag im Array finden in C, Code schneller machen
name; // // arr_##name alloc_arr_##name(int len) { // arr_##name a = {len, len > 0 ? malloc(sizeof(type) * len) : NULL}; // return a; // } // // int firstDuplicate(arr_integer a) { int value = -1; int index = 0; for(int x=0; x<a.size-1; x++) { for(int y=x+1; y
-
Thread
pointer auf typedef array
Wenn wie hier, bei der Übergabe an eine Funktion nicht, weil C dann eh > castet. Beim Benutzen von sizeof schon. Deshalb hat der Holger auch einen eigenen Thread zum Thema sizeof. Weil's darum hier nicht geht.
char volatile v; > v = T (g, g); > v = T (g, &g[0]); > __typeof(g) b; > v = sizeof (g); > v = sizeof (b); > } > dann werden nacheinander folgende Werte in v gespeichert: 0, 1, 21, 21. > > Die beiden letzten Werte sind klar, aber warum hat g nicht den Typ von g > sondern
-
Thread
Über Funktionen "loopen" (Arduino IDE)
{ int zeit = 30; // Iteriere durch ganzes Array, d.h. von 0 bis 3 for (size_t j = 0; j < (sizeof(ledPwm)/sizeof(ledPwm[0])); ++j) { ledPwm [j].led(4096,0,0); delay(50); } }[/c]
potentielle Fehlerquelle, ins besondere wenn man was ändern muss. [c] const size_t anzahlLED = sizeof(led_lut)/sizeof(led_lut[0]); [/c] So könntest du die "<= 17" durch "< anzahlLED" ersetzen, und bräuchtest dich nicht zu kümmern, wenn eine LED hinzugefügt oder weg genommen wird. Was allerdings
-
Thread
sizeof mit strukt und padding.
finde deine Einstellung etwas komisch. Legst Du auch erst einen int-Pointer an, und wendest darauf sizeof an, oder wendest du sizeof direkt auf int an? [c] int *ptr; ptr = malloc(sizeof(*ptr)); ptr = malloc(sizeof(int)); [/c] Mag geschmackssache sein. Soll also jeder machen, wie er mag. :)
deine Einstellung etwas komisch. Legst Du auch erst einen > int-Pointer an, und wendest darauf sizeof an, oder wendest du sizeof > direkt auf int an? > int *ptr; > ptr = malloc(sizeof(*ptr)); > > ptr = malloc(sizeof(int)); > > Mag geschmackssache sein. Soll also jeder machen, wie er mag. :
-
Thread
Bestimmte Zeichen aus String entfernen? GCC
) { char str [] = "Gutenxxx Tagxxx"; printf ("Vorher : %s\n", str); str [remove_2 (str, sizeof (str))] = 0; printf ("Nachher: %s\n", str); }[/c]
-
Thread
Führende Nullen unterdrücken wenn == 0
was er sucht. [c] char *itoa(int val, char *s, int radix) { unsigned int u; char buf[1 + sizeof(val) * 8 + 1]; char *p; int sign = 0; if ((radix < 2) || (radix > 36)) { s[0] = 0; return (s); } u = val; /* assume positive */ buf[sizeof(buf) - 1] = 0; p = &buf[sizeof(buf) - 2]; /* last character position */ if (radix == 10 && (int) u < 0) { sign++; u = -u; } while (1) { *p = (u % radix) + '0'; if (*p > '9') *p += 'a'-'0'-10;
-
Thread
STM32 F103 - I2C Probleme
habe ich erfolglos schon folgende Befehle: [c] HAL_I2C_Master_Transmit(&hi2c1, 0x3C, outbuffer, sizeof(outbuffer), 1); HAL_I2C_Mem_Write(&hi2c1, 0xA0, 0x1AAA, I2C_MEMADD_SIZE_16BIT, (uint8_t*)wmsg,strlen(wmsg)+1, HAL_MAX_DELAY);[/c] I2C Port ist in CubeMX auf Standard und auf Pin PB6 und PB7 eingestellt
So in etwa. [c] HAL_I2C_Master_Transmit(&hi2c1, 0x3C, outbuffer, sizeof(outbuffer), 1); [/c] wird zu: [c] HAL_I2C_Master_Transmit(&hi2c1,(uint16_t)0x3C,(uint8_t*)outbuffer,sizeof(outbuffer),1); [/c]
-
Thread
Matlab - Mikrocontroller - serielle Schnittstelle
UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); sei(); while(1) { uart_gets (Line, sizeof(Line)); uart_puts(Line); uart_puts( "\n" ); } }[/c] In Matlab hab ich bis jetzt folgendes eingetippt: [c] clc close all; clear all; // Aktive Ports löschen delete
Steff G. schrieb im Beitrag #5300497: > while(1) > { > uart_gets (Line, sizeof(Line)); > > uart_puts(Line); > uart_puts( "\n" ); > } Du lässt vom uC lauter leere Zeilen zurücksenden, wenn nicht gerade ein Zeichen reinkommt... Da wundert es nicht, wenn beim Empfänger
-
Thread
Maussensor PMW 3310 firmware (ASCII - textfile) einspielen
sehr gut per Block Edit. "const" nicht vergessen, sonst landet der Kram im RAM. Grösse bekommst per sizeof(). Dann durch den SPI (ggf. DMA) in den Sensor klappern. VG, /th.
stimmt :-) [c] const char image[] = { ... } int elements = sizeof(image) / sizeof(image[0]); [/c]
-
Thread
Problem bei C++ Programmcode
dass er das hier kann. Es wird also nur ca. 1 Pointer + 2 Integer kopiert- genau genommen das was sizeof(vector<...>) zurück gibt.
-
Thread
Font in SPI Flash schreiben
for(count=0;count<sizeof(Arial_8x13_Table)/255;count++) { df_write((uint8_t*)&Arial_8x13_Table[count*255],255); df_write_close(); } df_write( (uint8_t*)&Arial_8x13_Table[count*255],sizeof(Arial_8x13_Table
for(count=0;count<sizeof(Arial_8x13_Table)/255;count++) { df_write((uint8_t*)&Arial_8x13_Table[count*255],255); df_write_close(); } df_write( (uint8_t*)&Arial_8x13_Table[count*255],sizeof(Arial_8x13_Table
-
Thread
STM32 i2c MCP23017 keine Kommunikation
[]={1,2}; HAL_I2C_Master_Transmit(&hi2c2,(uint16_t)(MCP_I2C_ADDR<<1 | MCP_I2C_W),(uint8_t*)data,sizeof(data),10); [/c]
-
Thread
Größe von einem "struct Array" bestimmen?!
"Neustart" ,3}, {"Exit" ,4}, }; void test(menue_t *m) { printf("%d",sizeof(m) / sizeof(m[0])); } [/C]
Rufus Τ. F. schrieb im Beitrag #5293242: > Ja. Mit einem simplen Macro: > #define MENUEANZAHL ((sizeof mainMenue) / sizeof menue_t) Ich würde diese Schreibweise wählen: #define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof((array)[0])) Aber das ist eine Feinheit.
-
Thread
CANopen - Datenlogger
rfilter[0].can_mask = 0x1FFFFFFF;; ... setsockopt(iSock, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter)); ... read(iSock, &frame, sizeof(frame)) Als CANopen Übertragungstyp für die Sensoren habe ich "Ereignisgesteuert + zyklisch" eingestellt (=255). Ist das die richte Methode um Sensoren
-
Thread
elm-chan FatFS 2 Dateien in 2 Ordnern gleichzeitig benutzen
logs"); res= f_open(&Fwrt, "log1.txt", FA_CREATE_ALWAYS | FA_WRITE); res= f_write(&Fwrt, zeile1,sizeof(zeile1)-1, &cnt); // res = f_chdir("/de"); // Verzeichnis wechseln // res= f_write(&Fwrt, zeile2,sizeof(zeile2)-1, &cnt); res= f_close(&Fwrt); //----------------------------------------------
-
Thread
FatFs mit Fifo Bibliothek von Falk Brunner, Fifo behält trotz Auslesen und read_bursted Restdaten.
} } } } int main(){ [...] fifo_init(&fifo, fifo_bufferarray,sizeof(fifo_bufferarray)/sizeof(fifo_data_t)); uint16_t fifo_wrap_size; uint16_t fifo_block_size=fifo_writesize; while(1){ [...] // Normaler Schreibvorgang auf SD Karte if(SDcard_ready
operation f_write(&file1, (uint8_t*)fifo.read_p, rest_size * sizeof(fifo_data_t), &fatfs_bytes_written); fifo_read_bursted(&fifo, fifo_block_size); // Anm.: hier dann natürlich ebenfalls rest_size f_sync(&file1); } [/c] > > Kleiner Tip. Die Sequenz
-
Thread
Lesbarer ProgrammCode
uint8_t *mem_1 = malloc(10); /* do fancy stuff */ uint16_t *mem_2 = alloc(23 * sizeof(uint16_t)); /* do fancy stuff */ uint32_t *mem_3 = malloc(47 * sizeof(uint32_t)); /* do fancy stuff */ int ret_val = 0; if ( mem_1 == NULL ) ret_val = -
1 == NULL) { return -1; } /* do fancy stuff */ mem_2 = malloc(23 * sizeof(uint16_t)); if (mem_2 == NULL) { free(mem_1); return -2; } /* do fancy stuff */ mem_3 = malloc(47 * sizeof(uint32_t)); if (mem_3 == NULL) {
-
Thread
Pointer in Funktion inkrementieren - Adress Frage
kannst aus a[10] oder *b nicht erkennen, ob a oder b jeweils Pointer oder Array ist. Aber beim sizeof, inkrement, Adressoperator, als Zuweisungsziel ist es ein großer Unterschied.
-
Thread
Einflußfaktoren zur Rechendauer bei Divisionen
COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int* rem) { const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT; const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT; udwords n; n.all = a; udwords d; d.all = b; udwords q; udwords r; unsigned sr;