-
Thread
double in bytes konvertieren/wiedergeben
man sowas? nein, denn shift geht nur für int. ich würde es mit memcpy machen. uint8_t b[sizeof(float)]; float f; memcpy( b, &f, sizeof( float ) );
-
Thread
C-Programmieren LED & Schalter
u8State]; if ( ++u32Tick < u32TimeToWait ) return; u32Tick = 0; u8Max = (uint8_t) ( sizeof(scLedData)/sizeof(scLedData[0]) ); if ( ++u8State >= u8Max ) { u8State = 0; } PORTB = scLedData[u8State].u08Port_b; PORTD = scLedData[u8State].u08Port_d; } [/c]
-
Thread
Sonderzeichen mit sprintf
musst explizit nach (double) casten. > Es funktioniert ja auch Zufällig, weil im AVR-GCC sizeof(float) == sizeof(double) ist.
-
Thread
array Zeigerarithmetik
Data[i] = Data_init[0][i]; }[/c] Oder einfacher mit memcpy: [c]memcpy (Data, Data_init[0], sizeof(Data));[/c] Oder wenn du doch was mit Zeigern machen möchtest, kannst du Data als Zeiger deklarieren und auf die Zeile zeigen lassen. Dadurch werden keine Daten kopiert, sondern Data verweist einfach
20,30,40,50,60}, {25,35,45,55,65}}; uint8_t Data[5]; memcpy (Data, Matrix[1], sizeof(Data))[/c] Ergibt in Data: 15 0 25 0 35 sollte ergeben: 15 25 35 45 55 Offenbar wird zwischen 2 Elmenten immer eine 0 mit eingefügt- warum? alternativ [c] int Matrix[4][5] = { {10,20,30,40,50
-
Thread
Datensatz aus UART "gewinnen"
trotzdem mal defensiv programmieren, also direkt vor dem Zugriff auf Gültigkeit prüfen: [c] if( i < (sizeof( x ) / sizeof( x[0] ))){ x[i] = data; } [/c]
-
Thread
avrgcc calloc versus static
// 100 -> "100" also konstante Stringlänge char *buf = (char*) calloc (laenge+1,sizeof(char)); -> 1. Versuch oder static char buf[laenge+1] ={0}; -> 2.Versuch ..... return (&*(buf+i+1))); } Ich habe bemerkt das,das nicht das selbe zu sein scheint. Der RETURN von m8_itoa(); landet in char *out_buf = (char*) calloc (laenge+1,sizeof(char)); ,der wiederum mit einigen statischen Strings verkettet, mit lcd_puts(out_buf); ausgegeben wird. Beim ersten Versuch bekomme ich beim Einschaltvorgang immer undef. Zeichen auf das DISPLAY
-
Thread
Variable aus dem PC in uc speichern
Peter, hier mein code: main() { ... while(1) { uart_gets(tmp, sizeof(tmp) ); split(tmp, sizeof(tmp) ); } } unsigned char Getch1(void) // Waits for and returns incoming char { unsigned char rxchar; for(;;) { while(SSR1_RDRF == 0)
-
Thread
ADC-Kanäle sukzessive abfragen
Beim 8Bit AVR 1 Byte. Lasse dir auf deiner Zielplattform von allen Datentypen die Größe mittels sizeof() ausgeben. bool kann nur Werte von true/false annehmen. Das ist die Eigenschaft des Datentyps. https://wandbox.org/permlink/Fncn3pcBbPohZ6Vl Kannst Clone & Edit drücken und Run. Der Wert wird
8Bit AVR 1 > Byte. Lasse dir auf deiner Zielplattform von allen Datentypen die Größe > mittels sizeof() ausgeben. bool kann nur Werte von true/false annehmen. > Das ist die Eigenschaft des Datentyps. Dann bedeutet das, dass mehrere bools in so einer Struct nicht in ein Byte gepackt werden? D.h
-
Thread
Analoger Messwert nach Sleep falsch
//delay(50); ID = 1; //a++; keep_ADCSRA = ADCSRA; memset(daten, 0, sizeof daten); // Inhalt der Variblen (char) löschen digitalWrite(strom, HIGH); digitalWrite(PIN_LED, HIGH); delay(450); sprintf(daten, "%d,%d", ID, analogRead
Auf der Empfängerseite habe ich folgende Zeile vergessen [code] memset(StringReceived, 0, sizeof(StringReceived)); [/code] Manchmal sucht man einfach an der falschen Stelle :-) Danke für eure Hilfe Viele Grüße Torsten
-
Thread
Feldzugriff modulo
ArrayPointer[n] ist das gleiche wie *(ArrayPointer + n * sizeof(ArrayTyp))
schrieb im Beitrag #3154087: > ArrayPointer[n] ist das gleiche wie > > *(ArrayPointer + n * sizeof(ArrayTyp)) *NEIN*. ArrayPointer[n] ist das gleiche wie *(ArrayPointer + n);
-
Thread
Verständnisfrage zu diesem Microcontroller
das macht es verständlich, dass ein '''char''' == '''int''' == 16 Bit ist. Mit allen Konsequenzen: sizeof(char) == 1 (per Definition) und sizeof(long) == 2! Bytes (Oktetts) sind schlicht nicht adressierbar. Das gab es IMHO auch beim Z800, den 16-Bit-Nachfolger des Z80. Man hatte damals beschlossen, die
-
Thread
Verschiedene Zeiger auf dieselbe Adresse
{ unsigned long ul; unsigned char uc[4]; }u; u *buffer; buffer = (u*)malloc(samples*sizeof(u)); buffer[n].ul = 1234; buffer[n].uc[0] .. buffer[n].uc[3] Gruss Helmi
pointer; // angenommen, daß "samples" die Anzahl der 32-Bit-Werte ist buffer = malloc(samples * sizeof (uint32_t)); // buffer füllen // pointer = (uint32_t *) buffer; // und pointer nutzen for (i = 0; i < samples; i++) { pointer[i] = irgendwas; } [/c]
-
Thread
DMX - kein Empfang
UCSZ10); UCSR1B = (1<<RXEN1)|(1<<RXCIE1); gDmxState= IDLE; uint16_t i; for (i=0; i<sizeof(DmxRxField); i++) { DmxRxField[i]= 0; } DmxAddress = 1; } ISR (USART1_RX_vect) { uint8_t USARTstate= UCSR1A; //get state uint8_t DmxByte= (UDR1); //
_t *DmxPnt; DmxPnt= gDmxPnt; *DmxPnt= DmxByte; if (++DmxPnt >= (DmxRxField +sizeof(DmxRxField))) //all ch received? { gDmxState= IDLE; IndFlags |= (1<<VALID_DMX); } else gDmxPnt= DmxPnt; //PORTD &= ~( 1 << PD7 ); } //PORTD
-
Thread
C Anfänge: User input string, fgets(), max. Arraygröße
[c] char string[4]; scanf("%3s", string); [/c] oder [c] char string[4]; scanf("%*s", sizeof(string)-1, string); [/c]
buf[32]; // short lines ... int i = 0; printf("Anfang\n"); while (ngets(buf, sizeof(buf))) printf("Zeile %d: '%s'\n", ++i, buf); printf("Ende\n"); [/c] > Wegen der letzten drei Zeilen. Nur die letzte. Die beiden davor kümmern sich darum, dass der Buffer immer
-
Thread
Programm unklar / Sinn von malloc
z=0, s=0; double *matrix; /* Speicher reservieren */ matrix = (double *) malloc(3*3 * sizeof(double)); /* Matrixelemente einlesen */ for (z=0; z<3; ++z){ for (s=0; s<3; ++s){ printf("Element %i/%i: ", z, s); scanf("%lf", &matrix[ z*3 + s ]); } } /*
double matrix[3*3];[/c] wir der Speicher im Stack angelegt und bei [c]double* matrix = maloc(3*3*sizeof(double));[/c] im Heap Am besten liest du dir diesen Artikel mal durch http://tutorial.schornboeck.net/stack_heap.htm
-
Thread
Fehlermeldung Zugriffsverletzung, aber wo?
bearbeiten?\n"); scanf("%d", &anzahl); fflush(stdin); zahlen = (int*)malloc((anzahl) * sizeof(int)); for (int i = 1; i <= anzahl; i++){ printf("Zahl[%d]:",i); scanf("%d", &zahlen[i]); fflush(stdin); } sortieren(zahlen, anzahl); system("pause"); return
bearbeiten?\n"); scanf("%d", &anzahl); fflush(stdin); zahlen = (int*)malloc((anzahl+1) * sizeof(int)); for (int i = 0; i < anzahl; i++){ printf("Zahl[%d]:",i); scanf("%d", &zahlen[i]); fflush(stdin); } system("pause"); return 0; }
-
Thread
User Sections GCC
} SECTIONS { ... .text : { ... } > text .data : AT (ADDR (.text) + SIZEOF (.text)) { PROVIDE (__data_start = .) ; ... PROVIDE (__data_end = .) ; } > data .bss : AT (ADDR (.bss)) { PROVIDE (__bss_start = .) ; *(.bss) *(.bss
} > data __data_load_start = LOADADDR(.data); __data_load_end = __data_load_start + SIZEOF(.data); /* Global data not cleared after reset. */ .noinit : { PROVIDE (__noinit_start = .) ; *(.noinit*) PROVIDE (__noinit_end = .) ; _end = . ; PROVIDE (__
-
Thread
Ausführen von Funktionen alle x ms
delay(100); } void increaseLoopCounter() { lastValuePointer++; int arraySize = sizeof(results)/sizeof(char *); if(lastValuePointer == arraySize) lastValuePointer = 0; loopCount++; if(loopCount > 8) loopCount = 0; } void loop() { String valueToCheck
-
Thread
Problem bei einem Verwaltungsprogramm
else if(ptr1==first_element) { first_element=malloc(sizeof(struct verwaltung)); first_element->nummer=num; strcpy(first_element->name, nam); first_element->next=ptr1; } else {
while(ptr2->next!= ptr1) ptr2=ptr2->next; ptr1=malloc(sizeof(struct verwaltung)); ptr1->nummer=num; strcpy(ptr1->name,nam); ptr1->next=ptr2->next; ptr2->next=ptr1; } } } [/c] Das was
-
Thread
VisualDSP++ Bild laden
free\n", heap_space_unused(heap_index)); fb = heap_malloc(heap_index, TFT_WIDTH * TFT_HEIGHT * sizeof(uint16_t)); if(fb == NULL) { printf("ERROR: Not enough memory in SDRAM!\n"); exit(EXIT_FAILURE); } [/c] Danach habe ich einfach einen Breakpoint gesetzt, die Adresse in fb ausgelesen
free\n", heap_space_unused(heap_index)); fb = heap_malloc(heap_index, TFT_WIDTH * TFT_HEIGHT * sizeof(uint16_t)); if(fb == NULL) { printf("ERROR: Not enough memory in SDRAM!\n"); exit(EXIT_FAILURE); }[/c] Dann bekomm ich nur die Fehlermeldung: [c]".\SignDetect_Blackfin.c",
-
Thread
IL3829 - E-Paper Display Treiber
auf Ausgang setzen */ IL3829_D_C_DDR |= ( 1 << IL3829_D_C_bp ); il3829WriteCmd( init , sizeof( init ) / sizeof( init[0] ) ); } static inline void il3829WriteCmd( uint8_t *buff , size_t leng ) { /* * Steuerpin "D/C" muss bei einem Kommando auf "low" gezogen
-
Thread
Uhr des µC stellen über c# keine funktion
void Uhrstellen() { uart_gets( line, sizeof( line ) ); } wollte dann beim einlesen so die daten reinholen und auslesen. und damit die Uhr stellen. diese läuft soweit allerdings startet sie immer wieder erst bei 0. und sollte über string
" ); uart_puts( "waiting for string, terminate with \\n\r\n" ); uart_gets( line, sizeof( line ) ); uart_puts( "received: " ); uart_puts( line ); uart_puts( "\r\n" ); } } } [/C] und damit experimentierst du jetzt erst mal. Vom Hyperterminal aus!
-
Thread
Zuweisung zwischen unterschiedlichen Pointern
in den (Welt-)Raum. *UNiON* [c] typedef union { uint64_t o; // Oktal Byte = 8*sizeof(Byte) = 8*8 uint8_t b[8]; // Index E {0,..,7} } union_64bit_t; union_64bit_t my_var; // Zugriff uint64_t u_64data = my_var.o; uint8_t u_8data = my_var.b[0]; [/c] [c] // Zugriff
geschrieben. > also den Wert von array. Nein. Der Wert von /array/ (wenn man den Namen ohne sizeof-Operator in einem Ausdruck verwendet) ist die Adresse des ersten Array-Elements (genauer gesagt der Wert des Zeigers auf das erste Element). Den willst und brauchst du aber nicht. hausmeister
-
Thread
Vergleich zweier uint8_t
ISO-Doc zu suchen, aber wichtig ist das wirklich nicht. Unsigned Int wird nur verwendet, wenn z.B. sizeof(unsigned char)==sizeof(int), aber das müsste schon ein sehr merkwürdiger Compiler sein. > Der springende Punkt: Ein int kann alle Werte eines unsigned char > aufnehmen. Von daher passiert bei
-
Thread
struct als Funktionsrückgabe
allokieren lassen: struct TESTSTRUCT *getValues(void) { struct TESTSTRUCT *tempstruct = malloc (sizeof (struct TESTSTRUCT)); /* hier wird die Struct gefüllt */ tempstruct->success = 1; return tempstruct; } Hier muss man dann darauf achten, dass die zurückgegebene Struktur nicht von alleine
getValues(&values)) /* Auswerten der values */ Alternativ: struct TESTSTRUCT *values = malloc (sizeof (struct TESTSTRUCT)); if (getValues(values)) /* Auswerten der values */ free (values); Das sind nur einige von diversen Möglichkeiten. Wenn man z.B. weiß, dass man mit einem globalen Struct
-
Thread
Menüstruktur
struct menue *pointer; if(first == NULL) { if((first = (struct menue *) malloc(sizeof(struct menue))) == NULL) { return; } set_cursor(0, 1); lcd_string (strcpy(first->titel, t)); set_cursor(0, 2); lcd_string (strcpy(first->punkt1, p1));
pointer->next != NULL) pointer=pointer->next; if((pointer->next =(struct menue *) malloc(sizeof(struct menue))) == NULL) { return; } pointer=pointer->next; /* zeiger auf neuen Speicherplatz */ set_cursor(0, 1); lcd_string (strcpy(first->titel
-
Thread
C: Array mehrere Zellen beschreiben
[c] memset(array,0,sizeof(array)); [/c] Oder du schaust in *dein* C-Buch. Bitte
kopiert werden. In deinem Fall sähe diese so aus: [c] memcpy(array, (int []){1, 2, 3, 4, 5}, sizeof array); [/c] Das komische Konstrukt in der Mitte nennt sich offiziell "compound literal" und wurde im C99-Standard eingeführt. Sehr Alte C-Compiler unterstützen es möglicherweise nicht. Auch
-
Thread
externe variablen richtig angelegt
/*in canmessages.c*/ //irgendwo in ner Funktion (mit Beispiel 10) repeat_blocks = malloc(10 * sizeof(can_messageblock_struct)); //... Speicher reservieren für jede Nachricht repeat_blocks[repeatindex].message = malloc(sizeof(can_message_struct)*20); //... Zugreifen tue ich dann in etwa so: repeat_blocks
hier kann kein Speicher mehr reserviert werden message_block->message[blockposition].data = malloc(sizeof(uint8_t) * message_block->message[blockposition].datalength); [/c] Irgendwas ist da doch faul, oder? Als µC nutze ich eien AT90CAN128. Evtl noch nützliche Infos zur Speichernutzung: .data size
-
Thread
AVR, progmenu array mit strings und unsigned char: will nicht so recht !
{1, "mvi a,?"}, {2, "cmpg a,?"}, {3, '\0'}, {4, "cdis"}, }; const byte ANZAHL = sizeof(daten) / sizeof(Struktur); void setup() { Serial.begin(115200); Serial.println("\nStart"); // klassische Variante // for (byte i=0; i<ANZAHL; i++) // for Range-Based Variante
-
Thread
uint16_t array über UART übertragen
Oder so? for (int ix = 0; ix < sizeof(wert); ix++) { // cast Startadresse des arrays zu dem gewünschten Typ* // Verwende Zeigerarithmetik für die gewünschte Schrittweite // und dereferenziere den resultierenden Zeiger
casten willst, brauchst Du nur die 1 Zeile so ändern: uint8_t wert[] .... for (int ix = 0; ix < sizeof(wert) / 4; ix++) { SendSPI( *(((u32*)&wert[0]) + ix) );
-
Thread
Arduino EEPROM Kontrolle
T &t ){ EEPtr e = idx; uint8_t *ptr = (uint8_t*) &t; for( int count = sizeof(T) ; count ; --count, ++e ) *ptr++ = *e; return t; } template< typename T > const T &put( int idx, const T &t ){ EEPtr e = idx; const uint8_t *ptr = (const uint8_t*) &t; for( int count = sizeof(T) ; count ; --count, ++e ) (*e).update( *ptr++ ); return t; } }; [/c] und hier ran sieht man, dass im Falle eines Falles update() benutzt wird, d.h. ist der Wert, der geschrieben
-
Thread
printf format strings prüfen?
} if (format == NULL || *format == '\0') { format = "%F %T"; } strftime (text, sizeof text, format, localtime (&unixtime)); return text; }[/c] Ja, natürlich kann ich das mount auch anders formulieren, da gibt es nur vier bekannte Dateisysteme. Aber wie man ein Datum schreibt,
options) doch lieber. [c]static const char dosopts[] = "check=strict,showexec"; snprintf (fatopts, sizeof fatopts, "time_offset=%ld,uid=%d,gid=%d", timezone / 60L, uid, uid); if (strcmp (fstype, "vfat") == 0 || strcmp (fstype, "msdos") == 0) { asprintf (&options, "%s,%s,%s", errors, fatopts
-
Thread
Konzept für einen ATtiny-Bootloader in C
[c] struct BOOT_FUNCTIONS boot; ... memcpy_P (&boot, (void *) BOOTLOADER_FUNCTIONS_ADDRESS, sizeof BOOTLOADER_FUNCTIONS); [/c] Dann geschieht der Aufruf über boot.uart_poll() bzw. boot.uart_getc(). Das ist etwas effizienter, hat aber den Nachteil, dass die Struct 2x im SRAM liegt - einmal im
Tabelle reinlaufen und der Linker bekommt Probleme. Der Bootloader könnte größer werden als die "sizeof (section_bootloader) - sizeof (BOOTLOADER_FUNCTIONS)", ja. Das kann man aber leicht abbiegen. Man definiert eine eigene Section die auf FLASHSIZE - sizeof (BOOTLOADER_FUNCTIONS) beginnt. Dann bemerkt
-
Thread
char Array für ultoa()
bevor das Programm überhaupt gestartet wurde. Sagen wir mal: So gut wie immer. Für den Operator sizeof ist garantiert, dass er bis auf VLAs den übergebenen Operanden nicht evaluiert und damit auch im Falle eines Zeiger nicht dereferenziert. Für [C] char* p = 0; sizeof *p; [/C] ist also garantiert
und sizeof nicht dereferenziert, obwohl man's hinschreibt). ;-) Deinen restlichen Ausführungen kann ich folgen. Danke dafür.
-
Thread
malloc und Strukturen gehen nicht
[30]; }; struct Daten* Pointer = NULL; puts("Datenbank:"); Pointer=(char*)malloc(sizeof(struct Daten)); if(Pointer == NULL) { puts("Arbeitsspeicher ist voll!"); fflush(stdin); getchar(); exit(0); } Daten->Personennummer = 1; strcpy(Daten->Vorname
deine struct? OK nein ist er nicht :) Das hier hat funktioniert: Pointer=(struct Daten*)malloc(sizeof(struct Daten)); Peter II schrieb im Beitrag #2599272: > weil eine dynamische speicherverwaltung zu ineffizient ist, zu langsam > und fehler sich damit noch schwerer finden lassen. OK dann
-
Thread
ESP32 HTTP Client: Fehlercode -1 nach einiger Zeit?
/* Datensicherung im EEPROM rolierend */ void SafeToEE(tables_t* data) { const int len = sizeof(*data); /* Erzeuge eine zufällige Blockadresse */ const int max_blocks = EESIZE / len; int newBlock = random(0, max_blocks); EE_WritePtr = newBlock * len; // Zieladresse im EEPROM
const uint32_t blknrOffs = (uintptr_t) & (data->blknr) - (uintptr_t) & (*data); const int len = sizeof(*data); /* EE durcchsuchen nach gültigem valid */ int16_t marke, id; while (EE_AdrPtr < (EESIZE - len)) { myMem.get(EE_AdrPtr + validOffs, marke); // Valid Marke auslesen als int16
-
Thread
leidiges EEPROM schreiben
#define OFFSET_ADDR (void*)0x10 ... eeprom_read_block( &offset, OFFSET_ADDR, sizeof( offset )); ... eeprom_write_block( &adc_sum, OFFSET_ADDR, sizeof( adc_sum )); [/C] Bei mir funktionierts jedenfalls. Peter
-
Thread
EEPROM read_block
Strings den man einlesen will noch >gar nicht existiert, Aber die Länge der Variablen ist mit sizeof bestimmbar. Und ich denke, das sollte dahin, weil dann das eeprom-read-block weiß, wie groß der puffer maximal ist. sonst könnten nachfolgende variablen überschrieben werden..
Strings den man einlesen will noch >>gar nicht existiert, > Aber die Länge der Variablen ist mit sizeof bestimmbar. > > Und ich denke, das sollte dahin, weil dann das eeprom-read-block weiß, > wie groß der puffer maximal ist. sonst könnten nachfolgende variablen > überschrieben werden.. > Stimmt
-
Thread
Kommunikation mit NIOSII SPI
rd_id_cmd[] = {epcs_rdid}; alt_u8 id[3]; alt_avalon_spi_command( base, 0, sizeof(rd_id_cmd) / sizeof(*rd_id_cmd), rd_id_cmd, 3, id, 0 ); return (alt_u32) ((id[0] << 16) | (id[1] << 8) | id[2]);[/c] An dieser Stelle bleibt er hängen: [c]/* Wait
-
Thread
Probleme mit dem EEprom AVR Mega8
int Versuch[50]; for (i=0;i<=50;i++) { Versuch[i]=0; } eeprom_write_block(Versuch,0,sizeof(Versuch)); } Nach dem Auslesen des EEprom sollten die ersten 100Byte 0 sein. Im Sim. ist es auch so... Danke Malte
Versuch[50]; for (i=0;i<50;i++) { Versuch[i]=0; } eeprom_write_block(&Versuch,&EEMEMVersuch,sizeof(Versuch)); } Null erscheint mit keine gültige Pointer Adresse.