-
Thread
C-Compiler und Debugger
hochgecastet. Ein [c] int16_t j = 9000; int16_t i = j * j / 8000; [/c] liefert bei einer sizeof(int) von 2 ein falsches Ergebnis, während es bei einer sizeof(int) von 4 ein richtiges Ergebnis liefert. Und du kannst nichts dagegen tun ausser aufpassen.
-
Thread
SAMD21 DMA auf Pin
dma_descriptor_get_config_defaults(&descriptor_config); descriptor_config.block_transfer_count = sizeof(source_memory)/4; descriptor_config.source_address = (uint32_t)source_memory + sizeof(source_memory); descriptor_config.destination_address = 0x41004480 + 0x1C; descriptor_config.beat_size
-
Thread
Mit 3Bits arbeiten, andere Möglichkeit?
0b11000000, 0b10000000 }; // Anzahl der Einträge im Array lpattern #define LPATTERN (uint8_t)(sizeof(lpattern)/sizeof(lpattern[0])) // die Bitmuster aus lpattern[] an die roten Leds vorne ausgeben // Diese Funktion jenach gewünschter Geschwindigkeit alle 10..200ms // aus der main_loop heraus
-
Thread
png processing with C
matrix pointer */ pixel **p; /* allocate space for rows */ p = (pixel **) malloc(n * sizeof(pixel *)); /* validate pointer */ if( p != NULL ) { /* allocate first column */ p[0] = (pixel *) malloc(n * m * sizeof(pixel)); /* validate pointer */ if( p[0] == NULL
-
Thread
32 bit über rs232 einlesen
das Ergebnis ein long sein muss. Daher gehen die Shifts für Byte3 und Byte4 in die Hose, wenn sizeof(long) != sizeof(int) long result = (long)( Byte1 | ( Byte2 << 8 ) | (((unsigned long)Byte3) << 16 ) | (((unsigned long)Byte4) <<
-
Thread
printf druckt falsch aus dem FLASH
eeStartupMsg[] EEMEM = "VERSION 0.0.5 ALPHA\r\n"; int main() {mc_init(); char *startupMsg = malloc(sizeof(eeStartupMsg)); eeprom_read_block(startupMsg,&eeStartupMsg,sizeof(eeStartupMsg)); printf("%s",startupMsg); free(startupMsg); } Achte auch darauf, dass du die .eep-Datei mitflasht. MfG,
-
Thread
"Gruppierung" von Pins
}, { &PORTC, 0x02 }, { &PORTC, 0x08 }, { &PORTC, 0x80 } }; #define PINS_COUNT (sizeof(pins) / sizeof(portpin_t)) static void pinout(portpin_t* pp, bool high) { if(high) { *(pp->port) |= pp->pinmask; } else { *(pp->port) &= ~pp->pinmask; } }
-
Thread
STM32 komisches Verhalten bei include und leerer Funktion
Hm.. besagte Zeilen sehen beide so aus: [c] uint8_t u8Max = (uint8_t) ( sizeof(scEsc_SysTick.apfct) / sizeof(scEsc_SysTick.apfct[0]) ); [/c] mit: [c] volatile struct { void ( *apfct[8] ) (void); } scEsc_SysTick; [/c] Ich habs geändert
-
Thread
Was ändern um Winavr-Projekt in AVR-Studiuo zu builden?
AVR die Casts auch ganz weglassen können. Die sollen wohl einige unschöne Effekte verhindern wenn sizeof(int) != sizeof(void*). CU
-
Thread
Float in I2C-EEPROM und zurück
... float *fTmp=new float; char *cTmp=(char *)fTmp; *fTmp=<float-wert>; for (int i=0;i<sizeof(float);i++) { I2C_Write(cTmp[i]); } so in die richtung sollte das hinhaun... einfach einen float-pointer in einen char-pointer umcasten und dann die bytes durchgehn (ich hoff mal es gibt ein sizeof bei dir...sonnst im manual nachschaun wie viele byte der float hat) 73 HG
-
Thread
Unerwarteter Wert bei Berechnung für s16-Wert
Der Tricore-Compiler dürfte aber einer sein, bei dem sizeof(int) == 4 ist. Oder?
Das mit sizeof(int) habe ich nicht ausprobiert aber ich nehme mal an das da 4 rauskommen muss. In der Datei limits.h vom Tricore kann ich entnehmen das der int so gross ist wie ein long. Ausserdem klappt ja obige
-
Thread
Funktion, welches je nach Datentype der Eingangsvariablen anders reagiert - geht sowas ?
Vielleicht lässt sich auch was mit präprozessor-Makros machen und tricksen mit sizeof() oder so ;)
das angeben muss (oder überhaupt schon weiß, vielleicht ändert es sich ja) Für die Größe reicht sizeof, geschenkt. aber ob ich -1 oder 255 anzeigen soll, ist schon wichtiger. Wenn ich die Variablen MyIndex, MyCount und MyWhatever habe, möchte ich vielleicht einfach Add(MyCount), Add(MyIndex),
-
Thread
USB Verbundgerät
, 0x01, 0x1, 5), /* HID, boot, keyboard (3/1/1) */ USB_FILL_HID_DESC(9, 0x0100, 0x0, 1, 0x22, sizeof(kbd_report_descriptor)), USB_FILL_EP_DESC(0x1, 1, 0x3, 8, 0x20), USB_FILL_IFC_DESC(1, 0, 1, 0x3, 0x0, 0x0, 6), /* (HID, none, none) */ USB_FILL_HID_DESC(9, 0x0100, 0x0, 1, 0x22, sizeof(
-
Thread
Zugriff auf structs
b ; }; int main(int argc, char *argv[]) { telbuch eintrag1; eintrag1.b = malloc(sizeof(int)); if(eintrag1.b == 0)return EXIT_FAILURE; //Fehler beim Speicheranfordern *(eintrag1.b) = 77; //printf("askdfj %d unsigned:%u \r\n",&(eintrag1.b),&(eintrag1.b)); return
Das ganze geht auch mit 'anonymen Speicher' [C] int main() { int * ptr; ptr = malloc( sizeof( int ) ); *ptr = 8; free( ptr ); } [/C] Das baut im Grunde dieselbe Struktur auf, nur dass der Speicher auf den ptr zeigt, jetzt keinen Variablennamen mehr hat und erst zur Laufzeit des
-
Thread
ARM: malloc & Null pointer Vergleich
uint16_t i; uint8_t *sram; for(i=1;i<65500;i++){ if((sram = (uint8_t *) malloc(i*sizeof(uint8_t))) == (void *) 0) { free(sram); lcd_string_P("free bytes: "); lcd_writei(i-1); i=65500; } else{ free(sram); } }//for [/c] beim ARM
funktioniert das nicht. ich habe auch schon sowas probiert: [c] if((sram = (uint8_t *) malloc(i*sizeof(uint8_t))) == (uint8_t *) 0) [/c] aber die abfrage wird nie .true. was muss ich beim arm anders machen? danke alex
-
Thread
Cast eines Int zu Pointer
hier geht ist eben als 32 Bit Int > definiert. Dann unterscheide die Fälle einfach: if (sizeof (ptr) == sizeof (uint16_t)) { casten wie oben angegeben; } else { nicht casten; } Dann bleibt der Code kompatibel. Der Compiler wird den jeweiligen nicht durchlaufenen
-
Thread
Problem mit Overflow
ich verwende immer 16bit groß, das kann >ich also ausschließen. Auf dem AVR? sicher? Mach mal sizeof. >Gibt es in C eigentlich signed*unsigned bzw. signed/unsigned >Operationen, oder müssen beide den gleichen "Typ" haben ? Naja, das sollte man tunlichst vermeiden. Das gibt "nette" Compilerabhängigkeiten
verwende immer 16bit groß, das kann >>ich also ausschließen. > > Auf dem AVR? sicher? Mach mal sizeof. 100%ig sicher ! Für short ist laut K&R mindestens 16bit vorgeschrieben. >>Gibt es in C eigentlich signed*unsigned bzw. signed/unsigned >>Operationen, oder müssen beide den gleichen "Typ" haben
-
Thread
GCC-Option -mint8 vermeiden?
gewisse Reste geben, in denen man erkennt, dass die Grundeinheit von GCC ein 16-Bit Register ist (sizeof int).
zieht hier ein Zwischenergebnis aus der Schleife raus und da alle Rechenoperationen mit mindestens sizeof(int) gerechnet werden ist diese Variable nun 16 Bits breit. Der Rest folgt daraus. Diese Optimierung ist global, für alle Architekturen, und kümmert sich nicht um die Frage, ob eine Teilwortoperation
-
Thread
printf ersetzen
Controller wohl nicht für u32. man könnte jeden Parameter von __VA_ARGS__ erst überprüfen lassen if(sizeof(u32var) >4 then (int) weil der wert eh nicht mehr als 1 ist.. zumindest in dem programmteil den ich gesehen habe
die Hexadezimaldarstellung einer int-Variable. Das ändert nur das Aussehen, nicht die Größe (sizeof) der Variablen.
-
Thread
Fehler beim ausführen von MAKE (e=2) kann Datei nicht finden
define FLAG_UPDATE 2 // Watchdog signaled a update #define SIZEOF_FLY 8 // sizeof struct firefly_t #define WAVE_END_L 0 // offsets to members in struct firefly_t #define WAVE_END_H 1 #define WAVE_PTR_L 2 #define WAVE_PTR_H 3 #define FLY0 0 * SIZEOF_FLY // offsets for 3 flies relative to _fly_ptr #define FLY1 1 * SIZEOF_FLY #define FLY2 2 * SIZEOF_FLY #define _saveZ r2 #define _
-
Thread
MFC_SDI
* ein Zaehler (ist glaub ich ein int) * ein Pointer d.h. Du erkaufst dir den Platzgewinn von sizeof(int) durch * umstaendlichere Programmierung * wenn Du einen Fehler machst, hast Du Speicherlecks * siehe oben, beim geringsten Fehler einen Crash, den Du erst muehsam suchen musst Eine Speichereinsparung von genau einem sizeof(int) ist bei heutigen Desktop Systemen Jacke wie Hose. Dem Windows wird das wahrscheinlich noch nicht mal auffallen, das rueckt seinen Speicher sowieso in 4 KByte Einheiten raus. Die Zeiten wo
-
Thread
Performance - großes switch-statement - jump-table ?
** labels[] PROGMEM = { && label0, && label1 }; if (i < sizeof (labels) / sizeof (labels[0])) { void ** addr = (void**) pgm_read_word (& labels[i]); goto *addr; } return 0; label1: return 2;
-
Thread
DS1307 Lib für Fleury's I2C
// Read DS1307 and put data in "t struct" so we can write back the date memset( time_str1, 0, sizeof( time_str1)); // Empty the temporary string time_str1[0]=time_str2[0]; // Copy first character from source string to temporary string time_str1
// Read DS1307 and put data in "t struct" so we can write back the time memset( date_str1, 0, sizeof( date_str1)); // Empty the string date_str1[0]=date_str2[0]; // Copy first character from source string to temporary string date_str1[1]=date_str2
-
Thread
ATMEGA32 USART sendet ein Zeichen zuviel
Variablen ------------------------------------------------ uint16_t u16Buff = (uint16_t) sizeof(scRs232.au8TxData); uint16_t u16Array = ( u16Buff - scRs232.u16Fill ); uint8_t u8Max = (uint8_t) sizeof(scRs232.au8TxLen ); uint8_t u8Idx = 0; //-- Eingangsvariablen
---------------------------------------------------------- uint16_t u16Buff = (uint16_t) sizeof(scRs232.au8TxData); uint16_t u16Idx = scRs232.au16TxRef[scRs232.u8TxOut]; uint8_t u8Len = scRs232.au8TxLen [scRs232.u8TxOut]; uint8_t u8Max = (uint8_t) sizeof(scRs232
-
Thread
FTDI USB device notification
OnInitDialog() { DEV_BROADCAST_DEVICEINTERFACE NotificationFilter; ZeroMemory( &NotificationFilter, sizeof(NotificationFilter) ); NotificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE); NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE; NotificationFilter.dbcc_classguid
-
Thread
Webserver NETIO Paket senden?
(WEATHER_SERVER_IP,HTONS(80)); memcpy_P(ð_buffer[TCP_DATA_START],WEATHER_GET_STRING,(sizeof(WEATHER_GET_STRING)-1)); tcp_entry[index].status = ACK_FLAG | PSH_FLAG; create_new_tcp_packet((sizeof(WEATHER_GET_STRING)-1),index); } } Benötige ich auch das ARP Request
-
Thread
Speicherbelegung unterschiedlicher CPSs
nicht das Problem ist. Ich lege also einen Char Zeiger auf den Anfang der Struktur und übertrage sizeof(Struktur) Daten. Auf der anderen Seite der Schnittstelle saß bisher eine gleiche CPU Familie, also alles gut! Jetzt habe ich eine PC-ähnliche CPU angeschlossen und folgendes gemacht wie immer. Im
Erst 1Byte, dann ein Dummy Byte, dann die 16Bit Variable und die 32Bit Variable. Heißt also das der sizeof folgerichtig die Struktur 8Byte groß macht, und diese auch sendet. Die Emfangsseite erwartet aber nach der Byte Variable die 16Bit Variable u.s.w., erwartet also 7Byte. Natürlich kann man auf der
-
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
Wert aus Array an eine Union übergeben
dieses Problem vor einiger Zeit mit der Funktion memcpy((BYTE*)&OUTPacket,&receivedDataBuffer,sizeof(receivedDataBuffer)) lösen können. Diese Funktion scheint mir während der Laufzeit im µC Probleme zu machen. Vielleicht gibt es eine andere sichere oder einfachere Methode? Bei mir ist eine struct
Rumburak schrieb im Beitrag #4819617: > memcpy((BYTE*)&OUTPacket,&receivedDataBuffer,sizeof(receivedDataBuffer)) Du kopierst 512 Bytes in einen wenige Bytes großen Buffer? Ja, das macht wohl Probleme. Es sei denn, eines der übrigen Elemente der Union ist mindestens 512 Bytes groß. Rumburak
-
Thread
Linux socketCan Interrupthandler mehrere CANs
strcpy(ifr.ifr_name, ifname ); ioctl(s, SIOCGIFINDEX, &ifr); memset(&addr, 0, sizeof(addr)); addr.can_family = AF_CAN; addr.can_ifindex = ifr.ifr_ifindex; if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { perror("Bind"); return 1; } while(1) { nbytes = read(s, &frame, sizeof(struct can_frame)); printf("vcan1: "); fflush(stdout); if (nbytes < 0) { perror("Read"); return 1; } printf("0x%03X [%d]
-
Thread
Doppeltverkettete Liste Speichern Datei
struct meineDatenElement* item = theListRoot; while( item ) { fwrite( item.daten, sizeof( item.daten ), 1, outFile ); item = item->next; } fclose( outFile ); } } int readFrom( const char* fileName ) { FILE* inFile; int retValue = 0; inFile = fopen
) return 1; struct meineDaten readItem; deleteList(); while( fread( &readItem, sizeof( readItem ), 1, inFile ) ) addAtTail( &readItem ); if( !feof( inFile ) ) retValue = 2; fclose( inFile ); return retValue; } [/c] Ich seh jetzt ehrlich das Problem nicht
-
Thread
Ansi C - UDP Case switch
2] = { {"tasklist_start", &task_monitor}, {"km", &callback_2}, }; for (int x = 0; x < (sizeof(myDummyStruct) / sizeof(*myDummyStruct)); x++) { if(strstr(rx_buffer, myDummyStruct[x].findString) != NULL) { char *d = strstr(rx_buffer, myDummyStruct[x].findString); if (myDummyStruct
-
Thread
GCC warning cast expression as lvalue
gewisse vereinfachende Annahmen über die Hardware der verwendeten Maschine zu machen; der Fall, daß sizeof (void*) != sizeof (funktion*) ist, ist IMHO verhältnismäßig selten*. Bei der ursprünglichen Aufgabenstellung ist es jedenfalls definitiv dasselbe. Mein etwas brachiales Typecast-Konstrukt hat nie
-
Thread
C/C++, Linux: Veriegelung das ein Prozess nur genau 1 mal läuft
SOCK_STREAM, 0); struct sockaddr_un tmp = { .sun_family = AF_UNIX }; snprintf(tmp.sun_path+1, sizeof(tmp.sun_path)-1, "%s", "MeinProgrammName"); tmp.sun_path[0]='\0'; // "abstrakter"-Socket. int ret=bind(sock, (struct sockaddr *)&tmp, sizeof(tmp)); if (ret) { perror("Programm läuft
-
Thread
Nullpointer-Frage
variadische Funktionen, die eine ungecastete NULL nicht als Pointer übernehmen sondern als int. Ist sizeof(int) != sizeof(void*), dann hast du Ärger.
-
Thread
Schrittmotor Vollschritt belegung
void mOneBackward() { MONEPORT &= ~CoilsOne[stepOne]; if( stepOne == 0 ) stepOne = sizeof(Coils) - 1; else stepOne--; MONEPORT |= CoilsOne[stepOne]; } void mone_vor(int schritte) { for( int i = 0; i < schritte; i++ ) { mOneForward; _delay_ms(1);
einen Schrittzyklus ausführen lassen. Der oben gezeigte Code passt sich durch die Verwendung von sizeof an die neue Arraygröße an, ohne dass du im Code selber etwas anpassen müsstest (der Compiler macht die Anpassung) [c] unsigned char CoilsOne[] = { 1 << MONEORANGE,
-
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
fgets wartet nicht, setzen einer variablen in einem struct lässt programm abstürzen
= list) { printf("empty list, create first element\n"); if(NULL == malloc(sizeof(struct liste))) { fprintf(stderr, "no free memory\n"); return; } printf("add list number\n"); list->number = number; printf(
Buffer 21 Zeichen groß und setz nach dem fgets noch: word[20] = '\0'; > if(NULL == malloc(sizeof(struct liste))) Wo speicherst Du denn den Rückgabewert von malloc? Gar nicht.
-
Thread
Atmega 8; EEPROM bei Reset korrumpiert; alle 0 werden zu 255
hat (wahrscheinlich) eine andere Bitbreite. Lasst dir doch mal über Serial oder wie auch immer sizeof(uint8_t) und sizeof(uint8_t*) ausgeben.
-
Thread
Uart und W-Lan doppelte Übetragung
[c] void reset_soft() { Reset: wait_ms(500); STK_puts("at+rsi_reset\r\n"); STK_gets( Line0, sizeof(Line0)); if(strstr(Line0,OK)) wait_ms(50); goto Reset; } [/c] Das schreibt man so: [c] void reset_soft() { do { STK_puts("at+rsi_reset\r\n"); STK_gets( Line0, sizeof(Line0));
-
Thread
Felder in "C" handling
elementweise oder per memcpy Feld[1][0] = Feld[2][0]; Feld[1][1] = Feld[2][1]; memcpy(Feld[1], Feld[2], sizeof(int) * SPALTEN); // soll die Funktion test auf das gesamte Array zugreifen // gehen folgende Varianten void test2(int param[ZEILEN][SPALTEN]) { } void test3(int param[][SPALTEN]) { } void
Beispiel: <c> #include <string.h> int main(void) { char Feld[6][6]; memset(Feld,0,sizeof(Feld)); //Feld mit Nullen initialisieren int i; int j; for (i = 0; i < 6; i++) { for (j = 0; j < 6; j++) { Feld[i][j] = i * j; } } memcpy(Feld[0],"ABCDE",5); //kopiert
-
Thread
Array ins EEprom speichern
das passt nicht gut zusammen > > Und int war wie groß noch gleich? das kannst du z.B. mit sizeof(int) rausfinden, ist ja nicht ganz sicher was der TO für einen Compiler verwendet, auf AVRs ist es normalerweise 2, sizeof(char) dagegen 1
-
Thread
Seltsames verhalten des GCC Compilers beim Arduino
IR Datensatz senden #ifdef USE_INFRARED_SENDER IR_Start(); IR_SendPaket(&GlobalVars_,sizeof(GlobalVars_)); #endif [/c] Hier die Routine für das Datenpaket: [c] void IR_SendPaket(void* data, uint8_t len) { #define GAP_TIME 600 #define START_TOK 2400 uint8_t chksum
Datensatz senden > #ifdef USE_INFRARED_SENDER > IR_Start(); > IR_SendPaket(&GlobalVars_,sizeof(GlobalVars_)); > #endif > [/c] und wo soll dieser Aufruf sein? Der muss ja in einer Funktion enthalten sein. (zb innerhalb der Funktion setup(), die vom Arduino System beim Programmstart aufgerufen
-
Thread
Banking probleme mit PIC 16f690
while (TRUE) { halRfSendPacket(txBuffer, sizeof(txBuffer)); } break; case RX: /* Infinite loop* / while (TRUE) { length = sizeof(rxBuffer); if (halRfReceivePacket(rxBuffer, &length)) { } } } #endif
-
Thread
UART String empfangen
Main rufe ich char Line[10]; // Array vom Typ int uart_gets( Line, sizeof( Line ) / sizeof( Line[0] ) ); nun will ich den String nachdem ich 10 Zeichen bzw enter gedrückt habe wider ausgeben auf den Heiperterminal und es geht nicht. ich benutze dafür
-
Thread
Zufallsfunktion liefert bei wiederholtem Aufruf den gleichen Wert
aus lauter Pointern besteht. Was dich rettet ist die Tatsache, dass auf deinem System offenbar sizeof(int) == sizeof( void*) Und natürlich, dass der Compiler einen & bei einem Array-Argument ignoriert. Das entspricht zwar nicht den C-Vorgaben, manche Compiler tun das aber trotzdem.
-
Thread
Frage zur float Darstellung - Prozessor unbekannt
, 0.001, 1.000, 1.998, 1.999, 2.000, 3, 4, 5, 10, 33 }; for (int i = 0; i < sizeof numbers / sizeof *numbers; ++i) { double n = numbers[i]; printf("%f:", n); for (int j = 0; j < 8; ++j) { printf(" %.02X", ((unsigned char*)&n)[