-
Thread
Konstanter Zeiger auf ein Array der Größe 2 eines volatile structs
Wenn &arr schon keine Warnung bringt, sind Warnungen wohl aus. Was ist sizeof(Mystruct_t)? Und wofür die Klammern und *const arrp?
A. S. schrieb im Beitrag #7260695: > Was ist sizeof(Mystruct_t)? 8, wie erwartet. A. S. schrieb im Beitrag #7260695: > Wenn &arr schon keine Warnung bringt, sind Warnungen wohl aus. Hm, stimmt, ich referenziere eine Ebene zu tief. Da muss
-
Thread
Hashtables/assoz. Arrays
, { "bla", 16 }, }; // einmalig sortieren: qsort( tabelleWertePaare, ANZAHL, sizeof( wertepaar_t ), compareWertePaar ); // nach dem Wert zu "klm" suchen (15): wertepaar_t key = { "klm", 0 /* Wert egal */ }; wertepaar_t *p_gefunden = bsearch( &key, tabelleWertePaare, ANZAHL, sizeof( wertepaar_t ), compareWertePaar ); if( p_gefunden ) { printf( "Wert: %d\n", (int)p_gefunden->value ); }
-
Thread
Daten des ATTiny24 über SPI auslesen
; if(hSerial==INVALID_HANDLE_VALUE) {B_Connect->Caption = "ERROR_1";} memset(&Device,0,sizeof(Device)); Device.DCBlength = sizeof(Device); Device.BaudRate = iBaudrate; // Baudrate Device.fParity = FALSE; Device.fBinary = TRUE; Device.Parity
-
Thread
2D Arrays und Zugriff über Pointer?
2D-Array, wobei die letzte Dimension variabel sein soll int* Data[5]; Data[0] = malloc( 2 * sizeof(**Data)); // Allokiere 2 Elemente Data[0][0] = 8; Data[0][1] = 3; Data[1] = malloc( 4 * sizeof(**Data)); // jetzt 4 Data[1][0] = 2; Data[1][1] = 4; Data[1][2] = 5;
-
Thread
ATSAMD21G18 und Atmel Studio 7
/c] [c] uint8_t string[] = "Hallo\n"; usart_write_buffer_wait(&usart_instance,string, sizeof(string)); [/c]
; uint8_t string[] = "Hello World\r\n"; usart_write_buffer_wait(&usart_instance, string, sizeof(string)); }[/c] ...trotzdem funktioniert es nicht. Keine Ausgabe an der seriellen Schnittstelle :( Hardwaremässig ist aber alles ok, mit dem Arduino sketch kann ich an den Pins senden und empfangen
-
Thread
verständisfrage zu pointer auf array
setze a[4] auf 44\n"); a[4] = 44; printf("wert b0: %i\n", b[0]); printf("groesse a: %u\n", sizeof(a)); printf("groesse b: %u\n", sizeof(b)); printf("wert b12: %i\n", b[12]); printf("wert a16: %i\n", b[16]); return 0;[/c] die Ausgabe ist [code] adresse b: 00400080 adresse
-
Thread
Von Assembler nach C
[c] char *hallo = "halloWelt"; [/c] hier pointer inkrementieren bzw. dekrementieren. über sizeof(hallo)/sizeof(char) überlauf abfangen. gruß R2D2
-
Thread
shared mamory: Blockweise schreiben bzw. lesen
BytesToRead, fdBin12); blöcke aus und inkrementiere die Adresse dann mit shPtr1I += BytesToRead/sizeof(*shPtr1I); demnach würde sich doch der speicherbereich um BytesToRead/sizeof(*shPtr1I) verändern. Ist korreckt so?? sorry für die, für manche leichten fragen aber ich bin noch nicht so lange dabei
-
Thread
NRF24L01+ schwache Verbindung
print(inputString); // an die TTL-Schnittstelle schicken und radio.write(&inputString, sizeof(inputString)); zaehler = 0; } digitalWrite(led, LOW); // LED auslöscchen } } [/c] Code Empfänger: [c] #include <SPI.h> #include <nRF24L01.h> #include <RF24.
nRF24L01 Packete empfangen: if (radio.available()) { char text[32] = ""; radio.read(&text, sizeof(text)); Serial.print("From nRF24L01 Data: "); String newString = text; newString.trim(); newString.toUpperCase(); Serial.println(newString); if (newString.startsWith("
-
Thread
C Katastrophen.
Abfangen von derart groben Schnitzern selber verantwortlich. Man könnte z.B. schreiben: [c] if(c < sizeof(a)/sizeof(a[0])){ a [c] = 0; }else{ printf("Programmierer war besoffen oder stoned!\n"); exit(-1); } [/c]
-
Thread
fftw in c++ mit 2-dim messdaten
das füllen des arrays mit x und y werten? [c] double* samples = (double*) malloc(2 * smplCount * sizeof(double)); fftw_complex* spectrum = (fftw_complex*) fftw_malloc((smplCount / 2 + 1) * sizeof(fftw_complex)); memset(samples, 0, 2 * smplCount * sizeof(double)); memset(spectrum, 0, (smplCount / 2 + 1) * sizeof(fftw_complex)); fftw_plan forward = fftw_plan_dft_r2c_2d(smplCount, 2, samples, spectrum, 0); for (int i = 0; i < smplCount; i++) { samples[i] = input->get(i).x; samples[smplCount + i] =
-
Thread
Stringauswertung
c] unsigned int c, c_temp, num_temp; char *abschnitt; char delimiter[]=";"; uart_gets(Line,sizeof Line); abschnitt=strtok(Line,delimiter); c_temp=abschnitt; while (abschnitt!=NULL) { abschnitt=strtok(NULL,delimiter); num_temp=abschnitt; } if ( c_temp & UART_NO_DATA ) { /* no data available
] char c[0], c_temp[0], num_temp[3]; char *abschnitt; char delimiter[]=";"; uart_gets(Line,sizeof Line); abschnitt=strtok(Line,delimiter); c_temp=*abschnitt; while (abschnitt!=NULL) { abschnitt=strtok(NULL,delimiter); num_temp=*abschnitt; } if ( c_temp & UART_NO_DATA ) { /* no data
-
Thread
Neue Frage zu Union in C
auf 4 BYte aufgeblasen, damit sie ohne Problem als Array benutzt werden kann. Teste das mal mit sizeof(S_M_H_Time)
Herzlichen Dank erst mal für die schnellen Antworten! >Teste das mal mit sizeof(S_M_H_Time) Ergibt 3. Der Compiler ist XC8, da habe ich dieses "short long" von irgendwoher einfach abgeschrieben. Mit dem XC8 arbeite ich erst ein halbes Jahr. Vorher hatte ich den CC8e.
-
Thread
PIC24f32KA304 EEPROM lesen und schreiben
offset = __builtin_tbloffset(&eeData); // Initizlize lower word of address offset += index * sizeof(int); return __builtin_tblrdl(offset); // read EEPROM data } int EEP_Write(int index, int data){ unsigned int offset; if(index > 0xff) return -1; if(index < 0)
offset = __builtin_tbloffset(&eeData); // Initizlize lower word of address offset += index * sizeof(int); __builtin_tblwtl(offset, data); asm volatile ("disi #5"); // Disable Interrupts For 5 Instructions __builtin_write_NVM(); // Issue Unlock Sequence and Start Erase Cycle
-
Thread
microchip user space api wie nutzen für phi ?
board. Assign point to the board definition board = &board_table[0]; memset (&board_table[0], 0, (sizeof(vtss_appl_board_t) * MAX_BOARD_INSTANCES)); [/code] // Sie initialisieren das Board: --- [code] vtss_board_phy_init(board); //sie kreieren ein Board: // "Create" the board vtss_inst_get(board
, buffer); T_N("mmd_read_rbt: %s", buffer); socket_write(&buffer[0]); memset(buffer, 0, sizeof(buffer)); socket_read(&buffer[0]); [/code] (Aber es ist seltsam, da dieses Beispiel einen Socket für SPI verwendet. Vielleicht hat jemand eine Idee dazu) Ich sollte also meine eigene Board-Definition
-
Thread
Stringtabelle mit Funktionspointer sortieren
printf("String[%d] = %s\n", i, *(store+i)); } int main() { char **stringtabelle = malloc(4*sizeof(char*)); *stringtabelle = "Karku"; *(stringtabelle+1) = "Marku"; *(stringtabelle+2) = "Parku"; *(stringtabelle+3) = "Farku"; printStringTable(stringtabelle); return
int compare(char *string1, char *string2); int main() { char **stringtabelle = malloc(4*sizeof(char*)); *stringtabelle = "Karku"; *(stringtabelle+1) = "Marku"; *(stringtabelle+2) = "Parku"; *(stringtabelle+3) = "Farku"; printStringTable(stringtabelle); qsort
-
Thread
Problem mit void*
)(var(INT_,0))) = 12; *((short *)(var(SHORT_,12))) = 0; ... [/C] P.S: Mit AVR-GCC/WinAVR ist sizeof(int) == sizeof(short) und darum die Unterscheidung eine rein akademische Angelegenheit. EDIT: PPS. Ähh i ist char[], aber case INT_: return &i[element]; ???
-
Thread
16 Bit Timer läuft nicht an
ISR (SIG_OUTPUT_COMPARE1A) { unsigned char counter; for(counter = 0; counter < (sizeof(time_counter_)/sizeof(unsigned int)); counter++) { if(time_counter_[counter] > 1) time_counter_[counter]--; } // sprintf(led_blink_buffer, "%s\n\r" ,led_blink); // usartPuts
-
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
Array zurücksetzen auf default
So: [c]memset(data_array, 0, sizeof (data_array));[/c] (wenn data_array wirklich als Array deklariert und kein Zeiger ist) oder so: [c]memset(data_array, 0, sizeof (unsigned char) * 7);[/c] (dann kann data_array ein Pointer sein
-
Thread
Hilfe um 8 Bitfelder in uint8_t umzuwandeln (ESP32)
vorgestellt: [c] // -->: in eigene Library-Header template<uint8_t N, typename T> requires (N < (sizeof(T) * 8)) auto bit(T& v); namespace detail { template<uint8_t N, typename T> requires (N < (sizeof(T) * 8)) struct Bit { friend auto bit<N, T>(T& v); template<typename
explicit Bit(T& v) : d{v}{} T& d; }; } template<uint8_t N, typename T> requires (N < (sizeof(T) * 8)) auto bit(T& v) { return detail::Bit<N, T>{v}; } // <-- Ende Library-Header // Beispiel zur Verwendung std::byte v; int main() { bit<3>(v) = true; bit<7>(
-
Thread
Arduino Uno Programm auf Micro
void loop() { int z; if (myRadio.available()){ i=150; myRadio.read(&z, sizeof(int)); Serial.println("Ein, z = "+String(z)); } if(i>0)i--; digitalWrite(4,i>0); ausgabe++; if(ausgabe==100){ ausgabe=0; // Ausgabe if (i>0) {
myRadio.openWritingPipe( addresses[0]); } void loop() { int x =0; myRadio.write(&x,sizeof(int)); Serial.print("EIN"); delay(1000); } [/c] So sieht der Funktionsablauf des Programms in etwa aus.
-
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
Wie die Bytegröße einfach bestimmen (in C)?
16 hat, besteht ein char dann eben aus 2 8-Bit Byte. Allerdings ist auch auf solchen Systemen der sizeof(char) gleich 1, sodass man aus C-Sicht ein C-Byte als 16-Bit Einheit ansehen könnte obwohl es im Speicher meistens aus 2 8-Bit Bytes zusammengebaut wird. Heutige Speicher und Bussysteme sind als Vielfaches
C-Implementierung, bei der die > Größe eines int kleiner ist als 16 Bit? Mit avr-gcc -mint8 ist sizeof(int) = 1, allerdings wird diese Option nicht mehr gepflegt und ist in neueren Versionen spätestens ab 4.6 nicht mehr funktional. Um das "live" zu sehen, braucht mal also eine was angestaubte Version
-
Thread
Komisches Bitfield Padding
unsigned int :4 ; }; }; }DCF77_DATA_STREAM; [/c] Wenn ich nun mit "sizeof" die Größe bestimme erhalte ich 10 Bytes, obwohl sowhl unsigned long long int 8 Bytes groß sein müsste, als auch das gesamte Bitfeld. Wo is'n da der Fehler??? Hinweis: MPLAB C30
Michael S. schrieb im Beitrag #2309070: > Wenn ich nun mit "sizeof" die Größe bestimme erhalte ich 10 Bytes, > obwohl sowhl unsigned long long int 8 Bytes groß sein müsste, als auch > das gesamte Bitfeld. Wo is'n da der Fehler??? Das Problem ist wohl, dass Deine
-
Thread
Bitfelder: Zuweisung so zullaessig?
/ <-- ist das zulaessig? Die Frage ist, WAS macht der Compiler draus? memcpy(&feld2,&feld1,sizeof(BITFIELD)); ?
MaWin schrieb im Beitrag #3965580: > memcpy(&feld2,&feld1,sizeof(BITFIELD)); Kann er machen. Der Compiler ist aber nicht verpflichtet, Löcher in Strukturen mit zu kopieren.
-
Thread
UART Sendevorgang funktioniert nicht
void) { // TX next character UCA0TXBUF = string2[i++]; // TX next character if (i == sizeof string2 - 1) // TX over? { i=0; //Zähler für Übertragung reseten UC0IE &= ~UCA0TXIE; // Disable USCI_A0 TX interrupt } } [/c] Vielen Danke für jede Hilfe, Sebastian :)
Variable namens 'I'? Das nennt man Drahtseilakt ohne Netz und doppelten Boden. Sowas > if (i == sizeof string2 - 1) // TX over? willst du auch nicht benutzen. Du willst genau dann aufhören, wenn der String zu Ende ist und nicht wenn das Array aufhört. Ein String ist zu Ende, wenn du im String auf
-
Thread
UART und Timer: Verrücktes Verhalten
KLAPPT DIE ÜBERTRAGUNG EINWANDFREI //!!!!!! char text[] = "TEST \n"; SendeTextUART(text,sizeof(text)); } // Die globale Zählvariable zum Realisieren größerer Periodendauern wird hier hochgezählt gHeartbeat++; } void Timeraufgaben_Abarbeiten(){ if(gfAufgabenLiegenVor == 1
WERDEN NUR TEILWEISE ÜBERTRAGENG //!!!!!! char text[] = "test \n"; SendeTextUART(text,sizeof(text)); gfAufgabenLiegenVor = 0; } } /////////////////////////////////////// // UART Teil /////////////////////////////////////// // Globaler Eingangspuffer und Arrayindex char
-
Thread
uin8_t array to uin32_t
diese Zwecke ein htonl() vor (*) [c] uint32_t value = 0; uint32_t rdata; for (uint8_t i = 0; i < sizeof(data); i+=4) { rdata = *(uint32_t*) (data[i]); //memcpy(&rdata,&data[i],sizeof(uint32_t)); if (MSB_FIRST) rdata = htonl(rdata); value ^= rdata; } //do something with value [/c] (
-
Thread
Absolute Funktionsadressen in Tabelle ablegen
memory segment func1, func2 }; u8 execute( u8 func_no ) { if( func_no >= sizeof(func_table) / sizeof(u8funcv)) return 255; // out of table return func_table[func_no](); // do it } [/c] Dazu muß man
-
Thread
Array extern - Anzahl Elemente mit eingeben oder nicht?
falsch, oder macht es einen Unterschied? Die erste liefert die Grössenangabe mit, abfragbar per sizeof(array)/sizeof(array[0]), die zweite nicht. Wenn dein Arry nicht selbst eine Grössenangabe enthält, beispielsweise mit einem 0-Element als letztem Element, dann ist die erste sicher schlauer.
-
Thread
Display Menü LCD 4x20
runter zählen, den Text anzeigen und die Funktion aufrufen. Als maximalen Index nimmt man per sizeof(table)/sizeof(structur) die Anzahl Elemente in der Tabelle oder legt einen letzten Eintrag fest (Null-Text, Null-pointer). D.h. man kann ganz easy weitere Punkte hinzufügen oder welche löschen.
-
Thread
Schrittmotorsteuerung für primitive Astro-Nachführung
0; //START++; //START %= 2; START = 1; lcd_clear(); str = (char *) calloc(16, sizeof(char)); // STARTE // WERTE IN DAS EEPROM SPEICHERN eeprom_write_byte(&eeWINKEL, WINKEL); eeprom_write_byte(&eeZEIT, ZEIT); eeprom_write_byte(&eeWIEDERHOLUNGEN, WIEDERHOLUNGEN);
my_uitoa(uint32_t zahl, char* string) { int j=0,i=0; char *st; st = (char *)calloc(10,sizeof(char)); while(zahl>0){ st[i] = (zahl%10) + '0'; zahl = zahl / 10; i++; } for (j=0; j<=i; j++){ string[j] = st[i-j-1]; } string[i] = '\0'; free(st); } [/c
-
Thread
Auf ein Byte zugreifen
pHelp; // mach was mit allen Bytes von Value pHelp = (uint8_t*) &Value; for( i = 0; i < sizeof( Value ); ++i ) output( pHelp[i] ); [/C]
unbedingt besser oder übersichtlicher, aber geiziger: [c] uint32_t Value; for( i = 0; i < sizeof( Value ); ++i ) output( ((uint8_t*)&Value)[i] ); [/c]
-
Thread
gcc Konfiguration mit #if prüfen
richtig ist? d.h wie macht man folgende symbolisch geschriebene Zeile (die lt GCC Manual wegen des sizeof() Operators nicht geht) so, daß es bereits beim Compilieren kracht ? typedef irgendeinedefinition #if sizeof(irgendeinedefinition) > 5 #error "zu gross" #endif Danke, Mario
www.pixelbeat.org/programming/gcc/static_assert.html http://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
-
Thread
Enum oder #define?
DistanceModes VL53L1_DISTANCEMODE_SHORT = 1; int main () { fwrite (&VL53L1_DISTANCEMODE_SHORT, sizeof (VL53L1_DISTANCEMODE_SHORT), 1, stdout); }[/c] geht weder mit enums noch Makros. In C++ kann man es sich leicht machen und immer "const" nehmen. In C muss man zwischen enum und const abwägen und
// ... // over temperature: flash-dim all LEDs memset(leds, DIM_FLASH, sizeof leds); [/c] Das Ganze funktionierte ohne „__attribute__((packed))“ nicht wie gewünscht (nur die Hälfte aller LEDs wurde passend gesetzt), mit dagegen schon. Das widerlegt ganz eindeutig
-
Thread
Memory Pool - GrundsätzlichsTes
über die Adresse > -Kann ich einen Pool Initialisieren der sich wie ein Array verhält? Solange sizeof(array) <= sizeof(memoryBlock) gilt, sehe ich erstmal keinen Hinderungsgrund > -Ich möchte auch Funktionen wie vsnprintf oder sprintf damit verwenden, Nimm snprintf statt sprintf und gib als size
-
Thread
Rowley CTL RTOS - Kein Scheduling
unsigned task1_stack[CTL_CPU_STATE_WORD_SIZE + 32]; ctl_task_run(&task1, 200, Task1, 0, "Task1", sizeof(task1_stack) / sizeof(unsigned), task1_stack, 0); CTL_TASK_t task2; unsigned task2_stack[CTL_CPU_STATE_WORD_SIZE + 32]; ctl_task_run(&task2, 200, Task2, 0, "Task2", sizeof(task2_stack) / sizeof(unsigned), task2_stack, 0); ctl_task_set_priority(&mainTask, 0); while (1) { } } [/c]
-
Thread
Dynamisches Array (mit calloc() und realloc()) löst BusFault aus. Wieso?
(größe ist abhängig von der Anzahl der Stuffs) nutzdaten_bit_stuffing= calloc((32+stuffs),sizeof(unsigned long)); first_passing = 0; } else { //größe des Arrays ändern, wenn sich Anzahl der Stuffs ändert nutzdaten_bit_stuffing= realloc(nutzdaten_bit_stuffing,(32+stuffs)*sizeof(unsigned long)); } //---------------------------------------------------------------------------------------------// for(i=0;i<32;i++) {nutzdaten_bit_stuffing[i]=nutzdaten
-
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
Aus Ascii mach Integer mach Ascii gleich Null??
= 5; int wert = 0; while(1) { uart_gets (Line, sizeof (Line)); for (i = 0; i < 70; i++) //String auf Terminal-Bildschirm { cursor_pos ( reihe , i ); //Cursor ein weiter uart_putc (Line[i]); //nächster char
Telegramm > int i = 0; > int reihe = 5; > int wert = 0; > > while(1) > { > uart_gets (Line, sizeof (Line)); > for (i = 0; i < 70; i++) //String auf Terminal-Bildschirm > { > cursor_pos ( reihe , i ); //Cursor ein weiter > uart_putc (Line[i]); //nächster
-
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
eeprom_read - Adresse casten?
uint8_t eeBreak, eeFreq, eeILimit; #define ADR_eeBreak 0 #define ADR_eeFreq ADR_eeBreak + sizeof(eeBreak) #define ADR_eeILimit ADR_eeFreq + sizeof(eeFreq) Wenn ich nun aus dem eeProm lesen möchte, muss ich dann "ADR_eeBreak" zu einem (uint8 *) casten? Also so?: eeBreak = eeprom_read_byte
-
Thread
struct und Array (Arduino)
for(i=0; i<sizeof(HeaderUnion); i++) { UDP_Header.Byte[i] = *UDP_Paket++; } [..] //Pruefsumme des Header okay? if (UDP_Header.Header.crc8 != CRC8(UDP_Header.Byte, sizeof(HeaderUnion) -1 ) ) return ( UDP_HEADER_\ CRC); Das funktioniert, sieht elegant aus, setzt aber voraus das du verstehst was du machst weil es abhaengig von Compiler und Wordbreite im Controller