-
Thread
unaligned acces bei einem imx6q
code] int main(int argc, char **argv) { long long i, temp, number=10; char *ptr = malloc(sizeof(long long) * number+1); long long *unaligned = (long long *)&ptr[2]; for(i = 0; i < number; i++) temp = unaligned[i]; return(0); } [/code] Int Variante ============= [code] int main(int argc, char **argv) { int i, temp, number=10; char *ptr = malloc(sizeof(int) * number+1); int *unaligned = (int *)&ptr[2]; for(i = 0; i < number; i++) temp = unaligned[i]; return(0); } [/code]
-
Thread
Mega32 schaltet, ohne ein Signal zu bekommen
menuPoint *initMenu() { // Hauptmenue struct menuPoint *tlMenu = (struct menuPoint *) malloc(3 * sizeof(struct menuPoint)); // Menue zum Einstellen der Glasgroesse struct menuPoint *glassSizeMenu = (struct menuPoint *) malloc(3 * sizeof(struct menuPoint)); // Menue zur Cocktailauswahl struct menuPoint *cocktailMenu = (struct menuPoint *) malloc(3 * sizeof(struct menuPoint)); // Menue Impressum struct menuPoint *imprint = (struct menuPoint *) malloc(sizeof(struct menuPoint)); /* * Glasgroesse */ // kleines Glas glassSizeMenu
-
Thread
Simpeles Menü - Denkfehler
menu_text[]= { "Spuelen", "Spueldauer", "Test2", "Test3", "Exit", " "}; #defien MENU_SIZE ( sizeof(menu_text) / sizeof(*menu_text) ) [/C] Dann brauchst du dir auch nicht den Wolf zählen, wieviele Einträge du wirklich hast. Das erledigt dann der Compiler für dich. Versuch immer, Wissen aus
menu_text[]= { "Spuelen", "Spueldauer", "Test2", "Test3", "Exit" }; #define MENU_SIZE ( sizeof(menu_text) / sizeof(*menu_text) ) #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif .... menu_index = 0; menu_tmp = 100; menuOnScreen = TRUE; while(1) { //
-
Thread
STM32 Struct ins Flash
set_in_Flash(tSetup2 *setup) { uint32_t *pData = (uint32_t *)setup; uint8_t i; int x = (sizeof(tSetup2) / sizeof(int)); FLASH_Unlock(); FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); FLASH_ErasePage(FLSHBSEADRPG192); for(i=0;i<x;i++) { FLASH_ProgramWord(FLSHBSEADRPG192 + i*sizeof(uint32_t), pData[i]); } FLASH_Lock(); } [/c] Kann mir jemand diese Zeile erklären?: [c] FLASH_ProgramWord(FLSHBSEADRPG192 + i*sizeof(uint32_t), pData[i]); [/c] Warum pData[
-
Thread
unterschiedliche Datentyp über einer Variable auslesen
main() { int value; char Command[20]; while(1) { fgets(Command, sizeof(Command), stdin); if (0 == strcmp(Command, "pain\n")) { valeur.pain = VALEUR_PAIN; value = valeur.pain; } else if (0 == strcmp
{ struct tval tval; char Command[20]; while(1) { fgets(Command, sizeof(Command), stdin); if (0 == strcmp(Command, "pain\n")) { tval.typ = TVAL_FLOAT; tval.val.f = VALEUR_PAIN; } else if (0 == strcmp(Command
-
Thread
Teilstring aus String auswählen und in neuen string kopieren, AVR
denn "svn" und "src" existieren, dann benötigst du den Abstand als ein abgerundetes Vielfaches von sizeof(uint16_t)? Dein Nachfolgender Code sieht eher so aus, als ob du den Abstand in char benötigst. > branchStr[50] = Das ist das 51. Zeichen. Du hast aber nur 50 Zeichen definiert. > return
reinsoll, zusammen mit einer expliziten Information, wie lang der übergebene Speicherbereich ist. Sizeof funktioniert nicht mit arrays, die an FUnktionen übergeben werden, daher die explizite Längenangabe. Vorteil: Wenn mehrere Stellen die Funktion aufrufen, kriegen sie alle ihr Ergebnis korrekt.
-
Thread
Serialports in Win32 App finden
port) { char buffer[7]; COMMCONFIG CommConfig; DWORD size; snprintf( buffer, sizeof buffer, "COM%d", port); size = sizeof CommConfig; return (GetDefaultCommConfig(buffer, &CommConfig, &size) || size > sizeof CommConfig); } for (int i=1; i<256; i++) { if (COM_exists
-
Thread
C++ Udp Broadcast empfangen und antworten
string recv; char *ip; setsockopt(s, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof broadcast); memset(&si_me, 0, sizeof(si_me)); si_me.sin_family = AF_INET; si_me.sin_port = htons(port); si_me.sin_addr.s_addr = INADDR_ANY; assert(::bind(s, (sockaddr *)&si_me, sizeof(sockaddr))!=-1); while(1) { char buf[10000]; unsigned slen=sizeof(sockaddr); recvfrom(s, buf, sizeof(buf)-1, 0, (sockaddr *)&si_other, &slen); recv = buf; ip = inet_ntoa(si_other.sin_addr); if(recv.compare("HELLO DEVICE") == 0){
-
Thread
Samd21 (Adafruit Feather or Cortex M0 Mini board) mit NRF24L01 funktioniert nicht
{ // While there is data ready radio.read( &got_time, sizeof(unsigned long) ); // Get the payload } radio.stopListening(); // First, stop listening so we can talk radio.write( &got_time, sizeof(unsigned long) ); // Send the final one back. radio.startListening(); // Now, resume listening so we catch the next packets.
-
Thread
Xilkernel message queue problem
Korrekt wäre wohl #define RXMSGQ_SIZE (sizeof(struct _rxmsgq)) Es ist gesagt, dass der Compiler die 2 chars unbedingt nebeneinander packt. Außerdem : Es hat zwar mit deinem Problem nichts zu tun, aber Bezeichner mit _ sollte man nicht
laut Konvention für > implementierungsinterne Dinge reserviert. danke für die antwort! mit sizeof() ist das natürlich am einfachsten gemacht! danke und lg martin
-
Thread
Problem SDfat - Ende der Datei finden
> if (daten.fgets(line, sizeof(line)) < 0) { Bist du sicher das da ein negativer Wert zurück kommt wenn keine Daten mehr da sind? Eine Null würde es auch tun.
) { pos = daten.curPosition(); daten.seekSet(pos-1); if (daten.fgets(line, sizeof(line)) < 0) { Serial.print("Line not found"); } Serial.print("Testausgabe"); Serial.print(line); }
-
Thread
Mit RS232 und msp430F5529 senden und empfangen
interrupts ... } #pragma vector=USART0_A0_VECTOR __interrupt void USART0_A0_TX (void) { if (i < sizeof answer1-1) // string schon zu ende? UCA0TXBUF = answer1[i++]; // string ausgeben else if (i == sizeof answer1-1) // wenn erster string zu ende ...
; // ... dann den getippten buchstaben ausgeben i++; } else if (j < sizeof answer2-1) // wenn auch der ausgegeben ist ... UCA0TXBUF = answer2[j++]; // ... dann den zweiten string ausgeben } #pragma vector=USART0_A0_VECTOR __interrupt void
-
Thread
epoll() für "Interrupts" bei Embedded Linux GPIOs bei fallender Flanke?
blocking!! Also extra thread oder process! { int_fast8_t ret = 0; int val = 0; size_t size = (sizeof(char) * (strlen ("/sys/class/gpio/gpio") + strlen ("/value") + strlen (gpionum) + 1)); char * Target2 = (char *) malloc (size); while (Target2 == NULL) { printf ("No space
blocking!! Also extra thread oder process! { int_fast8_t ret = 0; int val = 0; size_t size = (sizeof(char) * (strlen ("/sys/class/gpio/gpio") + strlen ("/value") + strlen (gpionum) + 1)); char * Target2 = (char *) malloc (size); while (Target2 == NULL) { printf ("No space
-
Thread
Gleitkommazahlen im EEPROM speichern
Auslesen könntest du über Zeiger (hier double): [c] Lesefunktion(&Double_Variable,(uint8_t*)0,sizeof(double)); [/c] und schreiben so: [c] Schreibfunktion(&Double_Variable,(uint8_t*)0,sizeof(double)); [/c] In Lese- und Schreibfunktion werden die Bytes ab der dort angegeben Startadresse aus
-
Thread
qsort array funktioniert nicht
getNumberOfArrayElements(result2); array_[2] = getNumberOfArrayElements(result3); int8_t size = sizeof(array_) / sizeof(array_[0]); qsort((void*)array_, size, sizeof(array_[0]), comparator); return array_[0]; } [/c]
-
Thread
Eprom verwendung
eeprom_def_Rel_auto_mask); eeprom_busy_wait (); eeprom_read_block (IO_Feld, eeprom_def_IO_Feld, sizeof(IO_Feld)); } else { nop(); } } [/c] Wenn ich die Speierung von IO_Feld weg lasse funktioniert alles soweit, erst wenn ich IO_Feld ins eprom schreibe überschreibt er glaube
schreiben(void) { eeprom_busy_wait (); eeprom_update_block (IO_Feld, eeprom_def_IO_Feld, sizeof(IO_Feld)); eeprom_busy_wait (); eeprom_update_byte(&eeprom_def_EEProm_beschrieben, 1); eeprom_busy_wait (); eeprom_update_word(&eeprom_def_Rel_out_mask, Rel_out_mask); eeprom_busy_wait
-
Thread
MSP430 Probleme mit UART und Hyperterminal
interrupts ... //_BIS_SR(GIE); } interrupt (UART1TX_VECTOR) usart1_tx(void) { if (i < sizeof answer1-1) // String zu Ende? TXBUF1 = answer1[i++]; // String ausgeben else if (i == sizeof answer1-1) // wenn erster string zu ende ... { TXBUF1
// ... dann den getippten buchstaben ausgeben i++; } else if (j < sizeof answer2-1) // wenn auch der ausgegeben ist ... TXBUF1 = answer2[j++]; // ... dann den zweiten string ausgeben } interrupt (UART1RX_VECTOR) usart1_rx(void) { { i
-
Thread
Optimierung von Funktionen
pResultCount) { int* ptr; bool valueExisting; *pResultCount = 0; ptr = (int*)calloc(count, sizeof(int)); ptr[*pResultCount] = values[0]; (*pResultCount)++; if (count >= 1) { for(size_t x=1; x<count; x++) { valueExisting = false; for (size_t y=0; y<*pResultCount
= uniqueIndex; } int main() { int values[] = {1, 1, 1, 2, 3, 0, 2}; size_t count = sizeof(values) / sizeof(values[0]); removeDuplicates(values, &count); // Hier können Sie auf die eindeutigen Werte in 'values' zugreifen // und die Anzahl der eindeutigen Werte ist in '
-
Thread
MAX7219: einzelne LED ansteuern
auf das ich das damals mit enum gemacht habe. Funktioniert zwar hier, nur leider kann man nicht sizeof anwenden. Deswegen habe ich das etwas modernisiert und möchte das noch zeigen. Dann kann man die Anzahl der Digits automatisch ermitteln lassen und überall verwenden. Man darf nur nicht im struct die
MATRIX.segment.DP}, // LED 30 {MATRIX.digit.D2, MATRIX.segment.DP} // LED 31 }; const byte ANZAHL_LED = sizeof(LED) / sizeof(Led); const byte ANZAHL_DIGIT = sizeof(MATRIX.digit); [/c] So, genug gequatscht. :-)
-
Thread
C++ If else oder return?
struct bla* create_bla(int x){ > if(x < 0) > goto error; > > struct bla* bla = malloc(sizeof(struct bla)); > if(!bla) > goto error; > > if(init_bla_bla(bla) == -1) > goto error_after_malloc; > > if(do_bla_bla(bla, x) == -1) > goto error_after_init_bla_bla; >
x){ struct bla* blabla; if(x < 0) { blabla= NULL; } else { blabla= malloc(sizeof(struct bla)); if(blabla) { if(init_bla_bla(blabla) == -1) { free(blabla); blabla= NULL; } else if(do_bla_bla(blabla, x) == -1) { cleanup_bla_bla
-
Thread
Pointer nach Rückkehr aus Funktion null?
Standardwert für Zeiger die auf nichts zeigen (nicht 0!= void function (int * b) { b = malloc (sizeof(int)); } ... function (a); [/c] Auch wenn die Funktion gleich aussieht, tritt hier das selbe Problem auf, das wie folgt formuliert werden kann: Alle Werte innerhalb einer Funktion haben
möchte. Also so etwas wie int * a = NULL; void function (int * & b) { b = malloc(sizeof(int)); } function ( a); Das erspart 'Stern' und 'Und'. Statt gcc einfach g++ eintippen, und schon mag der Compiler das.
-
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
eeprom_write_block überschreibt andere Daten
; // führt zur Ausgabe: 200,8274 cli(); eeprom_write_block(&ee_foo_array,c_foo_array,sizeof(c_foo_array); sei(); } void LoadEEPROMParameters() { cli(); c_foo_word = eeprom_read_word(&ee_foo_word); sei(); } [/c] Führe ich nun die Load-Funktion aus, hat c_foo_word den
ee_foo_array[16] EEMEM = { /*16 Zahlen*/ }; > ... > eeprom_write_block(&ee_foo_array,c_foo_array,sizeof(c_foo_array); ^ Kontrolliere bzw. korrigiere das &. Näheres siehe AVR-GCC-Tutorial. Die Zeile müsste auch im Compiler einen Syntaxfehler erzeugen, weil eine schliessende
-
Thread
JSON parsen mit AVR
irgendwie? [c]static const char MyCommand[] = "Command"; static const size_t MyCommandSize = sizeof(MyCommand); static const size_t MyCommandLength = sizeof(MyCommand) - 1; // == strlen(MyCommand)[/c] Damit kannst du alle Magic Numbers erschlagen, auch die Strings selbst. Ich empfehle die Variablen
irgendwie? > static const char MyCommand[] = "Command"; > static const size_t MyCommandSize = sizeof(MyCommand); > static const size_t MyCommandLength = sizeof(MyCommand) - 1; // == > strlen(MyCommand) > Damit kannst du alle Magic Numbers erschlagen, auch die Strings selbst. > Ich empfehle die
-
Thread
EEPROM: was mache ich denn jetzt falsches?
eepromData test; struct eepromData eeTest[1] EEMEM; int main() { memset((&test), '\0', (sizeof(test))); eeprom_read_block(&test, &eeTest[0], sizeof(test)); memset((&test.str), '\0', (sizeof(test.str))); itoa(test.number, test.str, 10); test.number++; eeprom_write_block(&test, &eeTest[0], sizeof(test)); } [/code] Ich habe eine Datei angelegt mit alle 0x00 (also, 512 Bytes = 0). Ich schreibe diese Datei in die EEPROM mit: avrdude -pm8 -cstk500v2 -P/dev/ttyACM0 -U eeprom:w:test.eeprom
-
Thread
Mehrfachabfrage mit if und else oder besser?
int a = 0; printf("Eingabe: "); a = getchar() - '0'; for(int i = 0; i < (int)(sizeof(i2c) / sizeof(Int2Code_t)); ++i) { if( i2c[i].z == a ) { printf("Ergebnis: %d\n", i2c[i].p(a)); } } return 0; } [/c] Wenn Deine Variable "a" mehr oder
int a = 0; printf("Eingabe: "); a = getchar() - '0'; if(a >= 0 && a < (int)(sizeof(i2c) / sizeof(Funptr_t))) { printf("Ergebnis: %d\n", i2c[a](a)); } return 0; } [/c]
-
Thread
C++ Amp Matrix Multiplikation vs MatLab
[c] A_SUB = (double*)mkl_malloc(m * k * sizeof(double), 64); B_SUB = (double*)mkl_malloc(k * n * sizeof(double), 64); C_SUB = (double*)mkl_malloc(m * n * sizeof(double), 64); count = 0; for (int i = 0; i < m; i++) {
-
Thread
Spannungsversorgungs Probleme!
Druck: "); Serial.println(m.pressure); // byte array for sending data uint8_t payload[sizeof(struct Messung)]; // copy struct of measurement to byte array for sending memcpy(payload,&m,sizeof(m)); Serial.println("Sending to rf24_reliable_datagram_server"); // Send a message to manager_server if (manager.sendtoWait(payload, sizeof(payload), SERVER_ADDRESS)) { // Now wait for a reply from the server uint8_t len = sizeof(buf); uint8_t from; if (manager.recvfromAckTimeout(buf, &len, 2000, &from))
-
Thread
I2C Bus mit dem Attiny 841
Null ist, ist ein Master-Schreibvorgang im Gange. { if(tx_buf_index >= sizeof(tx_buf)) // ???? { // ???? tx_buf_index=0; // ???? } // ???? TWSD = tx_buff; // Sendepuffer vom Slave zum Master
Null ist, ist ein Master-Schreibvorgang im Gange. { if(tx_buf_index >= sizeof(tx_buf)) // ???? { // ???? tx_buf_index=0; // ???? } // ???? TWSD = tx_buff; // Sendepuffer vom Slave zum Master
-
Thread
Raisonance vergibt nun RIDE + RKIT-51 Lizenzen kostenlos
__ was eine Unterscheidung zwischen Keil und Raisonance komplizierter macht. 2. Verhalten von sizeof() bei fixen Arrays im Flash [c] const uint8_t CODE VendorDesc[170] = { 10,0, // wLength 0,0, // header 0,0,3,6, // OS #ifdef __RC51__ 170,0, #else sizeof (VendorDesc) & 0xFF, sizeof (VendorDesc) >> 8, #endif 8,0, 2,0, // MS_OS_20_SUBSET_HEADER_FUNCTION ..... [/c] Codegrößen bei meinem Testprogram:
-
Thread
ARM-GCC/AVR-GCC: Type punning
__attribute__((packed)) edm_diag_t; volatile edm_diag_t gls_edm_diag; static_assert(sizeof(edm_diag_t)==2,"miscalulated size"); [/c] verschwindet auch das Warning zum type-punning, das der ganze Auslöser von der Frage war.
attribute__((__may_alias__)) edm_diag_t; volatile edm_diag_t gls_edm_diag; static_assert(sizeof(edm_diag_t)==2,"miscalulated size"); [/c] Wenn ich aus dem "unsigned int" einen "unsigned char" mache, stimmt die Größe wieder.
-
Thread
SPI.transfer übermittelt nur einmal Array Inhalt
51200); //spi.unlock(); spi.frequency(30'000'000); //spi.write((const char*)array,sizeof(array), nullptr, 0); spi.write(0xff0f); [/c]
SPI_SCK); spi.frequency(62'500'000); spi_write_blocking(spi0, (const uint8_t*) test_buffer, sizeof(test_buffer)); // Pico SDK [/c] damit werden die 10 kB in 1,562 ms rausgehauen, also mehr also doppelt so schnell, das lohnt sich dann also schon.
-
Thread
Float-Wert in eine Datei speichern?
fwrite(fp, &float_wert, sizeof (float_wert)); fp ist der File-Pointer, den bekommst du von fopen.
wurde vermutlich für jede einzeln ausgewürfelt. > Richtig heißt es: > fwrite(&float_wert, 1, sizeof(float_wert), fp); Streng genommen eigentlich: [C] fwrite(&float_wert, sizeof(float_wert), 1, fp); [/C] Der zweite Parameter gibt die Größe eines Wertes an, der dritte, wieviele Werte geschrieben
-
Thread
ENC28J60 - sendet nichts
nochmal als Auszug: [c] void InterruptHandler() { unsigned length = enc28j60PacketReceive(sizeof(ethernet_buffer), ethernet_buffer); if (length) { struct Ethernet_Header *ether = (struct Ethernet_Header *)ethernet_buffer; if (ether->EnetPacketType == 0x0608) // ARP {
BuildARPReplyFrame(ethernet_buffer, remote_mac, remote_ip); enc28j60PacketSend(sizeof(struct Ethernet_Header) + sizeof(struct ARP_Header), ethernet_buffer); // <--- paket kommt nie an [/c] MfG Paketstapel
-
Thread
Strings zu einem zusammenfügen
ermitteln. Das ist die Größe des Zielarrays! In deinem Fall also: strncat( Enddata, data, sizeof(Enddata) ); Und warum kriegst du dann Zeichensalat? Ganz einfach: Was macht strncat, wenn der Platz im Zielarray nicht reicht? Simpel: es hört auf umzukopieren. Aber gemeinerweise schliesst strncat
9.9999"? dtostrf(sensor_value[i], 6, 4, tmp_string); strncat(final_string, tmp_string, sizeof(final_string); strncat(final_string, "; ", sizeof(final_string)); } rf12_txdata(final_string, strlen(final_string)); for(pause=1000; pause; pause--) _delay_ms(1); }
-
Thread
invalid conversion from 'const char*' to 'char' [-fpermissive]
bmpFile.position() != pos) { // Need seek? bmpFile.seek(pos); buffidx = sizeof(sdbuffer); // Force buffer reload } for (col=0; col<w; col++) { // For each pixel... // Time to read more pixel data? if (buffidx >= sizeof(sdbuffer)) { // Indeed bmpFile.read(sdbuffer, sizeof(sdbuffer)); buffidx = 0; // Set index to beginning } // Convert pixel from BMP to TFT format, push to display b = sdbuffer[buffidx++];
-
Thread
RS232: Geöffneter Port weder beschreib- noch lesbar (P5B)
to_check)); fprintf(stream, "Verify timeout paramters..."); check_err(!memcmp(&to, &to_check, sizeof(COMMTIMEOUTS))); fprintf(stream, "Write test string..."); check_err(WriteFile(hCom, strTest, strlen(strTest), &dwEaten, (LPOVERLAPPED)NULL)); fprintf(stream, "All characters written? .
strlen(strTest)); fprintf(stream, "Reading COM port..."); check_err(ReadFile(hCom, inBuf, sizeof inBuf, &dwEaten, (LPOVERLAPPED)NULL) && dwEaten>0); fprintf(stream, "Read from COM port: \"%*s\"", dwEaten, inBuf); fprintf(stream, "\n\nDone!\n\n"); CloseHandle(hCom); if(stream
-
Thread
Datei lesen und Werte in Struct übernehmen
{ int file = open("datei.txt", O_RDONLY); struct header head; read(file, &head, sizeof(head)); /* Eventuell Nullbyte zur Sicherheit einfügen: */ head.name[5] = 0; close(file); printf("Name: %s\n", head.name); return 0; }
( int nargs, char **args ) { printf( "%d\n", sizeof(struct header) ); return 0; } [/c] Ergebnis: 12 Byte D.h., daß du *in diesem einen Fall* die Warnungen in den Wind schlagen kannst und einfach mit fread aus der Datei in die struct lesen
-
Thread
raw socket - tcp checksum fehler
; /** *set a socket option */ if(setsockopt(rawsock, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0){ perror("setsockopt()"); exit(1); } /** *initialize paket */ memset(&paket, 0, sizeof(struct hdr)); /** *create IP Header */ .... paket.ip.check
MSG_LENGTH); paket.tcp.check = compute_checksum((uint16*)&Pseudo, MSG_LENGTH + sizeof(struct tcphdr) + sizeof(struct pseudohdr)); /** *now the paket is sent */ se = sendto(rawsock, &paket, sizeof(struct hdr), 0, (struct sockaddr*)&addr, sizeof(struct sockaddr_in
-
Thread
MP3 VS1053 gibt merkwürdiges rauschen mit dem Sound aus
dann etwa so aus: [c] if(buffSelect == 1) { rc = f_read(&fil, buff1, sizeof(buff1), &br); /* Lese 4096Bytes */ if (rc || !br) break; /* Error or end of file */ buffSelect = 5; //Buffer1 ist voll } if(buffSelect == 2) { rc = f_read(&fil, buff2, sizeof(buff2), &br); /* Lese 4096Bytes */ if (rc || !br) break; /* Error or end of file */ buffSelect = 4; //Buffer2 ist voll } while(!VS_DREQ_CHECK()); //Warte bis
-
Thread
STM32 FreeRTOS UART Empfangsproblem
Fill", 256, NULL, 1 , NULL ); // Hier Queues erstellen hSerialTx = xQueueCreate( 260, sizeof( uint8_t ) ); hSerialRx = xQueueCreate( 260, sizeof( uint8_t ) ); hUSART1_tx = xQueueCreate( 256, sizeof( uint8_t ) ); hUSART1_rx = xQueueCreate( 256, sizeof( uint8_t ) ); xdata = xQueueCreate (20, sizeof( uint8_t )); } // Hier scheduler starten vTaskStartScheduler(); } [\c] Ich habe keine Ahnung wo der Fehler liegt. Ich nutze die heap2.c, kann es da irgendwie zu einem
-
Thread
Implementierung eines Zustandreglers mit Beobachter
serial_data[3]=(serial_data[0] + serial_data[1] + serial_data[2]) & 0x7F; Serial1.write(serial_data, sizeof(serial_data)); } void set_speed_m1_m2(long speedM1, long speedM2) { byte ab[11]; ab[0] = address; ab[1] = 37; ab[2] = (speedM1 >> 24) & 0xff; ab[3] = (speedM1 >> 16) & 0xff; ab
10] = (ab[0]+ab[1]+ab[2]+ab[3]+ab[4]+ab[5]+ab[6]+ab[7]+ab[8]+ab[9]) & 0x7f; Serial1.write(ab, sizeof(ab)); } void read_current_distance_m1() { byte ab[2]; ab[0] = address; ab[1] = 16; Serial1.write(ab, sizeof(ab)); delay(10); byte distanceM1_byte[4]; // send data only
-
Thread
Frage zur C-Progrrammierung auf Mikrocontroller
int wert) { static int array[200]; static unsigned char index = 0; ... if (index >= (sizeof (array) / 2)) ; // Fehlerbehandlung else array[index++] = wert; ... } [c]
static schrieb im Beitrag #3615066: > if (index >= (sizeof (array) / 2)) wenn schon denn schon: [c] if (index >= (sizeof (array) / sizeof(array[0]))) [/c]
-
Thread
Zugriff auf Compact flash
{ sysace_fwrite (buffer , 1 , sizeof(buffer) , fstream_write); } sysace_fclose (fstream_write); print(" -- Datei schliessen -- \r\n"); void *fstream; /* A pointer to our file */ char data[50]; /* A buffer to read
in read only mode */ print(" -- Datei oeffnen nur lesen -- \r\n"); sysace_fread(data,1,sizeof(buffer2),fstream); /* Read SIZE_OF_DATA_BUFFER bytes into the buffer */ for (n=0; n<sizeof(buffer2); n++) { xil_printf("%c", data[n]); } print("\r\n");
-
Thread
[C++] Template in der Template Spezialisierung
val; matvar_t* var = Mat_VarRead(matfp, name.toStdString().c_str()); if (var->data_size == sizeof(T) && var != NULL) memcpy(&val, var->data, var->data_size); Mat_VarFree(var); return val; } [/c] Für das Lesen anderer Datentypen habe ich mir eine Spezialisierung erstellt, wie
Segmentation Violation abbrechen. So wäre es richtig: [C] if ( var != NULL && var->data_size == sizeof(T) ) ... [/C] oder auch: [C] if ( var && var->data_size == sizeof(T) ) ... [/C]
-
Thread
Wert in Matrix ablegen
. So wird oft auf ganze 32 bit Worte aufgerundet. Testweise koennte man sich zum Beispiel mal sizeof(a), sizeof(b) und sizeof(c) ausgeben lassen. Normalerweise implementiert man so etwas mit Zugriffsfunktionen, die das entsprechende maskieren uebernehmen.
-
Thread
2. element im 2d array auf null setzen
man memset wieder nehmen, also: [c] char sign_letter[] = {'A', 'B', 'C', ...}; int sign_count[sizeof(sign_letter)/sizeof(*sign_letter)] = {0}; ... memset(sign_count, 0, sizeof(sign_count)); [/c] 1) https://en.wikipedia.org/wiki/Stride_of_an_array
memset(my_array+1, 0, COLS*sizeof(char)); puts(""); for(int i
-
Thread
Laufzeiten und GNU/Watcom C
und den Kram in die Strukuren laden Punkt 4. schwächelt. Die Größen der Strukuren gibt sizeof() gleich aus.
unwahrscheinlich (unmittelbar in main() ganz oben rufe ich das auf). gprof produziert schicht Unsinn. sizeof zeigt mir bei den verschachtelten Strukturen unter GCC und Watcom die gleiche Größe, das sollte passen.
-
Thread
USB: Verständnisfrage
suche, erhalte ich für die beiden Data-Endpoints folgendes: [c] .ep_in.bLength = sizeof(usb_ep_desc_t),\ .ep_in.bDescriptorType = USB_DT_ENDPOINT,\ .ep_in.bmAttributes = USB_EP_TYPE_BULK,\ .ep_in.bInterval = 0,\ .ep_out.bLength = sizeof(
beiden Bulk-Endpoints) als einziger noch definiert ist: [c] .ep_notify.bLength = sizeof(usb_ep_desc_t),\ .ep_notify.bDescriptorType = USB_DT_ENDPOINT,\ .ep_notify.bmAttributes = USB_EP_TYPE_INTERRUPT,\ .ep_notify.wMaxPacketSize = LE16(UDI_CDC_COMM_EP_SIZE),\ .ep_notify.bInterval