-
Thread
Daten via USART senden auf SAM V71
pt_amplitude = (signed char*)&fTFTAmplitude[1][i][finished_result_counter%5]; memcpy(&data[(i*3)*sizeof(float) + config_bytes],pt_amplitude,4); pt_phase = (signed char*)&fTFTPhase[1][i][finished_result_counter%5]; memcpy(&data[(i*(3) + 1)*sizeof(float) + config_bytes],pt_phase,4); pt_frequency = (signed char*)&fTFTFrequency[i][finished_result_counter%5]; memcpy(&data[(i*(3) + 2)*sizeof(float) + config_bytes],pt_frequency,4); } //send_data_function(FUNCTIONCODE_Phasor, data, size); [/c] Da ich also ein Array mit einer gewissen Datengröße übertragen möchte, muss die Übertragung
-
Thread
ElmChan LFN f_open
function common result code static char lfn[_MAX_LFN + 1]; fno.lfname = lfn; fno.lfsize = sizeof lfn; res = f_open(&fsrc, "uartconfig.txt" , FA_OPEN_EXISTING | FA_READ); [/c]
-
Thread
Compiler-Direktive #define auswerten? #define foo 1; #if (foo ==1)?
elif (SENSORTYPE == 2) uint8_t msg[27]; #endif std::cout << "Size of msg: " << sizeof(msg) << std::endl; return 0; } [/c] [pre] Size of msg: 22 [/pre] Thomas I. schrieb im Beitrag #5113224: > Liegt es vielleicht am Kompiler von Atmel Studio? Nein, denn da wird auch
-
Thread
Pointer incrementieren schlägt fehl?!
printf(str); } int main(int argc, char *argv[]) { char *buff = (char*)calloc(11,sizeof(char)); ausgabe(buff); return 0; } [/c]
Jan H. schrieb im Beitrag #5112745: > char *buff = (char*)calloc(11,sizeof(char)); sizeof(char) ist per Definition /immer/ 1. Du kannst also einfach calloc(11,1) oder noch einfacher malloc(11) schreiben. Der Grund ist, dass sizeof die Größe des Typs als Vielfache von der
-
Thread
IEEE-754 Float erzeugen
[c] unsigned char tmp[2]; tmp[0] = 0x43FA; tmp[1] = 0x9B9A; float f; memcpy( &f, &tmp, sizeof( float ) ); [/c] eventuell die Reihenfolge tauschen.
korrektur: [c] uint16_t tmp[2]; tmp[0] = 0x43FA; tmp[1] = 0x9B9A; float f; memcpy( &f, &tmp, sizeof( float ) );
-
Thread
Arrays/Zeiger und Callbackfunktionen
Codeabschnitte identisch? [c] #define MAX_EVENTS 100 struct epoll_event *events; events = malloc (sizeof (struct epoll_event) * MAX_EVENTS); [/c] [c] #define MAX_EVENTS 100 struct epoll_event events[MAX_EVENTS]; [/c] Und meine zweite Frage bezieht sich auf folgenden Abschnitt: [c] int
Callbackfunktion void callback_timer (struct epoll_event *events, uint64_t *count) { read(tfd, &count, sizeof(count)); printf("Timer \n"); } void callback_signal(struct epoll_event *events, uint64_t *count) { read(sfd, &siginfo, sizeof(siginfo)); printf("Signal: %d \n", siginfo.ssi_signo); }
-
Thread
uint32_t => float (32) ohne cast!
memcpy(&int, &float, sizeof(float));
wäre zumindest memcpy akzeptabel, falls in ein uint32_t aber nur, wenn man noch ein static_assert(sizeof(float)==sizeof(uint32_t),"Float wasn't 4 bytes big"), einbaut. Bei einem cast ist nur nach char* in Ordnung, wegen aliasing. Wenn man jedoch zwischen verschiedenen Geräten Daten austauschen will,
-
Thread
struktur elemeten durchlaufen C
alles in ein array gepakt oder wie soll ich mir das vorstellen? size_t people_count = sizeof(people) / sizeof(people[0]); //sizeof(people) liefert doch 3 oder? also index 0-2 und was macht das teilen durch sizeof(people[0])? [/c]
person_ptr_ptr)->vorname; (**person_ptr_ptr).vorname; person_ptr_ptr[0][0].vorname; // etc. // Achtung: sizeof(person_ptr_ptr) entspricht sizeof(struct person**) entspricht sizeof(void*), alle pointer sind gleich gross, aber sizeof(people_b) entspricht sizeof(struct person*[3]) entspricht sizeof(struct person
-
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
Pointer freigeben?
wenn ich einen Speicherbereich mit calloc alloziere, also z.B. uint8_t xyz = (uint8_t*) calloc(sizeof(uint8_t), 10); dann gebe ich den ja danach wieder mit free(xyz) frei. Muss ich das auch mit jedem von mir erzeugten Pointer tun, oder sind "normal" erzeugte Pointer, die nicht mit calloc / malloc
wenn ich einen Speicherbereich mit calloc alloziere, also z.B. > uint8_t xyz = (uint8_t*) calloc(sizeof(uint8_t), 10); > dann gebe ich den ja danach wieder mit free(xyz) frei. So weit, so korrekt. > Muss ich das auch mit jedem von mir erzeugten Pointer tun, oder sind > "normal" erzeugte Pointer
-
Thread
LwIP UDP Callback
); ethTxBuffer_p = pbuf_alloc(PBUF_TRANSPORT, sizeof(clientMagicPacket_c), PBUF_RAM); if (ethTxBuffer_p == NULL){} memcpy(ethTxBuffer_p->payload, clientMagicPacket_c, sizeof(clientMagicPacket_c)); udp_sendto(udpPcb1_p, ethTxBuffer_p
-
Thread
STM32F103 nach Interrupt im Nirvana
uint8_t nrBytes = RF_GetPayloadSize(); if ((pipe == 1) && (nrBytes <= sizeof(actual_data))) { f_RF_Timeout = false; ReceivedDataBlocks++; /* Daten auslesen */ RF_ReadPayload((uint8_t*)&actual_data
Zeit atomar in eigenen Struct holen */ NVIC_DisableIRQ(RTC_IRQn); memcpy((void*)&mytime,ptr,sizeof(struct tm)); // mytime <- localtime Buffer NVIC_EnableIRQ(RTC_IRQn); } [/c]
-
Thread
Multibyte write
die Funktion [c] HAL_I2C_Master_Transmit(&hi2c1, ep1_address_write, &FORCE_ANA_CTRL_SIGS, sizeof(FORCE_ANA_CTRL_SIGS), 1000);[/c] Dabei ist ep1_address_write die Deviceadresse &FORCE_ANA_CTRL_SIGS die Adresse des Registers vom Sensor, das geändert werden soll (angegeben als Daten) und im
Ich habe die FunktionHAL_I2C_Master_Transmit(&hi2c1, ep1_address_write, > &FORCE_ANA_CTRL_SIGS, sizeof(FORCE_ANA_CTRL_SIGS), 1000); Wie ist die Signatur der Funktion? Um welchen Sensor handelt es sich? Grüße Oliver
-
Thread
USB des STM32 F103C8T6 nutzen
if (!bOverFlow) bRx=true; bOverFlow=false; } else { if (nRx >= (sizeof(RxBuf)-1)) { bOverFlow=true; } else { RxBuf[nRx]=u; nRx++; } } } [/C] dazu wurde in der usb.c die Funktion OnEpBulkOut geändert
-
Thread
Atmega Flash -> PROGMEM -> ARRAY
vor image ;) Und dann normal den Pointer übergeben? [C] lcd_printImage(pgm_read_ptr(&hesch),sizeof(hesch)); [/C]
-
Thread
[Glaskugel] Funktionsaufruf lässt Controller hängen
example, if the radix is 2 (binary), you need to supply a buffer with a minimal length of 8 * sizeof (unsigned int) + 1 characters, i.e. one character for each bit plus one for the string terminator. Using a larger radix will require a smaller minimal buffer size. Warning If the buffer is
-
Thread
Events mit timerfd und epoll
nr_events; i++) { if (events[i].data.fd == tfd) { read(tfd, &count, sizeof(count)); printf("Beep!\n"); } else if (events[i].data.fd == sfd) { read(sfd, &siginfo, sizeof(siginfo)); printf("Received signal number
-
Thread
char Arrays variabel
aber am Ende von einem anderen Programm aus nur so viele Zeichen lesen möchte, wie geschrieben. sizeof(buffer) liefert nämlich stets 20 als integer-Wert.
string with which mystr has been initialized has a length of only 11 characters. Therefore, while sizeof(mystr) evaluates to 100, strlen(mystr) returns 11. [/pre]
-
Thread
Union und Bitfelder
event2; } event; event events; int main (void) { printf ("size of events: %ld %p %p\n", sizeof(events), &events.event1, &events.event2); while (1) { printf ("evt1:%02X dir1:%02X evt2:%02X dir2:%02X\n", events.event1.evt,
event2; } event; event events; int main (void) { printf ("size of events: %ld %p %p\n", sizeof(events), &events.event1, &events.event2); while (1) { printf ("val1:%02X dir1:%02X evt1:%02X val2:%02X dir2:%02X evt2:%02X\n", events.event1.val,
-
Thread
Übertragungsgeschwindigkeit SPI Bus Arduino Mega
-15, -0.320207200030E-18, 0.971511471520E-22, -0.121047212750E-25}; int cLength = sizeof(c) / sizeof(c[0]); double a0 = 0.118597600000E+00; double a1 = -0.118343200000E-03; double a2 = 0.126968600000E+03; for (i = 0; i < cLength
-15, -0.320207200030E-18, 0.971511471520E-22, -0.121047212750E-25}; int cLength = sizeof(c) / sizeof(c[0]); double a0 = 0.118597600000E+00; double a1 = -0.118343200000E-03; double a2 = 0.126968600000E+03; for (i = 0; i < cLength
-
Thread
Strings im Flash ablegen, oder nicht?
LOADADDR (.data) 0x00000056 __data_load_end = (__data_load_start + SIZEOF (.data)) [/pre] Das gleiche Programm compilert für einen ATtiny40: [pre] $ avr-gcc foo.c -o foo.elf -mmcu=attiny40 -Os -save-temps -Wl,-Map,foo.map $ avr-objdump -d foo.elf[/pre] [avrasm
LOADADDR (.data) 0x0000004c __data_load_end = (__data_load_start + SIZEOF (.data)) [/pre] Hier liegt i an Flash-Adresse 0x4a, was per RAM-Adresse 0x404a zugegriffen wird. Das RAM beginnt bei 0x40, enthält hier aber keine Daten. Wenn es welche hätte, würde es vom Startup-Code
-
Thread
CRC16 - schnellere Implementierung möglich?
oder nach dem senden: alt: berechne_crc(string) sende(string) neu: for(position=0;position<sizeof(string);position++) { crc=berechne_crc(zeichen an positon) sende(zeichen an positon) }
-
Thread
Hex Zahlen aus Datei lesen und in char[] = {} im Programm speichern in C
cmd; int readed, i; size_t *t = malloc(0); char *cmd1 = "0x"; char **gptr = malloc(sizeof(char*)); *gptr = NULL; datei = fopen("test.txt", "r"); if(NULL == datei) { fprintf(stderr, "Konnte Datei \"test.txt\" nicht öffnen! : %s\n", strerror(errno)); return EXIT_FAILURE
-
Thread
Externen I2C (F)RAM bequem verwalten
her, ob es tatsächlich kompiliert weiß ich gar nicht): [c] char[32] str; fram_read_block(0 + sizeof(version_t) + sizeof(length) + sizeof(prefs_sub_t) * 17, str, 64); [/c] Das erscheint mir etwas unpraktisch und erfordert wohl viel Rechnerei. Vorallem erfordert es Anpassungen, sobald sich die
> ich muss händisch die jeweiligen Offsets berechnen Es gibt neben sizeof auch offsetof(struct_t,member), damit wird es kürzer und unempfindlich(er) gegen Änderungen einer struct Definition. Zweitens könnte man z.B. eine Funktion schreiben, die ein komplettes Element
-
Thread
VS1063 MP3 abspielen
test_volume = read_register(0x0B); //result = 0xFFFF while(1) { for(uint32_t i=0 ; i<sizeof(HelloMP3) ; i++) { wait_dreq(); GPIO_WriteBit(BSYNC_PORT, BSYNC_PIN, Bit_RESET); send(HelloMP3[i]); GPIO_WriteBit(BSYNC_PORT, BSYNC_PIN, Bit_SET); } } return
rüber schubsen ? Thorsten schrieb im Beitrag #5087779: > while(1) { > for(uint32_t i=0 ; i<sizeof(HelloMP3) ; i++) { > wait_dreq(); > GPIO_WriteBit(BSYNC_PORT, BSYNC_PIN, Bit_RESET); > send(HelloMP3[i]); > GPIO_WriteBit(BSYNC_PORT, BSYNC_PIN, Bit_SET); > } >
-
Thread
Unterschied zwischen bei Compiler MPLAB® C und MPLAB® XC
/Language code string descriptor ROM struct{BYTE bLength;BYTE bDscType;WORD string[1];}sd000={ sizeof(sd000),USB_DESCRIPTOR_STRING,{0x0409 }}; //Manufacturer string descriptor ROM struct{BYTE bLength;BYTE bDscType;WORD string[11];}sd001={ sizeof(sd001),USB_DESCRIPTOR_STRING, { 'G','m','b','
//Product string descriptor ROM struct{BYTE bLength;BYTE bDscType;WORD string[31];}sd002={ sizeof(sd002),USB_DESCRIPTOR_STRING, { 'D', }}; #pragma romdata SERIAL ROM struct{BYTE bLength;BYTE bDscType;WORD string[8];}sd003={ sizeof(sd003),USB_DESCRIPTOR_STRING,{'6','9','0','0','0','0','0
-
Thread
STM32 SPI DMA
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_BufferSize = sizeof(RxBuffer); DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; DMA_Init(DMA1_Channel2,
STMSPISucks schrieb im Beitrag #5080238: > sizeof(TxBuffer); Das gibt dir immer die Pointergröße, also 4 Byte zurück, egal wie groß dein Buffer ist. Das gleiche gilt natürlich für RxBuffer.
-
Thread
Call by Value, char-Arrays
Peter II schrieb im Beitrag #5064886: > S_Spieler Doch, wenn ich per sizeof(S_Spieler) Aufrufe, ist Speicher reserviert, obwohl noch keine Instanz erzeugt.
Michi schrieb im Beitrag #5064909: > Doch, wenn ich per sizeof(S_Spieler) Aufrufe, ist Speicher reserviert, > obwohl noch keine Instanz erzeugt. nein, siezeof liefert die größe, sagt aber überhaupt nicht ob Speicher reserviert ist.
-
Thread
Seltsames Programmverhalten
TaskScheduler(void) { const uint32_t QUEUE_LENGTH = 1; const uint32_t QUEUE_ITEM_SIZE = sizeof(STC_MSG_TELEGRAM*); qh = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); sma_rx_qh = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); oCTelegram = new CTelegram(sma_rx_qh); ###############
TaskScheduler(void) { const uint32_t QUEUE_LENGTH = 1; const uint32_t QUEUE_ITEM_SIZE = sizeof(STC_MSG_TELEGRAM*); qh = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); sma_rx_qh = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); CTelegram oCTelegram(sma_rx_qh); #####################
-
Thread
Verkette Listen in C und C++
Byte, dass nicht beschrieben werden darf. Man muss es je Puffer nur einmal zuweisen: lim = buf +sizeof(buf); Näheres siehe https://www.mikrocontroller.net/topic/416474#4862280
-
Thread
Linux serial port cross compile
if (FD_ISSET(fd, &readSet)) { printf("--reading--->\n"); rdlen = read(fd, buf, sizeof(buf) - 1); printf("length: %i\n",rdlen); if (rdlen > 1) { unsigned char *p; printf("Read %d:", rdlen); for (p = buf; rdlen-- > 0; p++) printf(" 0x%x", *p
Daten (binär) die ich vom PC sende. wenn ich rein diesen code Ausführe [c] dlen = read(fd, buf, sizeof(buf) - 1); [/c] das gleiche auch in die andere Richtung. Habe es noch zusätzlich mit dem Oszi überprüft. Stimmt soweit alles. habe es auch über das Terminal versucht: cat /dev/ttyS2 Daten
-
Thread
union mit Struktur und Array gleicher Größe?
} int main() { struct eeprom src = { 1,2,0xffffffff,-42 } ; unsigned char buffer[sizeof(struct eeprom)] ; unsigned char *p = buffer ; serialize(src.ui8, sizeof(src.ui8 ),&p) ; serialize(src.ui16,sizeof(src.ui16),&p) ; serialize(src.ui32,sizeof(src.ui32),&p) ; serialize(src.i16 ,sizeof(src.i16 ),&p) ; struct eeprom dst ; unsigned char const *q = p ; dst.i16 = (int16_t )deserialize(&q,sizeof(dst.i16 )) ; dst.ui32 = (uint32_t)deserialize(&q,sizeof(dst.ui32
-
Thread
EEPROM Emulieren auf Atmel SAM4E APP Note
page_walker++) { memcpy(page_buffer, (const void *)(FLASH_START + page_walker*PAGE_SIZE), sizeof(page_buffer)); current_eep_index = get_eep_block(page_buffer); current_page = page_walker; if(current_eep_index >= 0) break; } //if no page found, then the last page
0) { memcpy(page_buffer, (const void *)(FLASH_START + ((current_page-1)*PAGE_SIZE)), sizeof(page_buffer)); for(int i = 0; i < EEPROM_SIZE; i++) #if(EEPROM_SIZE == 511) eep_buffer[i] = page_buffer[i + 1]; #elif(EEPROM_SIZE == 255) eep_buffer[i] = page_buffer
-
Thread
Pointer in Funktion..
[lvalue] Wie jede andere Variable hat ein Pointer eine Adresse (&-operator) und eine Größe (sizeof-operator). Axel S. schrieb im Beitrag #5052529: > Wenn du schon den Standard zur Hand hast: schlag doch mal die Definition > des Konzepts "Pointer" nach. Und dann zeig mir, wo der Standard das
hat. > Wie jede andere Variable hat ein Pointer eine Adresse (&-operator) und > eine Größe (sizeof-operator). Und wie jede andere Variable hat ein Pointer einen Wert. Im Falle eines Pointers ist dieser Wert eine Adresse.
-
Thread
STM32F7: Eigener Bootloader startet die Applikation nicht
sizeof(APP_HEADER)) ); Jump_To_Application();
die Applikation gestartet: __set_PRIMASK(1); addr = GetApplicationStartAddress() + sizeof(APP_HEADER)+4; JumpAddress = *(__IO uint32_t*) addr; Jump_To_Application = (pFunction) JumpAddress; __set_MSP(*(__IO uint32_t*)(GetApplicationStartAddress() + sizeof(APP_HEADER