-
Thread
BMP von SDCard
if ( res == FR_OK ) { //WriteString(0,0,"bmp found",WHITE,RED); f_read(&fsrc, (u8 *)&bmp, sizeof(bmp), &br); if( (bmp.pic_head[0]=='B') && (bmp.pic_head[1]=='M') ) { res = f_lseek(&fsrc, ((bmp.pic_data_address_h<<16)|bmp.pic_data_address_l)); ty=bmp.pic_h_l;
-
Thread
stm32f103 exti
player den byte-transfer zum vs1053 über isr zu führen. [c]void read_file_exti(){ fileSize=(sizeof(vs_buffer)/32)*32;//rest wird zur Vereinfachung abgeschnitten pt_vs_buffer=fileSize+1; fat_res=f_open(&File[0], cur_fname, FA_OPEN_EXISTING | FA_READ); /* Create a file */ #if 01
Lesebedingung prüfen if(pt_vs_buffer>=fileSize){ fat_res = f_read(&File[0], vs_buffer, sizeof vs_buffer, &fat_bitct); /* Read a chunk of src file */ pt_vs_buffer=0; //2. fileende erreicht? if (fat_res || fat_bitct == 0){ //eof => close file f_close(&File
-
Thread
[c] Eine Funktion für verschiedene Listen
int mein_integer; double mein_array[17]; /* ... */ }; struct mein_item_t *a = malloc(sizeof(struct mein_item_t)); struct mein_item_t *b = malloc(sizeof(struct mein_item_t)); /* ... */ insert(a, b); [/c] Das spart dann halt eine Indirektion. Die glib macht das ziemlich exzessiv so.
-
Thread
variables Array in einer struct richtig initialisieren
dass du den eigentlichen Speicher dafür irgendwo in passender Größe per malloc() beschaffst. sizeof(struct) kannst du benutzen, um alles /außer/ dem flexible array zu bestimmen, d. h. wenn du 20 Elemente im Array hinter der eigentlichen struct haben willst, allozierst du [c]malloc(sizeof(struct xxx) + 20 * sizeof(array yy))[/c] Davon darfst du dann einen Typecast auf einen Zeiger auf die struct machen und nun auf den zusätzlichen Speicher am Ende typsicher zugreifen.
-
Thread
STM32F4 komplementär PWM Problem in ChibiOs
PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); while (true) { sdWrite(&SD2, (uint8_t *)"Hallo\n", 6); if (palReadPad(GPIOA, GPIOA_BUTTON)) sdWrite(&SD2, (uint8_t *)"Press\n", 6);
-
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
C, Mingw, UDP-Pakete, Startschwierigkeiten
= INADDR_ANY; if(setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq)) == SOCKET_ERROR) printf("setsockopt() error: %d\n", WSAGetLastError()); // try SYNC_LENGTH_SEC seconds to get any answer time_t timetotry = time(NULL)+SYNC_LENGTH_SEC;
fflush(stdout); // now socket is synced while(1){ // endless memset(buf, 0, sizeof(buf)); if(recvfrom(sock, buf, sizeof(buf), 0, NULL, NULL) == SOCKET_ERROR) printf("recvfrom() error\n"); if((buf[0] == 'M') || (buf[0] == 'N')) {// only M-SEARCH and
-
Thread
Seltsames Arduino Serial Read verhalten
" ->zu kurz, min. 17 Zeichen\"setdate2014/10/05\"")); memset(&serial_in_command[0], 0, sizeof(serial_in_command)); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); } memset(&serial_in_command[0], 0, sizeof(serial_in_command)); memset(&serial_in_buff[0], 0
[0], 0, sizeof(serial_in_command)); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); } } // if(strlen(serial_in_command)) [/c]
-
Thread
Zugriff auf Strukturelement über Index+"Zweig"
const description_t Descriptions; #define descPrintAstr(idx) descPrint(&Descriptions.a[0], sizeof(Description.a)/sizeof(desc_t), idx); [/c] und in der C-Datei steht [c] const desciption_t Descriptions = { .a = { { 0, "text1" }, { 1, "text2" }, { 2, "text3" }, { 3,
-
Thread
Debugging Hilfe
calloc(100,1); Passwort=calloc(100,1); [/c] Meep, falsch. Sollte nämlich besser calloc(100, sizeof(char*)) heissen, so wird nur 1/4 oder 1/8 des benötigten Speichers allokiert. Damit hast Du hier: [c] for(i=0;i<100;i++){ Benutzername[i]=calloc(20,1); Passwort[i]=calloc(20,1); }
-
Thread
C++ Zeiger auf Struktur inkrementieren?
Das Struct ist 2 Byte groß, da sizeof(uint16_t) = 2 ist. Das char-Array dahinter ist ja leer. Das folgende Struct belegt 11 Byte: [c] typedef struct { uint16_t index; uint8_t data[9]; } my_struct_t; [/c]
Slippin J. schrieb im Beitrag #4869170: > Das Struct ist 2 Byte groß, da sizeof(uint16_t) = 2 ist. Das char-Array > dahinter ist ja leer. > > Das folgende Struct belegt 11 Byte: > > [c] > typedef struct { > uint16_t index; > uint8_t data[9]; > } my_struct_t
-
Thread
Hilfe die Zeiger kommen !
ist mit der Länge sizeof(struct eeprom_giess). Hast du das gemeint?
ergäbe p1+1 dann 9. Bei uint32_t *p2 mit der Annahme p2==8 ergäbe p2+1 dann 12. Das mit dem sizeof brauchste bei malloc, etwa um auf einen uint32-t-Pointer 5 uint32_t zu allozieren: uint32_t *p3; p3 = malloc(5 * sizeof(uint32_t));
-
Thread
EEPROM Speicher Verwaltung
benötigt. Da musst Du eine Schleife aufbauen, die Erkennt wie viele Bytes deine Struktur groß ist (sizeof(EE_Data)).
-
Thread
String-Array und malloc
dann mit str=realloc(str,strlen(str)+1) auf den wirklich benötigten Speicher kürzen. Das malloc(sizeof(char*)*laenge)ist übrigens Unsinn, da du nicht Länge mal Zeiger auf Char brauchst, sondern Länge+1. sizeof(char) ist 1, deshalb kannst du es weglassen, und 1 Byte brauchst du noch für das Nullbyte
str=realloc(str,strlen(str)+1) auf den > wirklich benötigten Speicher kürzen. > > Das malloc(sizeof(char*)*laenge)ist übrigens Unsinn, da du nicht Länge > mal Zeiger auf Char brauchst, sondern Länge+1. sizeof(char) ist 1, > deshalb kannst du es weglassen, und 1 Byte brauchst du noch für das
-
Thread
433 MHz Rf Sendermodul
Variablen. Für den Sender habe ich den Code genommen: .... void loop() { vw_send((uint8_t*)&hal, sizeof(hal)); vw_wait_tx(); delay(1000); } So wie ich das verstanden habe kann ich, um eine Variable zu versendenl, mit &x ,sizeof(x) einfacher vorgehen als ein Char zu konvertieren ?! Doch im Seriellen-Monitor
>So wie ich das verstanden habe kann ich, um eine >Variable zu versendenl, >mit &x ,sizeof(x) einfacher vorgehen als ein Char >zu konvertieren ?! Ja und nein. >Doch im Seriellen-Monitor am Reseiver wird immer nur 0 zurückgegeben >(int hal=22;). >Was mache ich denn falsch?
-
Thread
uint16_t Array im PROGMEM; erste Elemente stimmen nicht
Also ist die 2 von sizeof(uint16_t) bzw. sizeof(*c3) ?
-
Thread
Arduino Funkverbindung mit mehren clients
Serial.begin(9600); } void loop() { const char text[] = "Hallo"; bool ok = radio.write(&text, sizeof(text)); if(ok) Serial.println("gesendet"); else Serial.println("Fehler"); delay(1000); } [/c] Empfänger: [c] #include <SPI.h> #include <nRF24L01.h> #include <RF24.
void loop() { if (radio.available()) { char text[32] = {0}; radio.read(&text, sizeof(text)); Serial.println(text); } } [/c] Ich hatte es einmal geschafft "Hallo" ein oder zweimal zu übertragen, aber eigentlich funktioniert es nicht. Es wird auf der Sender Seite auch
-
Thread
Delphi 7: Comport auslesen, Byte-Weise oder per Stop-Zeichen
else begin fillchar (CPDCB,SizeOf (TDCB),0); with CPDCB do begin DCBlength := SizeOf (TDCB); BaudRate := CBR_9600; Flags := fParity or fOutxCtsFlow or fDtrControlEnable or fErrorChar or fRtsControlEnable; ByteSize := 8; Parity := EVENPARITY; StopBits
-
Thread
SD Karten Library für ATMega gesucht
if(errCode != 0) { return -1; } } while(1) { f_gets(filteredLine, sizeof(filteredLine), &file); if(strstr(filteredLine, "\r\n")) counteredLines++; if(f_eof(&file) != 0) { counteredLines++; break; } } if(openFile == 1) { errCode
deshlab ohne Fehler durchgehen, weil sie alles als C++ compiliert. > f_gets(filteredLine, sizeof(filteredLine), &file); > if(strstr(filteredLine, "\r\n")) counteredLines++; Und mas machst du, wenn dein "\r\n" mittig auf dem Ende deines Puffers liegt, spricht, wenn dein Puffer 20 Bytes lang
-
Thread
CString Variablen in C Sprache umformen
bei mir in CodeBlocks mit MinGW überhaupt nicht! char TempStr[] = ""; ist ein Array für 1 char, sizeof() liefert Größe 1, also kein Platz für mehr als z.B. ein Nullterminierungszeichen. TempStr = ASCII7BitTable[j].Bits; verursacht Fehler beim Compilieren: incompatible types when assigning to type
-
Thread
Programmabsturz - Fehler unbekannt
} } } int main(){ char **Feld; int i; Feld=malloc(DIM_ZEILE * sizeof *Feld); for(i=0;i<DIM_ZEILE;i++){ Feld[i] = malloc(DIM_SPALTE * sizeof **Feld); } spielGeruest(Feld); ausgabeSpielfeld(Feld); sodokuVorlage(Feld); ausgabeSpielfeld(Feld); sodokuStart
-
Thread
DCC Dekoder mit AtTiny45
if(!bitmask) { xor ^= data[byteind++]; if(byteind == sizeof(data)) { state = 0; syncct = 0; } else { bitmask = 0x80;
-
Thread
SSD1306/1309 Library zum Darstellen von Text auf OLED Displays
_SEGREMAP = 0xA0; uint8_t SSD1306_COMSCANINC = 0xC0; lcd_command(SSD1306_SEGREMAP | 0x0, sizeof(SSD1306_SEGREMAP)); lcd_command(SSD1306_COMSCANINC, sizeof(SSD1306_COMSCANINC)); } [/c] Das funktioniert leider nicht. Zeigt dann nur Müll an...
0x80, 0xA0}; uint8_t SSD1306_COMSCANINC[2] = {0x80, 0xC0}; lcd_command(SSD1306_SEGREMAP, sizeof(SSD1306_SEGREMAP)); lcd_command(SSD1306_COMSCANINC, sizeof(SSD1306_COMSCANINC)); } [/c]
-
Thread
Malloc - Fehler
> sizeof (char) * 4 * 2 + 1 Durch die Verwendung von Klammern im #define-Ausdruck ließe sich das Problem beseitigen. Davon abgesehen > Feld=(char**)malloc(sizeof(char*)* DIM_ZEILE); > for(i=0
von Operatoren gestört wird: [c] sizeof(char*)* GROESSE_FELD * 2+1 [/c] ist nämlich was ganz anderes als [c] sizeof(char*)* (GROESSE_FELD * 2+1) [/c]
-
Thread
STM8S - Timer4 Overflow Interrupt führt zu unhandled exception
counter]); } } void shuffleRight(){ uint8_t counter, temp; for(counter = 0; counter < sizeof(buffer); counter++){ if(counter != 0){ uint8_t temp2 = buffer[counter]; buffer[counter] = temp; temp = temp2; } else { temp = buffer[counter]; buffer[counter] = buffer[sizeof(buffer)-1]; } } } #pragma vector = 23 __interrupt void TIM4_UPD_OVF_IRQHandler(void){ if(!didInit){ initMAX7219(); didInit = true; } applyBuffer(); shuffleRight()
-
Thread
(Multi)Touch Treiber / Simulation, Raspberry Pi
memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_ABS; ev.code = ABS_MT_SLOT; ev.value = 0; if(write(fd, &ev, sizeof(struct input_event)) < 0)
die("error: write"); memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_SYN; ev.code = SYN_REPORT; ev.value = 0; if(write(fd, &ev, sizeof(struct input_event)) < 0) die
-
Thread
I2C read mit C-Programm Raspberry PI
wrong return; } //----- READ BYTES ----- length = sizeof(buffer); //<<< Number of bytes to read if (read(file_i2c, buffer, length) != length) //read() returns the number of bytes actually read, if it doesn't match
wrong return; } //----- READ BYTES ----- length = sizeof(buffer); //<<< Number of bytes to read if (read(file_i2c, buffer, length) != length) //read() returns the number of bytes actually read, if it doesn't match
-
Thread
Temperatursensor mit maximaler Genauigkeit auswerten
struct tab table[] = { { 980, -55 }, { 1030, -50 }, ... }; const int num_values = sizeof(table) / sizeof(table[0]); [/c] Mit dem gemessenen Widerstandswert gehst Du dann in die Tabelle und interpolierst: [c] int temp(int res) { int temp; int i = 0; do {
-
Thread
NRF24L01 | Arduino | Problem
// print and increment the counter digitalWrite(2, HIGH); delay(500); radio.write(data, sizeof(uint16_t)+1); Serial.print(" | Temperature sent: "); Serial.println(sensorValue); // pause a second digitalWrite(2, LOW); delay(500); }[/c] RX [c]#include <SPI.h> #include <RF24
{ // fetch the payload, and see if this was the last one done = radio.read(data, sizeof(uint16_t)+1); } // print the payload if (data[0] == 'T') { //put the uint16_t back together uint16_t sensorValue = data[2] | data[1] << 8; Serial.print(count);
-
Thread
Pointer auf 0x0000
int*)2; int* y = x-2; [/c] ist identisch zu [c] int* x = (int*)2; int* y = (int*)((int)x - 2*sizeof(int)); [/c] Siehe: Skalierte Zeigerarithmetik (oder wie man das schreibt).
-
Thread
NULL Pointer als Übergabe in Funktion verursacht sporadische Fehler
Sollte das memset(&Prog[0], 0, sizeof(Prog[0])); nicht eher memset(Prog, 0, sizeof(Prog)); sein?
A. K. schrieb im Beitrag #4837224: > memset(&Prog[0], 0, sizeof(Prog[0])); memset(&Prog[0], 0, sizeof(Prog));
-
Thread
strlen() und __flash (Atmel Studio7)
das Problem? [C] ... const __flash char s[] = "Irgendein Text"; ... c = strlen(s); c = sizeof(s); ... [/C]
: %i\n", strlen(x)); printf("sizeof: %i\n", sizeof(x)); return 0; } [/c] strlen gibt 5, sizeof 200 zurueck. Der Unterschied sollte halbwegs offensichtlich sein. Peter schrieb im Beitrag #4835558: > strlen gibt nicht die
-
Thread
AVR-GCC: ARRAY an eine feste RAM-Adresse legen
const char* name; void *address; int16_t size; } symlist = { { "ganze_struct", &daten, sizeof(daten_t) }, { "ganze_struct.feld1", &daten.feld1, sizeof(whatever_daten_feld_1_is) }, ... }; [/c] unterbringen kannst und willst (ist ja bei 400 Feldern schon ein wenig Arbeit), dann wäre es
char* name; > void *address; > int16_t size; > } symlist = { > { "ganze_struct", &daten, sizeof(daten_t) }, > { "ganze_struct.feld1", &daten.feld1, sizeof(whatever_daten_feld_1_is) > }, > ... > }; > [/c] > unterbringen kannst und willst (ist ja bei 400 Feldern schon ein wenig > Arbeit
-
Thread
DTMF decoder
32649, // 1336 Hz 26169, // 1477 Hz 18629 // 1633 Hz }; const int CoeffCnt = sizeof(CoeffArr)/sizeof(*CoeffArr); for(int f=650; f<1700; f+=10) { const uint8_t Cnt = 160; // 20ms lange Blöcke const short fSample = 8000; int16_t q[Cnt]; for(int i=0; i<Cnt
fSample*256/2/1336, fSample*256/2/1477, fSample*256/2/1633 }; const uint8_t StepCnt = sizeof(StepArr)/sizeof(*StepArr); for(uint8_t iCoeff=0; iCoeff<StepCnt; iCoeff++) { short Step = pgm_read_word(&StepArr[iCoeff]); short s = 0; short c = 0; { // "Sin-Summe
-
Thread
ATmega328p resetet ständig
@m.k. t++ erhöht den zeiger um 'sizeof' char nicht den wert der durch *t addressiert wird.
-
Thread
Mikrocontroller: Probleme mit char Buffer
#4827904: > kannst Du mir da mal ein Beispiel geben. Erzeuge lustige Strukturen. Lasse dir mit sizeof() die jeweilige Größe zeigen. Daraus solltest du auf die Anzahl Füllbytes schließen können.