-
Thread
Frage zur Betriebsspannung messen
eingestellt hat ADCSRA |= (1<<ADEN); //ADC aktivieren delay(150); ID=3; memset(daten, 0, sizeof daten); ADCSRA |= (1<<ADSC); //Messung starten while (bitRead(ADCSRA, ADSC)); //warten bis Messung beendet ist //Ergebnisse des ADC zwischenspeichern. Wichtig: zuerst ADCL auslesen, dann
vw_wait_tx(); // Wait until the whole message is gone memset(daten, 0, sizeof daten); // Inhalt der Variblen (char) löschen //Schlafen gehen for (int i = 0; i < 1; i++) { //Hier schläft er jetzt 8 Sekunden 450 ist eine Stunde //goToSleep
-
Thread
Strings- der blanke Hass in 'C'
die meisten String-Funktionen wissen selber, wo das Ende ist. Bei konstanten Strings ist auch sizeof() besser, da setzt der Compiler gleich die Zahl ein und braucht nicht erst zur Laufzeit abzählen. Peter
> Bei konstanten Strings ist auch sizeof() besser, da setzt der > Compiler gleich die Zahl ein und braucht nicht erst zur Laufzeit > abzählen. strlen() degradiert zu sizeof()-1 bei einem konstanten String. ;-) (Sofern man nicht -ffreestanding
-
Thread
TCP zwischen C und C#
; } send(mysocket,mystring,sizeof(mystring),0); strcpy(mystring,"Welt"); send(mysocket,mystring,9,0);[/c] Das Hallo kommt auch an, nur das Welt nicht. Sieht jemand den Fehler? Grüße
Die Frage ist: Was soll überhaupt gesendet werden? [c] char mystring[20] = "Hallo\n"; // sizeof oder strlen send(mysocket,mystring,sizeof(mystring),0); // strcpy oder strncat strcpy(mystring,"Welt"); // strlen("Hallo Welt") == 10, strlen("Welt") == 4, aber warum hier 9 send(mysocket,
-
Thread
Pointer Warning..
wird mittels SizeOf() bestimt, z.B: [c] unsigned char HAllO_MSG[] ='Hallo'; SetData(HAllO_MSG, sizeof(HAllO_MSG)); [/c]
Das dachte ich mir. Wenn du sizeof "Hallo" berechnen läßt, kommt 6 heraus - warum wohl?
-
Thread
ARM9 mit SDRAM
rodata_end = . ; code_end = . ; } > flash .data : AT (ADDR(.text) + SIZEOF(.text) + SIZEOF(.rodata)) { cram_start = .; data_start = .; KEEP(*(.vectors)) *(.data) *(.data*) data_end = .; } > cram .stack (NOLOAD): { . = cram_start
cram_size - 0; stack_end = . ; cram_end = . ; } > cram .ramc : AT (ADDR(.text) + SIZEOF(.text) + SIZEOF(.rodata) + SIZEOF(.data)) { sram_start = .; ramc_start = .; *(.ramcode) ramc_end = .; } > sram .bss (NOLOAD) : { . = ALIGN(4); bss_start
-
Thread
C Verständnissfrage Pointer (ja wieder mal ;-) )
execute (const char *text) { uint16_t i; const command_t * cmd = commands; for (i=0; i < sizeof(commands) / sizeof(command_t); i++) { if (strcasecmp_P (text, cmd->text)) { cmd++; continue; } int16_t (*func)(int16_t); // found <-- Was macht das???
file, sline, MAX_BUFFER)) // read until EOL { for (i=0; i < sizeof(keywords) / sizeof(keyword_t); i++) { if (strcasecmp_P (sline, key->text)) { key++; continue; } int16_t (*varpointer)
-
Thread
[C] enum Warnungen
FOO_B } foo_enum; int enum_test (foo_enum p1) { int i32; printf ("%ld %ld\n", sizeof i32, sizeof (time_t)); i32 = time (NULL); if (p1 == FOO_A) { p1 = time (NULL); } switch (p1) { case FOO_A: printf ("A\n"); break; case 42: printf
nicht long sein. Warum gibst du die Größe hier nicht einfach mit aus? > printf ("%ld %ld\n", sizeof i32, sizeof (time_t)); (übrigens: der korrekte Format-Specifier für size_t ist %zu) aber ja, der enum sollte die gleiche Größe wie int haben. Bauform B. schrieb im Beitrag #8015775: > Au weia
-
Thread
C programm
im Code, die Zahl 20 explizit vorkommt. Ein Profi schreibt das ganze zb. so for( i = 0; i < sizeof(test)/sizeof(*test); i++ ) { test[i] = unsetzen_Spannung(); ... oder er macht folgendes: unsigned char test[20]; #define NR_TEST (sizeof(test)/sizeof(*test)) .... for(
-
Thread
Conways Game of Live zu langsam auf Z80
changes = 0; generation = 0; // Felder löschen memset(&feld_last,DEAD_CELL,sizeof(feld_last)); memset(&feld_next,DEAD_CELL,sizeof(feld_next)); // Spiel k Generationen laufen lassen k = 0; randstart = START_RANDOM; while (1) { clear();
} LedOut(n_cells); // Altes Feld = Neues Feld memcpy(feld->last,feld->next,sizeof(feld->next)); // Anzahl Veränderungen zurück return (mods); } [/code]
-
Thread
float -> uint8_t: Festlegung, dass float immer 4 byte hat
repeat; uint8_t *pointer; pointer = (uint8_t*) &data; for( repeat = 0; repeat < sizeof(float); repeat++ ) { buffer[repeat] = *pointer++; } } [/c]
repeat; uint8_t *pointer; pointer = (uint8_t*) data; for( repeat = 0; repeat < sizeof(float); repeat++ ) { *buffer[repeat] = *pointer++; } } [/c]
-
Thread
Peter Flury´s UART Routinen
Veit D. schrieb im Beitrag #5226755: > uint8_t length = sizeof(Nachricht)-1; Moin. Vielen Dank, dass du dir die Zeit nimmst. Was jedoch ist "Nachricht"? soll das etwa die 32 Bits vom Buffer sein? Oder soll da die Länge, von dem drin stehen was ich erwarte
Hallo, [c] uint8_t length = sizeof(Nachricht)-1; [/c] Nachricht ist der Name meiner Datenstruktur zum senden und empfangen. Hier kannst du den Namen deines Empfangsarrays eintragen. Also deinen Buffer.
-
Thread
uart raspberry pi, warum neuer pointer zum senden?
Muss natürlich "sizeof(str)-1" heißen :-/
#5980571: > Du merkst den Unterschied, wenn du den Variablen Werte zuweisen willst > oder per sizeof die Größe abfragst ;-) Ach ja, logisch. Also kenne ich den Unterschied ja doch, war mir nur nicht bewusst.
-
Thread
**stack smashing detected** nach Aufbau einer TCP Verbindung
bool init_comm(void){ sock_cli = socket(AF_INET,SOCK_STREAM, 0); memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(TNB_MNS_PORT); servaddr.sin_addr.s_addr = inet_addr("192.168.0.4"); //try to establish a tcp connection to
ROS_INFO("Establishing TCP connection"); if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) return false; ROS_INFO("TCP connection established"); } [/c] Die Verbindung wird in der main() Routine erzeugt: [c] int main(int argc,char** argv){ ros::
-
Thread
SD Card GPS Logger optimieren?
card/partition/file ... */ /* search end of last recording */ while(fat_read_file(fd, &entry, sizeof(entry)) > 0) { if(entry.timestamp != 0) { file_offset = -((offset_t) sizeof(entry)); fat_seek_file(fd, &file_offset, FAT_SEEK_CUR); break; } } /* main recording loop */ while(1) { gps_receive(entry.gps, sizeof(entry.gps); entry.timestamp = clock_now(); file_offset += fat_write_file(fd, &entry, sizeof(entry)); } [/c] Die eigentliche Realisierung ist aber _Deine_ Aufgabe. Grüße, Roland
-
Thread
mehrere Fragen zum Thema EEPROM im AVR
ARRAY_SIZE]; void save_to_eeprom() { eeprom_busy_wait (); eeprom_write_block(&freq_adc, 0, sizeof(freq_adc)); } void read_from_eeprom() { eeprom_busy_wait (); eeprom_read_block(&freq_adc, 0, sizeof(freq_adc)); } [/c] So in etwa. Ich habe das jetzt nicht ausprobiert.
> > void save_to_eeprom() > { > eeprom_busy_wait (); > eeprom_write_block(&freq_adc, 0, sizeof(freq_adc)); > } > > void read_from_eeprom() > { > eeprom_busy_wait (); > eeprom_read_block(&freq_adc, 0, sizeof(freq_adc)); > } > [/c] > > > > So in etwa. Ich habe das jetzt nicht
-
Thread
Linux RS232 sendet willkürlich keine Daten
cmdMeasure_send(); // fordert einen Messwert an test = read(fd_timer, &exp, sizeof(uint64_t)); } } [/c] Die Funktion serial_receiveBuffer(NULL) ruft dabei die Funktion zum lesen auf. Meine Vorgehensweise war bisher. Ich lass das Programm im Debugger solange laufen
Funktion aufgerufen. Ich hatte mir Testweise auch die Ausgabe von [c] test = read(fd_timer, &exp, sizeof(uint64_t)); printf("%d | %d \n", test, exp); [/c] anzeigen lassen und die lief unverändert weiter.
-
Thread
zugriff auf struktur oder array, was ist schneller?
} 14 15 16 unsigned foo2(unsigned ar[], unsigned index) 17 { 18 return ar[index * sizeof(TS)/sizeof(unsigned) + 3]; 19 } 20 [/c] [code] Ein alter 2008 cl macht draus: cl -O1 -c test.c dumpbin -disasm test.obj Note: Das erste Argument (ar) ist im Register ecx, edx
multipliziert index mit 16 (shl rax,4) und dividiert dann durch 4 (shr rax,2) Schreibe ich "ar[index * ( sizeof(TS)/sizeof(unsigned) ) + 3];" ist der Assembler Code von foo1 und foo2 identisch, da hier der Klammerausdruck als erstes ausgewertet wird und eine Konstante erkannt wird. [/code] Ein 2022 cl liefert
-
Thread
uart_getc von Peter Fleury
error */ j = 0; while( ( c = uart_getc() ) != '\r'&& j < sizeof(Linein) ) { uint8_t HighByte = c >> 8; uint8_t LowByte = c; Linein[ j++ ] = LowByte; } [/c]
Linein[ 0 ] = c ; j = 1; while( ( c = uart_getc() ) != '\r'&& j < sizeof(Linein) ) { Linein[ j++ ] = LowByte; } [/C]
-
Thread
Struct-Array im Flash oder doch lieber aufsplitten?
AnzahlZeilen; ++y ) { struct segmap tmp; memcpy_P( &tmp, &Array[y][ Spalte_die_ich_haben_will ], sizeof( tmp ) ); mach_was_mit( tmp ); } [/C]
size_t n) Sprich das Karl heinz Buchegger schrieb: > memcpy_P( sm, & (digits[digit][i]), sizeof( struct segmap ) ); muss umgeändert werden in > memcpy_P( &sm, & (digits[digit][i]), sizeof( struct segmap ) ); (fürs Verständnis aber unerheblich!) Vielen Dank nochmal Karl heinz, Du hast
-
Thread
[avr-gcc] PORT Definition in einer Liste speichern
lesen einer Struct aus dem Array. Das fehlt leider > noch im Wiki Einfach in einer Schleife sizeof(testpin_t) Bytes aus dem Flash lesen und auf einer im SRAM bereitgestellten testpin_t Variable ablegen. Dazu muss man ein wenig casten. Man kann dazu zb die Funktion memcpy_P() sinnvoll benutzen
" "; stream << &liste[i] << " "; stream << *(liste[i].p_portL) << " "; stream << sizeof(liste[i]); i++; stream << xpcc::endl; } while (1) { } return 0; }[/c] &liste[i] gibt mir die Adresse des jeweiligen Struct aus. sizeof(liste[i]) ergibt interessanterweise
-
Thread
STM32 lwip UDP Empfang fehlerhaft
PBUF_TRANSPORT,strlen((char*)data), PBUF_RAM); //ethTxBuffer_p = pbuf_alloc(PBUF_TRANSPORT, sizeof(clientMagicPacket_c), PBUF_RAM); if (ethTxBuffer_p == NULL){} memcpy(ethTxBuffer_p->payload, data, sizeof(data)); //memcpy(ethTxBuffer_p->payload, clientMagicPacket_c, sizeof(clientMagicPacket_c
+ SIZEOF_STRUCT_PBUF))); /* restore old payload pointer */ p->payload = payload; /* bail out unsuccessfully */ return 1; } [/c] Das Problem ist, wenn ein Paket versendet
-
Thread
Leeres Byte Array übergeben
aufrufen? SendDyn(1,0) sorgt bei mir dafür dass der Debugger ein ominöses Array 192 anzeigt. Ein sizeof(Data) ergibt eine 2? Wieso ist das alles so? Vielen Dank schonmal Thomas
@Dr Beast int *pointer; int array[123]; sizeof (pointer) - sizeof (array) = ??? Nach deiner Meinung kommt da 0 raus. Die meisten werden eine andere Meinung haben. :-P
-
Thread
Minimum Struct größe erzwingen
_t A; //1byte uint32_t B; //4byte }st_x; int main(void) { st_x gg; uint16_t test = sizeof(gg); // test = 8 while(1); } [/c]
uint32_t B; //4byte }st_x; [/c] tatsächlich ein erzwungenes Alignment der Grund für eine sizeof von 8 ist, dann wird auch nach einer Umsortierung [c] typedef struct{ uint32_t B; //4byte uint8_t A; //1byte }st_x; [/c] die sizeof immer noch 8 sein. Der Grund dafür ist, dass der Compiler
-
Thread
uint8_t* als Rückgabewert als Adresse
sollte die Adresse nicht > 32-bit sein? Also uint32_t* ? wenn du ein 32bit system hat dann: sizeof(uint8_t) == 1 aber sizeof(uint8_t*) == 4 uint8_t-Zeiger bedeutet das bei dir ein 32bit Zeiger auf einen uint8_t Wert zeigt - mehr nicht sizeof(void*) == 4 sizeof(irgendein_struct*) == 4 sizeof
-
Thread
sprintf(string,"%1.3lf",123.456) avrcc
gekommen); die avr-libc implementiert dieses jedoch nicht. Generell ist bei avr-libc (derzeit) sizeof(float) == sizeof(double) == sizeof(long double) == 4, und die Konstante 123.456 hat den Typ double. Hast du denn aber überhaupt die Gleitkommaversion der printf-Bibliothek gelinkt?
-
Thread
malloc() Programm terminiert nicht
Gibt einlesen_size() denn das richtige zurück (Dateigröße / sizeof(int))? Und: Felix W. schrieb im Beitrag #6335498: > free(ptr); Eine Datei schließt man mit fclose(), nicht mit free().
[c] array = malloc( size * sizeof(*array)) [/c] Im C Standard wird dir garantiert das sich jeder Pointer nach (void *) und wieder zurück casten lassen kann, ohne Eigenschaften zu verlieren. Das heißt in diesen Fall, das der cast
-
Thread
C# Übergabe Char-Array sizeof wird ein Byte größer
(sizeof(WERT)); SendRemoteCommand(&WERT[0]); } void SendRemoteCommand(uint8_t *cmdValue) { Serial.println(sizeof(cmdValue)); } [/c]
Hi, sizeof(cmdValue) gibt Dir die Größe des Pointers zurück. Das wirst Du wohl nicht haben wollen. Du willst die Größe des Arrays - die aber kennt die Funktion an der Stelle nicht. Mit C# übrigens hat das nix
-
Thread
Array mit memalign
] trellis_value_t **trellis_matrix; trellis_matrix = (trellis_value_t**) memalign(16,10 *sizeof(trellis_value_t*)); trellis_matrix = (trellis_value_t*) memalign(16,100 *sizeof(trellis_value_t*)); uint32_t l; uint32_t j = 100 - 1; do { l = 10 - 1; do { trellis_matrix
trellis_value_t **trellis_matrix; trellis_matrix = (trellis_value_t**) memalign(16, 100 * sizeof(trellis_value_t*)); uint32_t l = 100 - 1; do { trellis_matrix[l] = (trellis_value_t*) memalign(16, 10 * sizeof(trellis_value_t)); } while (l--); [/c]
-
Thread
Länge Array aus Pointer bestimmen?
: [c] int main() { int days[] = {1,2,3,4,5}; int *ptr = days; printf("%u\n", sizeof(days)); printf("%u\n", sizeof(ptr)); return 0; } [/c]
int main() { int days[5] = {1,2,3,4,5}; int (*ptr)[5] = &days; printf("%u\n", sizeof(days)); printf("%u\n", sizeof(*ptr)); return 0; } [/c] In C99 und GCC gibt es Arrays variabler Länge, was hier vielleicht besser passen könnte, aber da muss ich vorerst passen.
-
Thread
i2c buffer in array übergeben funktioniert nicht
i, char *b) { printf("0x%x, %d, 0x%x\n", a, i, b); } int main(void) { E6_work(data, sizeof(data), net.ip); // OK E6_work(&data[0], sizeof(data), &net.ip[0]); // OK /* structtest.c: In function 'main': structtest.c:18:3: warning: passing argument 1 of 'E6_work' from incompatible pointer
structtest.c:9:6: note: expected 'char *' but argument is of type 'char (*)[42]' */ E6_work(&data, sizeof(data), &net.ip); // nicht OK s.o. } [/C]
-
Thread
NXP K64, GCC, Variablenspeicher nach Reset nicht überschreiben. Wie?
+ SIZEOF(.data); /* Global data not cleared after reset. */ .noinit ADDR(.bss) + SIZEOF (.bss) : AT (ADDR (.noinit)) { PROVIDE (__noinit_start = .) ; *(.noinit*) PROVIDE (__noinit_end
Johann L. schrieb im Beitrag #5251571: > .bss ADDR(.data) + SIZEOF (.data) : AT (ADDR (.bss)) > { > PROVIDE (__bss_start = .) ; > ... > PROVIDE (__bss_end = .) ; > } > data Hm, was ist hier der Unterschied zum einfacheren: [code] .bss
-
Thread
7-zip Kommandozeile
STARTUPINFO si; PROCESS_INFORMATION pi; memset (&si, 0, sizeof (si)); si.cb = sizeof (si); si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_SHOWNORMAL; if (CreateProcess (NULL, "c:\\> 7z.exe a -tzip \"+base_archive_File+\" \"+test+\" -r",
newZipFile="c:\\> 7z.exe a -tzip "+base_archive_File+" "+test+" -r"; memset(&si, 0, sizeof(STARTUPINFO)); si.cb = sizeof(STARTUPINFO); si.dwFlags = STARTF_USESHOWWINDOW |STARTF_USESTDHANDLES; si.wShowWindow = SW_SHOWNORMAL; if(!CreateProcess(ZipPath.c_str
-
Thread
EEPROM Struct mit read und write block kopieren?
komplette Struktur aus dem eeprom ins ram geladen... [C] eeprom_read_block(&RAM_Data,&EEP_Data,sizeof(Speicherdaten)); [/C] das klappt scheinbar auch. Um nun nur die "Foo" Struktur ins EEPROM zu schreiben benutze ich folgende Codezeile: [C] eeprom_write_block(&RAM_Data,&EEP_Data,sizeof(((Speicherdaten
eeprom_write_block( & RAM_Data.Foo, & EEP_Data.Foo, sizeof( RAM_Data.Foo ) ); [/C] > allerdings nicht mit der Array-Struktur "Bar"... > [C] > eeprom_write_block(&RAM_Data,&EEP_Data,sizeof(((Speicherdaten*)0)->Bar[1])); > [/C] siehst du. Hier hast
-
Thread
absolute Adressen in C?
berechnet, und *alle weiteren* Variablen (nicht nur einzelne)danach anordnet. Evtl. hilft es, mit sizeof die Größe der einzelnen chars und floats und Array mal anzeigen zu lassen. Was ich auch schon öfters hatte: Der Compiler rechnet Konstanten erstmal mit 16 Bits, außer man hängt ein L daran an.
Na, super :-) Mit L klappte es wie gewünscht habe es jetzt mit sizeof gelöst: const char dummy[0x10000-sizeof(kennlinie1)-sizeof(kennlinie2)-sizeof(kennlinie3)]; passt :-) Da wiederum brauch ich kein L. Egal, vielen Dank
-
Thread
EProm im AVRGCC Tutorial
mit etwas Absicherung betr. der Länge */ eeprom_read_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer)); /* und nun mit 16-Bit Array */ eeprom_read_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer)); /* Datenblock in EEPROM schreiben */ eeprom_write_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer)); eeprom_write_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer)); } [/c] Obiges Beispiel findet man im Tutorial zum AVRGCC. Leider verstehe ich das nicht. MyByteBuffer
-
Thread
Struc as header einbinden - Compiler dreht durch
FX_MODE_PIXEL_MAP, FX_MODE_PIXEL_MAP, 1, 1, 0, 0 }; void eepromSave() { for (uint16_t t = 0; t < sizeof(deviceSettings); t++) EEPROM.write(CONFIG_START + t, *((char*)&deviceSettings + t)); EEPROM.commit(); } void eepromLoad() { // To make sure there are settings, and they are YOURS
deviceSettings; // Copy data to deviceSettings structure for (uint16_t t = 0; t < sizeof(deviceSettings); t++) *((char*)&deviceSettings + t) = EEPROM.read(CONFIG_START + t); // If we want to restore all our settings if (deviceSettings.resetCounter >= 5 || deviceSettings.wdtCounter
-
Thread
C Frage: auslesen eines *arrays[]
anschliessend soll er in einen Buffer: [c] char Buff[1025]; memset(Buff, '0', sizeof(Buff)); /* Hier code zum umwandeln von argv[3] */ write(sockfd, Buff, strlen(Buff)); <- schreiben der Daten [/c]
hin, da scanf bei %x einen Zeiger auf int erwartet. Du übergibst aber einen Zeiger auf char. Da sizeof(char) != sizeof(int) schreibt scanf da Bereiche, die nicht mehr zu c gehören.
-
Thread
Spaßig: "% 16" vs. "& 0x0F"
Üblicherweise findet sich dann eine Option, um zum Standard konform zu sein. GCC kennt -mint8, damit ist sizeof(int)==sizeof(char). Die avrlib kannst du dann allerdings vergessen.
...GCC kennt -mint8, damit ist sizeof(int)==sizeof(char). Die avrlib kannst du dann allerdings vergessen.... Was ist damit gemeint??
-
Thread
Schreibunterlage für Programmierer
anderen (und die obigen auch): | ——————————————————————————————————————— | /typ/ | sizeof (/typ/) * CHAR_BIT | ——————————————————————————————————————— 8<----------------------------------------- Habe ich einen vergessen? Ich glaube nicht ;-) Die Unterlage darf übrigens frei
Alle anderen (und die obigen auch): | ——————————————————————————————————————— | typ | sizeof (typ) * CHAR_BIT | ——————————————————————————————————————— 8<-----------------------------------------
-
Thread
Problem EEPROM nutzung
void readSetandInitStepper(){ cli(); eeprom_read_block(&stepperSetXYZ, &eestepperSetXYZ, sizeof(stepperSetXYZ)); sei(); } void writeStepperSettingstoEEPROM(){ cli(); eeprom_update_block(&stepperSetXYZ, &eestepperSetXYZ, sizeof(stepperSetXYZ)); sei(); } [/c] Nun ist mein Problem
readSetandInitStepper(){ > cli(); > eeprom_read_block(&stepperSetXYZ, &eestepperSetXYZ, > sizeof(stepperSetXYZ)); > sei(); > } > void writeStepperSettingstoEEPROM(){ > cli(); > eeprom_update_block(&stepperSetXYZ, &eestepperSetXYZ, > sizeof(stepperSetXYZ)); > sei(); > } eehm
-
Thread
c++: Lookup-Table Inhalt zur Compilezeit erstellen
template < typename ... Ts > struct table< std::tuple< Ts... > > { static const int content[ sizeof ...(Ts) ]; }; template < typename ... Ts > const int table< std::tuple< Ts... > >::content[ sizeof ...(Ts) ] = { fkt< Ts >::result... }; template < int I > using int_c = std::integral_constant
template< typename > class F > struct table< std::tuple< Ts... >, F > { static const int content[ sizeof ...(Ts) ]; }; template < typename ... Ts, template< typename > class F > const int table< std::tuple< Ts... >, F >::content[ sizeof ...(Ts) ] = { F< Ts >::result... }; [/c] Und zu guter
-
Thread
Algorithmus für Flächenvergleich
{ 14.0, 4.0 }, { 14.0, 0.0 } }; struct Face FaceA = { sizeof(Points)/sizeof(Points[0]), Points ); [/C] oder [C] struct Point { double x; doubly y; }; struct Edge { struct Point* startPoint; struct Point* endPoint; }; struct Face
], &Points[5] }, { &Points[5], &Points[0] } }; struct Face FaceA = { sizeof(Edges)/sizeof(Edges[0]), Edges }; [/C] oder ( noch komplexere Datenstrutur einsetzen. Je nachdem was man alles braucht. Gipfel ist wohl im 3D die 'Winged Edge Data Structure'. Aber die wird openCascade
-
Thread
Array aus SD Karte laden
knirsch! Lass dir ein wenig Platz um zumindest kleinere Fehler auffangen zu können. Arbeite mit sizeof um Arraygrenzen zu prüfen, das mindeste sind aber ein paar #define um Arraygrößen festzulegen und dann mit diesen #define die Bereichsgrenzen im Programm zu prüfen. Fread erwartet von dir lediglich
( &ReadBuffer, 1 ) != -1 ) { if( ReadBuffer == Terminator ) break; if( i < sizeof( mapBuffer ) - 1 ) mapBuffer[ i++ ] = ReadBuffer; } mapBuffer[ i ] = '\0'; return atoi( mapBuffer ); } void get_map(void) { uint16_t torque; uint16_t rev; while( Fread
-
Thread
Bilderkennung (Rechtecke)
points - // 4 points per square (the square's vertices) CvSeq* squares = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvPoint), storage ); cvFindContours( canny, storage, &contours, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) ); // test
accuracy proportional // to the contour perimeter result = cvApproxPoly( contours, sizeof(CvContour), storage, CV_POLY_APPROX_DP, cvContourPerimeter(contours)*0.02, 0 ); // square contours should have 4 vertices after approximation // relatively large area
-
Thread
Datenaustausch von µC und PC
state_request[] = "SR"; // Statusabfrage char mystring[40]; while(1) { uart_gets(mystring, sizeof(mystring)); if(strcmp(mystring, state_request) == 0) { uart_puts("state_request\r\n"); clear_string(mystring, sizeof(mystring)); } else { uart_puts(mystring); clear_string(mystring, sizeof(mystring)); } } } [/c]
-
Thread
C variablen in dateien aufteilen
auch wenn ihm die Struktur dann bekannt ist, wird es nicht funktionieren, denn ... [c]used_data = sizeof(tx);[/c] .. used_data enthält hier nur die Größe eines Pointers, nicht die Größe der Struktur, und schon gar nicht die Anzahl der Array-Elemente.
hi stefan also du hattest recht gehabt ... hatte das include vergessen! das mit dem sizeof stimmt auch... nur wie gehts? in main kann ich ja sizeof(data_field)/sizeof(struct spi) machen und bekomme dann das richtige zurück. aber in der fkt krieg ich nur die länge des ptr... muss ich die
-
Thread
avr-gcc: __DATE__ formatieren / "initializer element is not constant"
setup() { Serial.begin(9600); Serial.print(F("Date of Compilation:")); for (int i=0;i<sizeof(compileDate);i++) Serial.write(pgm_read_byte(&compileDate[i])); Serial.println(); } void loop() { // put your main code here, to run repeatedly: } [/c]
setup() { Serial.begin(9600); Serial.print(F("Date of Compilation:")); for (int i=0;i<sizeof(compileDate);i++) Serial.write(pgm_read_byte(&compileDate[i])); Serial.println(); Serial.print(F("Nach der Umformatierung:")); char buf[20]; sprintf_P(buf, PSTR("%04d/%02d/%02d_%02d
-
Thread
Latex Makros definieren
100, 10000, UINT_MAX }; char str[11]; int i; printf("letterizeAZ:\n"); for(i=0; i<sizeof values / sizeof(int); i++) printf("\\def\\ulmer%s{blabla}\n", letterizeAZ(values[i], str)); printf("\nletterizeAJ:\n"); for(i=0; i<sizeof values / sizeof(int); i++) printf("\\def\\ulmer
-
Thread
RAM überlauf nach einiger Zeit?
, Führt dieser Code: [c] char* UART_gets() { uint8_t length = 1; char* line = malloc(sizeof(char) * length); memset(line, 0, length); line[0] = -1; while ( 1 ) { line[length - 1] = UART_getc(); if ( line[length - 1] == '\0') break; else { length++; char* newLine = realloc(line, sizeof(char) * length); if ( newLine != NULL ) line = newLine; else break; line[length - 1] = 0; } } return line; } [/c] zu einem Überlaufen
-
Thread
C++17 initialzer list aus std::array
(sizeof...(AA) == (rows - 1), "wrong number of rows"); static_assert((std::is_same_v<ItemType, typename AA::value_type> && ...)); } template<typename... VV> constexpr auto operator()(VV... rv) { static_assert(sizeof...(VV) == columns, "wrong number of values to form a complete row"); // static_assert((std::is_same_v<ItemType, VV> && ...), "use always the same type"); auto n = [&]<auto... RR>(