-
Thread
goto verpönt - was dann nehmen?
gZ6_g, Z7_g }; if (z_measurement_g) { motion *priorRankedAxis = findPriorRankedAxis(allAxes,sizeof(allAxes)); if (priorRankedAxis != NULL){ stepper_handle(priorRankedAxis); } } else{ for (int i = 0; i < sizeof(allAxes); i++) { stepper_handle(&allAxes[i]); } } [/c]
Zeigern: [c] motion *allAxes[]{ &Z1_g, &Z2_g, &Z3_g, &Z4_g, &Z5_g, &Z6_g, &Z7_g }; int axesCount = sizeof(allAxes) / sizeof(*allAxes); if (z_measurement_g) { motion *priorRankedAxis = findPriorRankedAxis(allAxes, axesCount); if (priorRankedAxis != NULL) { stepper_handle(priorRankedAxis);
-
Thread
Komisches Zeichen wird im LCD angezeigt. Durch zusammenfügen von 2 Strings?
auch mal mitdenken. Setze hzString auf die maximale Stellenzahl von int16_t: [c] char hzString[sizeof("-32768")]; [/c] Aber wozu überhaupt atoi, wenn Du eh sprintf benutzt? Und malloc in ner Loop bricht dem RAM das Genick.
auch mal mitdenken. > Setze hzString auf die maximale Stellenzahl von int16_t:char > hzString[sizeof("-32768")]; > > Aber wozu überhaupt atoi, wenn Du eh sprintf benutzt? > Und malloc in ner Loop bricht dem RAM das Genick. itoa damit er aus hzInNumber(Frequenz) in ein String umwandelt. Damit
-
Thread
Dynamisch Speicher reservieren (Array)
("sizeof(uint16_t)") oder reicht es, mit malloc die Anzahl der Elemente zu reservieren? Sprich alloziiert malloc "automatisch" (dadurch das tempArray bereits uint16_t ist) die korrekte Größe von 10 Byte und
vom Gleichheitszeichen ein Pointer auf uint16_t steht. Du musst also wie gezeigt Anzahl Elemente * sizeof(uint16_t) rechnen um die richtige Größe zu kriegen.
-
Thread
Array als Rückgabewert kann nicht angezeigt werden
current_ic; uint8_t current_cell; cell_data_spi = (uint8_t *) malloc((NUM_RX_BYT*total_ic)*sizeof(uint8_t)); //The pec_error variable is simply set negative if any PEC errors Lcd_Out(2,1, "rdcv_readcellvlt"); //1.a if (reg == 0) { //a.i for
} } } //1.b else { //b.i //.... } //2 FreeMem(cell_data_spi, sizeof(cell_data_spi)); return(pec_error); } /* LTC6804_rdcv Sequence 1. Switch Statement: a. Reg = 0 i. Read cell voltage registers A-D for every IC in the daisy chain ii. Parse
-
Thread
EEPROM Block Access funktioniert nicht
int8_t CalbData[18]; int main(void) { eeprom_read_block(&CalbData, eeprom_calbData, sizeof(CalbData)); while(1) { //Programm } }[/CODE] Ich bekomme folgende Fehler raus wenn ich kompiliere: 1. too few arguments to function 'eeprom_read_block' 2. expected
eeprom_calbData CalbData; int main(void) { eeprom_read_block(&CalbData, &CalbDataEEPROM, sizeof(eeprom_calbData)); while(1) { //Programm } } [/c]
-
Thread
GCC ARM Embedded -> Compiler bug! Dereferenzierung von Pointern.
= %lp\r",&b); my_printf("&array_a = %lp\r",&array_a); my_printf("sizeof(t_a) = 0x%02X\r",sizeof(t_a)); my_printf("sizeof(arr_t_a) = 0x%02X\r",sizeof(arr_t_a)); my_printf("sizeof(t_b) = 0x%02X\r",sizeof(t_b)); CR; my_prints("Addresses dereferencing
TEST ptr_b = 0x1fff8038 &b = 0x1fff8038 &array_a = 0xba5c sizeof(t_a) = 0x11 sizeof(arr_t_a) = 0x55 sizeof(t_b) = 0x08 Addresses dereferencing ptr_b ptr_b->number_b = 0x1fff8038 ptr_b->arr_a[0] = 0xba5c ptr_b->arr_a[1]
-
Thread
Minesweeper in C
Zufällige anzahl der bomben bestimmen //Speicherzuweißung board = (int **)malloc(n * sizeof(int *)); for(i = 0; i < n; i++){ board[i] = (int *)malloc(m * sizeof(int)); } //Board mit 0 füllen, 0 ist die anzeige falls noch nicht aufgedeckt
-
Thread
MinGW: __attribute__((packed)) und alignment
ret .seh_endproc .comm foo, 4, 0 .ident "GCC: (tdm64-1) 5.1.0" [/code] bzw. der "sizeof"-Operator liefert 4 zurück.
Walter T. schrieb im Beitrag #4481740: > der "sizeof"-Operator liefert 4 zurück. Ja, sagt ja auch die .comm-Anweisung.
-
Thread
If Else geht nicht
/ alle 250µs { //-- Variable Licht betüdeln --------------- uint_xx_t Max = (uint_xx_t) ( sizeof(WAIT) / sizeof(WAIT[0]) ) if ( ... ) Licht = 1; else if ( ... ) Licht = 2; ... if ( Licht >= Max ) Licht = 0; // Timing erzeugen ------------------------- if ( ++TimeTick
-
Thread
C++ mehrere Int Variablen mit einander vergleichen
#include <stdio.h> int main(){ int nums[] = {1,2,3,4,5,6,7,8,9,0}; size_t num_count = sizeof(nums)/sizeof(*nums); size_t i,j; bool unique=true; for( i=0; i < num_count; i++ ) for( j=i+1; j < num_count; j++ ) if( nums[j] == nums[i] ){ unique = false; break
-
Thread
Code Block Marker in C
main_send_string] uint8_t string[] = "Hello World!\r\n"; usart_write_buffer_wait(&usart_instance, string, sizeof(string)); //! [main_send_string] //! [main_rec_var] uint16_t temp; //! [main_rec_var] [/c]
-
Thread
C embedded: Float zu uint32_t aus multidimensionalem Pointer funktioniert nicht
einfach memcpy und gut ist. [c] FLOAT32*fourB[2][6]; uint32_t tmp; memcopy( &tmp, &fourB[1][2], sizeof( uint32_t ) ); [/c]
schrieb im Beitrag #4474170: > FLOAT32*fourB[2][6]; > uint32_t tmp; > memcopy( &tmp, &fourB[1][2], sizeof( uint32_t ) ); Das & bei fourB gehört da aber nicht hin.
-
Thread
Geht das auch einfacher?
*fmt, ...) { va_list ap; char buf[80]; va_start(ap, fmt); int n = vsnprintf(buf, sizeof buf, fmt, ap); va_end(ap); if (n < 0) return; display.setCursor(x, y); display.println(buf); } ... display_output(0, 8, "Außen: %d°", a); [/c]
-
Thread
USART Kommunikation nur im Einzelschritt? ATmega2560 USART Problem
(); //Funktion in UART_init.c uart_puts(cmd[1]); //funktion in UART_send.c uart_gets(Line, sizeof(Line));//funktion in UART_receive.c while (!(UCSR3A & (1<<UDRE3))); /* warten bis Senden moeglich */ for(int i = 0; i < 41; i++) { UDR3 = Line[i]; } return 0; } [/c]
-
Thread
AVR "ret" springt zu 0x00
Hugo P. schrieb im Beitrag #4471062: > memset(&can_buffer, 0x00, sizeof(CAN_BUFFER)); Das ist fast sicher falsch (Pointer auf Pointer statt Pointer auf Array). Entweder [c] memset(can_buffer, 0x00, sizeof(CAN_BUFFER)); [/c] oder [c] memset(&can_buffer[0], 0x00, sizeof(CAN_BUFFER)); [/c]
-
Thread
STM32F407: Stack ins CCRAM gelegt erzeugt Hard Fault Error
stack_dummy section */ __StackTop = ORIGIN(CCRAM) + LENGTH(CCRAM); __StackLimit = __StackTop - SIZEOF(.stack_dummy); PROVIDE(__stack = __StackTop); /* Check if data + heap + stack exceeds RAM limit */ /*ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack") */ [/c] Der
-
Thread
Differenzen auswerten: Geht das eleganter?
float temperature_range_limits[] = {-2,-1,-0.5, 0, 2.5, 3.0}; const size_t num_temperature_ranges = sizeof(temperature_range_limits) / sizeof(temperature_range_limits[0]); const unsigned char leds[] = {0,1,2,3,4,5,6}; // irgendwelche Bitmuster. size_t get_temperature_range(float t) { for (size_t
. Dadurch war das mit der Schleife oben einfach lösbar. const size_t num_temperature_ranges = sizeof(temperature_range_limits) / sizeof(temperature_range_limits[0]); Auch noch nicht gesehen .... ich habe einfach 12 reingeschrieben.
-
Thread
Daten aus uint32_t Array als int auslesen
berechtigter Einwand, da muss man dann mal den C-Standard fragen wie groß int sein sollte. Den sizeof-Operator gibts auch, wenn man zur Laufzeit prüfen muss ob Datentypen ineinanderpassen. Achso und die Pointer-Arithmetik ist nur für ein 32-bit System richtig wenn ich mich nicht irre. Du zählst
direkt als int auslesen? Im Allgemeinen nicht. Im Speziellen wird es halbwegs funktionieren, wenn sizeof(int) == sizeof(uint32_t) ist. Denn nur in diesem Fall ist das Inkrementieren des Pointers äquivalent zum Zugriff auf das nächste Element des Arrays. Aber auch dann geht es in die Hose, wenn ein Eintrag
-
Thread
Parity check von 32-Bit Wert
GCC: [c]#include <stdint.h> uint8_t get_parity (uint32_t x) { #if defined(__GNUC__) && (__SIZEOF_INT__ == 4) return __builtin_parity (x); #elif defined(__GNUC__) && (__SIZEOF_LONG__ == 4) return __builtin_parityl (x); #else #error #endif }[/c]
-
Thread
RF24L01+ Modul an RPI
printf("Now sending...\n"); unsigned long time = millis(); bool ok = radio.write( &time, sizeof(unsigned long) ); if (!ok){ printf("failed.\n"); } ================ SPI Configuration ================ CSN Pin = CE0 (PI Hardware Driven) CE Pin = Custom GPIO22
-
Thread
long double übertragen
> Ich glaube verschwenderischer als ASCII-Konvertierung kanns nicht sein. Naja, geht so. sizeof(double) = 8 Bytes "123.1923" sind 8 Zeichen. Mit einer Ende-Markierung dann 9. W.S. schrieb: > Wenn man schon eine Gleitkommazahl von einem system auf einanderes > übertragen wil, dann bleibt
-
Thread
NRF24L01+ über mehrere Kanäle kommunizieren?
radio.stopListening(); radio.openWritingPipe(pipe); senden[0]=99; radio.write( senden, sizeof(senden) ); } if (modus == 1){ radio.openReadingPipe(1,pipe1); radio.startListening(); radio.read( empfangen, sizeof(empfangen) ); Serial.println(empfangen[0]); } } [/c]
radio.stopListening(); radio.openWritingPipe(pipe1); senden[0]=23; radio.write( senden, sizeof(senden) ); } if (modus == 0){ radio.openReadingPipe(1,pipe); radio.startListening(); radio.read( empfangen, sizeof(empfangen) ); Serial.println(empfangen[0]); } } [/c]
-
Thread
0x00 ausgeben mit printf in c
main(void) { char buf[16]; int n; n = sprintf(buf, "Anfang%cEnde\n", 0); fwrite(buf, sizeof (char), n, stdout); puts(buf); return 0; } [/c] [pre] $ sprintftest | cat -v Anfang^@Ende Anfang [/pre] Das "^@" steht für das NUL-Zeichen.
-
Thread
Unterschiedliche "static const struct Größe beim compilieren auf ARM/x86
verwende und mit dem gcc compiliere, ist das Struct 1 Byte größer, als mit dem ARM-compiler. Also sizeof(struct) gibt mir auf der x86 Platform ein byte mehr aus, als auf der ARM Platform. Ich habe mir schon die Größe jedes einzelne Element des structs ausgeben lassen mit sizeof(struct.element) und verglichen
kompiliere [c] struct st { int i; char c; }; std::printf( "%u\n", (unsigned)sizeof(struct st) ); [/c] , dann bekomme ich 8 als Größe raus. Das heißt, es wird auch am Ende noch gepadded. Ist auch logisch, weil man ja mit z.B. malloc(5*sizeof(struct st)) ein Feld allokieren
-
Thread
STM32F7 Bitmap auf SD-Karte speichern via DMA2D
fs_error != FR_OK) { Filesystem_ErrorHandler(fs_error); } tmp = tmp + 640*sizeof(uint16_t);//increase the SDRAM address } } fs_error = SD_CloseFile(&file); if(fs_error != FR_OK) Filesystem_ErrorHandler(fs_error); fs_error = SD_UnMount(); if(fs_error
-
Thread
SRAM in C direkt auslesen
Ram liegt ist doch egal. Mit einer For Schleife sendet man das dann: uint8_t i; for (i=0; i <sizeof (byBuffTx); i++) { while (!Uart frei...){}; Uart Tx Register = byBuffTx [i]; }
addr == 0xaffeaffe) { glbls = (struct globals *) addr; if (glbls->size == sizeof(struct globals)) break; glbls = NULL; } } while (addr++ != _data_end); if (glbls != NULL) { ... } [/c] Besonders effektiv ist das natürlich nicht (muß es aber
-
Thread
nRF24L01 : Arduino zu Arduino und zurück?
radio.openWritingPipe(pipe); } void loop() { inbyte = inbyte+1; daten[0] = inbyte; radio.write(daten, sizeof(daten)); } [/vhdl] 1 Byte-empfangen: [vhdl] #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #define CE_PIN 53 #define CSN_PIN 48 const uint64_t pipe = 0xE8E8F0F0E1LL; RF24
radio.available() ) { bool done = false; while (!done) { done = radio.read( daten, sizeof(daten) ); Serial.print("X = "); Serial.println(daten[0]); } } else { Serial.println("No radio available"); } } [/vhdl]
-
Thread
Linux: Dateizugriff von mehreren Prozessen
jedes Prozesses folgenden Code aus: [CODE] //try to get shared mem int shmid = shmget(SHM_ID, sizeof(pthread_mutex_t), 0666); if (shmid == -1) { //does not exist, we have to initialize shmid = shmget(SHM_ID, sizeof(pthread_mutex_t), 0666 | IPC_CREAT); cout << "SHM created, ID "
-
Thread
Wie mit STM32F0 DMX Empfangen
DmxInDataCounter++; // Datum weiter zaehlen if (DmxInDataCounter >= sizeof (DmxPc_In_DmxUniverse)) { DmxInStatus = IN_BREAK; // ALL CHANNELS RECEIVED } break; default : break;