-
Thread
Ada oder MISRA-C, aktuell und in Zukunft
Pointer' (Pool-Nummer und Objekt-Index) einen Pointer machen. D.h. dieselbe Operation (ausg. Cast und sizeof(Objekt)) für alle Objekttypen. Müsste eine gcc 3.x gewesen sein. Ich hätte auch erwartet, dass der Compiler erkennt, dass das mit genau einem Wrapper (index -> Pointer) abgehakt werden kann.
-
Thread
GCC Compiler Flags
die Libs (libc, libm, Header) dies natürlich unterstützen, z.B. dadurch dass die Implementierung __SIZEOF_DOUBLE__ berücksichtigt. -mshort-double o.ä. bzw. Anpassung von DOUBLE_TYPE_SIZE im ARM-Backend scheint aber nicht zu geben. Ergo 5 Möglichkeiten: 1) Die alte Version verwenden 2) Die neuen
-
Thread
PWM Frequenz ATTiny85
byte p: {3,5,9}) pinMode(p,INPUT); [/c] Das ist doch viel einfacher, als das Gehampel mit i und sizeof(). Nahezu ideal! Oder using... [c] using Buffer = int[20]; Buffer buffer; void druckeEs(Buffer &buffer) { for(auto value:buffer) Serial.print(value); } // in einer Funktion
-
Thread
C++ If else oder return?
struct bla* create_bla(int x){ > if(x < 0) > goto error; > > struct bla* bla = malloc(sizeof(struct bla)); > if(!bla) > goto error; > > if(init_bla_bla(bla) == -1) > goto error_after_malloc; > > if(do_bla_bla(bla, x) == -1) > goto error_after_init_bla_bla; >
x){ struct bla* blabla; if(x < 0) { blabla= NULL; } else { blabla= malloc(sizeof(struct bla)); if(blabla) { if(init_bla_bla(blabla) == -1) { free(blabla); blabla= NULL; } else if(do_bla_bla(blabla, x) == -1) { cleanup_bla_bla
-
Thread
C Array: Implizite Null-Initialisierung abfangen
doch einfach weg. Dann ist das Array so gross, wie Du Elemente drin hast. Im if benutzt du dann sizeof.
[c] #define ARRAY_SIZE(X) (sizeof(X) / sizeof(*(X))) _Static_assert (ANZAHLELEMENTE == ARRAY_SIZE (adressen), "Bug"); [/c] oder [c]_Static_assert (ANZAHLELEMENTE == ARRAY_SIZE ((uint32_t*[]) { INITIALISIERUNG }), "Bug");[
-
Thread
SAMC20: DMAC->CRC != srec_cat −crc32-l-e
uint16_t *)FLASH_ADDR) uint32_t crc32_val; uint16_t tmp_data = NVM_MEMORY[(NVMCTRL_FLASH_SIZE-sizeof(crc32_val))/2]; crc32_val = tmp_data; tmp_data = NVM_MEMORY[(NVMCTRL_FLASH_SIZE-sizeof(crc32_val)+2)/2]; crc32_val |= ((uint32_t)tmp_data<<16) & 0xFFFF0000; DMAC->CRCCTRL.reg = DMAC_CRCCTRL_CRCSRC_IO
DMAC->CRCSTATUS.bit.CRCBUSY = 1; flash_index++; if (flash_index >= ((NVMCTRL_FLASH_SIZE - sizeof(crc32_val))/2)) { crc = DMAC->CRCCHKSUM.reg; if (crc != crc32_val) { fehler(TEST_FLASH_FAIL); } DMAC->CTRL.bit.CRCENABLE = 0; DMAC->CRCDATAIN.reg = DMAC_CRCDATAIN_RESETVALUE
-
Thread
Fernabfrage ELV Raumklimastation RS500 über SSH
to open device\n"); return 1; } hid_set_nonblocking(handle, 1); memset(buf,0,sizeof(buf)); buf[0] = 0x7b; buf[1] = 0x03; buf[2] = 0x40; buf[3] = 0x7d; res = hid_write(handle, buf, 17); if (res < 0) { printf("Unable to write()\n"); printf("Error: %
hid_error(handle)); } res = 0; while (res == 0) { res = hid_read(handle, buf, sizeof(buf)); // if (res == 0) // printf("waiting...\n"); if (res < 0) printf("Unable to read()\n"); usleep(1000*1000); } for (i=0;i<8;i++) { if (strlen(pMo[i]))
-
Thread
2 Bytes zusammenfügen
gross geschrieben der TYP von union { int a; // integer char b[sizeof(short int)]; // Array mit zwei Bytes } c; // klein geschrieben die Variable c.a = 0x4711; printf("a=%x b0=%x b1=%x\r\n",c.a,c.b[0],c.b[1]); // liefert
-
Thread
Variablenüberlauf bei Parameterübergabe
funktioniert nicht mehr. Naja... Soweit mir bekannt, ist int auf den SAM Dingern 32Bit groß. sizeof() würde dir das beweisen.
funktioniert nicht mehr. > > Naja... > Soweit mir bekannt, ist int auf den SAM Dingern 32Bit groß. > sizeof() würde dir das beweisen. Sollte sizeof (int) 2 ergeben, dann hilft es long anstelle von int zu verwenden
-
Thread
MQTT Publish mit ESP8266 implementieren
topic[0] = 'a'; topic[1] = '/'; topic[2] = 'b'; const uint8_t topicStrLen = sizeof(topic) / sizeof(topic[0]); self->var_header_size = 1 + 1 + topicStrLen; os_free(self->var_header); self->var_header = os_zalloc(sizeof(uint8_t) * self->var_header_size); self
ICACHE_FLASH_ATTR user_send_data(struct espconn *pespconn) { char *pbuf = (char*)os_zalloc(sizeof(uint8_t) * mqttSize); mqtt.fillPacket(&mqtt, pbuf); espconn_send(pespconn, (uint8_t*)pbuf, mqttSize); os_free(pbuf); } [/c] Die Variable *mqttSize* ist hierbei der Rückgabewert
-
Thread
I2C Slave mit dem Attiny 841
& (1 << TWDIR)) // Master fordert Daten vom Slave an { if(tx_buf_index >= sizeof(tx_buf)) { tx_buf_index=0; } TWSD = tx_buf[tx_buf_index]; tx_buf_index++; TWSCRB = (uint8_t) ((1<<TWCMD1)|(1<<TWCMD0)); } else // Master
-
Thread
C -> AVR -> Strukturen -> Padding Bytes
t y; * }pos_t; * pos_t Position = [x][Padding][Padding][Padding][Padding][Padding][y][y] * sizeof(pos_t) = 8 Bytes bei einem "AVR", mit Padding Bytes * * * typedef struct __PACKED__ * { * uint8_t x; * uint16_t y; * }pos_t; * pos_t Position = [x][y][y] * sizeof(pos_t) = 3 Bytes
sizeof() würde es dir zeigen. Wieso stellst du solche Fragen?
-
Thread
Verständnissfrage -> C Code
sio_job_tabelle *p = tab_ptr; ; p++) { struct sio_job_tabelle jt; memcpy_P (&jt, p, sizeof (struct sio_job_tabelle)); if (jt.typ == 0) break; uint8_t *pos = (uint8_t*) jt.pos; if (ucSioBuffer[0]) { pos += sizeof (sio_slave_st
Kannst noch weiter kürzen: Den memcpy_P (&jt, p, sizeof (struct sio_job_tabelle)); kann man durch die folgende Zuweisung ersetzen: jt = *p; :-)
-
Thread
SD Karten Verlängerung & maximale SPI Länge
fs = &Fatfs; if(f_mount(0, &Fatfs) == FR_OK) { strcpy(fno.fname, lfn); fno.fsize = sizeof lfn; } rc = f_getfree("0:", &free_cluster, &fs); if(rc == FR_OK) { free_MB = (free_cluster * fs->csize) / 2048; sprintf(buffer, "SD Init successfully: %lu MB Free\r\n", free_MB
-
Thread
länge eines arrays wird ein element mehr als für mich erwartet
summe, const char* sum1, const char* sum2) { const uint32_t length_1 = sizeof(sum1)/sizeof(sum1[0]); const uint32_t length_2 = sizeof(sum2)/sizeof(sum2[0]); printf("length1: %d\r\n", length_1); printf("length2: %d\r\n", length_2); for(uint8_t x=0; x<length_1; x
static void add(char* summe, const char* sum1, const char* sum2) > { > const uint32_t length_1 = sizeof(sum1)/sizeof(sum1[0]); > const uint32_t length_2 = sizeof(sum2)/sizeof(sum2[0]); Das funktioniert nicht. Innerhalb der Funktion ist nicht bekannt, wie groß die Arrays sind. Das ist eine elementare
-
Thread
Fragen zu Arduino EEprom Programmierung
Daten.Parameter5,"Hallo"); // Daten ins EEprom schreiben save_to_EEprom((byte *) &Daten, sizeof(Daten)); } void save_to_EEprom(byte *data, int len) { int EEprom_adr = 0; while(len--) EEPROM[EEprom_adr++] = *data++; } void loop() { } [/avrasm]
-
Thread
Sinn dieses Codes?!
irgendeines/ Typs wie einen 16- oder 32-Bit-unsigned-Int beschreiben zu können. Das setzt voraus, daß sizeof int < sizeof long ist, was z.B. beim AVR der Fall ist. Etwas "portabler" wird das, wenn statt "unsigned int" und "unsigned long" die Typen "uint16_t" und "uin32_t" verwendet werden. Das Konstrukt
Rufus Τ. F. schrieb im Beitrag #5866933: > Das setzt voraus, daß sizeof int < sizeof long ist, was z.B. beim AVR > der Fall ist. Nein. Es ist erstmal egal, wie der User WORD und LONG in seinem Universum interpretiert. Und er kann mit plattformspezifischer Anpassung dieser
-
Thread
ld mehrere MEMORY
copy_symbol_0) { irgendwas } > ITCM_low /* AT > DDR_RAM */ copy_symbol_1 = copy_symbol_0 + SIZEOF(.wtz); .zrt : AT(copy_symbol_1) { irgendwas } > ITCM_high /* AT > DDR_RAM */ } [/avrasm] -> und so weiter Ein .DDR_RAM wäre doch schön. Am liebsten hätte ich ja so etwas: ... .ADR(DDR_RAM
-
Thread
opendir(), readdir() Sortierung
return 1; int ret = 0; size_t curSize = 32, read = 0; char** files = (char**) malloc (sizeof(char*) * curSize); if (!files) { ret = 1; goto closeDir; } memset (files, 0, sizeof(char*) * curSize); struct dirent* dirEntry; while ((dirEntry = readdir(dirHandle)) !
; } else { ++read; } } ret = 0; qsort (files, read, sizeof (char*), cmp); for (size_t i = 0; i < read; ++i) { puts (files [i]); } freePaths: for (size_t i = 0; i < read; ++i) free (files [i]); free (files); closeDir: closedir
-
Thread
C++ / Data Race
; } union PackedData { uint8_t* allocatedData; uint8_t asBytes[sizeof (uint8_t*)]; }; PackedData packedData; }; moodycamel::ReaderWriterQueue<miniClass> q; miniClass dequeue() { miniClass c; q.try_dequeue(c); return c; } int main (
-
Thread
ADC- und DAC-Experimente mit PCF8591 auf Banana Pi SBCs (WiringPi, i2c-tools)
write 0x0: ie. use just channel 0, see data sheet struct pcf8591_control_byte S; memset(&S, 0, sizeof(S)); /* S.Channel = 0; S.ChannelAutoInc = 0; ChannelMixing = 0; Enable_AOUT = 0; */ if (write(fd, &S, 1) != 1) printf("ERR #1: %s\n", strerror(errno));
-
Thread
Serielle Kommunikation / Modbus Format - wie implementieren?
z.B. [code] void bmsReset() { uint8_t req[] = { 0xAA, 0x02, 0x05}; _sendBMSRequest(req, sizeof(req) / sizeof(uint8_t) ); } void main() { ... bmsReset(); } [/code] Nach etwas Recherche habe ich schon aufgenommen, dass die Verwendung von dynamischen Arrays eher nicht so schlau
voltage = 0.0f; uint8_t req[] = { 0xAA, 0x03, 0x00, 0x37, 0x00, 0x02 }; _sendBMSRequest(req, sizeof(req) / sizeof(uint8_t)); // Response lesen // Auf Startzeichen 0xAA warten // Empfangens Byte No. 3 = 0x00 (dann Error, sonst Payload-Length) // CRC prüfen
-
Thread
größter Wert eines Array
, counter=0; for (i = 1; counter < min; i++) { counter = 0; max_val = feld[((sizeof feld)-i)]; for (j=0; j < sizeof(feld); j++) { if (feld[j] == max_val) { counter++; } } } return max_val; } int main(void) {
find_max_value (char *feld, uint8_t min, uint8_t max_val) Innerhalb von find_max_value() liefert dir sizeof(feld) die Größe des Pointers (4 Bytes vermutlich).
-
Thread
Send JSON Data with ESP32 over HTTP by WLAN -> no Answer
to array char JSONmessageBuffer [512]; JSONencoder.prettyPrintTo(JSONmessageBuffer, sizeof(JSONmessageBuffer)); Serial.println(JSONmessageBuffer); //Create url url = "POST"; url += " "; url += "/XXX/XXX.XXX.svc/"; url += "UpdateDataJson"; url += " HTTP
Serial.println(url); //Length output from Body -> used as Content Length Length = sizeof(JSONmessageBuffer); if (client.connect(_ip_Adress, 80)) { //Send HTTP Header to Server client.println(url); client.println("Content-Type: application/json
-
Thread
memcpy array mit offset auffüllen
#5853935: > Sehr merkwürdig, was Du da vor hast. Wieso nicht memset? [c] > memset(&array[20], 0xFF, sizeof(array) - 20);[/c] Dann aber [c]memset(&array[20], 0xFF, sizeof(array) - 20 * sizeof(int));[/c] Falls array nicht als Array gegeben ist sondern nur als Zeiger, dann liefert sizeof(array) natürlich
Johann L. schrieb im Beitrag #5854951: > Dann aber > memset(&array[20], 0xFF, sizeof(array) - 20 * sizeof(int)); Unfug.
-
Thread
Arduino: Initialisierung eines array funktioniert nicht.
feld2[5]; void set_feld2 (void) { memcpy (feld2, (const int[]) { 18, 39, 42, 25, 69 }, sizeof (feld2)); }[/c] Und ja, das geht auch mit avr-gcc / avr-g++.
Johann L. schrieb im Beitrag #5853142: > memcpy (feld2, (const int[]) { 18, 39, 42, 25, 69 }, sizeof (feld2)); Das Compound-Literal gibt es strenggenommen nur in C, nicht aber in C++, wo es lediglich als GCC-spezifische Spracherweiterung verfügbar ist. In der Arduino-Welt spielt das aber vermutlich
-
Thread
Big Endian 2 little Endian
uint32_t num=0x1f2f3f4f; printf("Zahl: %" PRIx32 "\n\n", num); const size_t ARR_LEN=sizeof(num); for(size_t i=0; i<ARR_LEN; i++){ printf("%" PRIx8 "\t", *((uint8_t*)&num+i)); } puts(""); for(size_t i=0; i<ARR_LEN; i++){ printf("%" PRIx8 "\t", *
-
Thread
uint64 wert in uint8 array
schonmal nicht. schade. Hatte es auch mit memcpy probiert [c] memcpy(transformedValue, &value, sizeof(value)); [/c] dann war transformedValue aber verdreht. Dann belasse ich es bei der schleife
-
Thread
CallbackFunktion übergabe mit oder ohne &
das gesamte Array (und nicht nur auf das erste Element) zu definieren. Außerdem kann man darauf sizeof anwenden, um die Größe des Arrays zu erhalten. In allen Ausdrücken, in denen dem Array-Vezeichner kein & oder sizeof vorangeht, wird er in einen Pointer auf das erste Element konvertiert. Aber
werden muss. Die Dereferenzierung eines Funktionspointers wäre demzufolge ein Fehler, da für wäre sizeof erlaubt und würde die Größe eine Code-Adresse liefern.
-
Thread
I2C problemchen
uint16_t dAddress = 0x06 << 1; // 0x0C read/write = 0 data = 0x02; size_a = sizeof(data); /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { HAL_I2C_Master_Transmit(&hi2c1, dAddress<<1, &data
-
Thread
STM32 Uart Float Bytes senden
exceptions and examples. D.h. du solltest es eher so machen: [c]float f = 1.0; uint8_t foo[sizeof(f)]; memcpy(foo, &f, sizeof(foo)); HAL_UART_Transmit(&huart2, foo, sizeof(foo), HAL_MAX_DELAY);[/c] Der compiler erkennt dann, dass du float nach uint8_t array casten möchtest und optimiert das
-
Thread
ESP32 A1S Eval
digitalWrite(GPIO_PA_EN, HIGH) - dann Loop über die samples ... i2s_write(I2S_PORT_TX, &tmp, sizeof(tmp), &iWritten,portMAX_DELAY); Funktioniert soweit auch, aber aus dem Speaker kommt für 5 sec. nur so eine Art 'schnarren', zwar mit den Lautstärkeänderungen wie bei MIC-Aufnahme, aber das wars
-
Thread
Python-STM32 serielle Schnitstelle
UART2_Temp_Buffer[0], 1);/* Blocking */ 35 memcpy(&Python_22_B.UARTRx, &UART2_Temp_Buffer[0], 1*sizeof(uint8_T));/* D0 [1] */ 36 37 /* RelationalOperator: '<S1>/Compare' incorporates: 38 * Constant: '<S1>/Constant' 39 */ 40 Python_22_B.Compare = (Python_22_B.UARTRx > 0); 41
57 58 /* block I/O */ 59 (void) memset(((void *) &Python_22_B), 0, 60 sizeof(B_Python_22_T)); 61 62 /* Level2 S-Function Block: '<Root>/UART Rx' (stm32f4_usart) */ 63 enable_UARTRx(); 64 65 /* Level2 S-Function Block: '<Root>/Digital Output' (stm32f4_digital_output
-
Thread
SDCC: warning 158: overflow in implicit constant conversion
Der SDCC scheint es mit den Integer-Typen nicht so drauf zu haben. Beispiele: [pre] sizeof (char) -> 1 richtig sizeof (int) -> 2 richtig sizeof 0 -> 2 richtig sizeof (0 + 0) -> 1 falsch sizeof (0xff + 0) -> 1 falsch sizeof (0xff + 1) -> 2 richtig sizeof (0 - 0x80) -> 1 falsch sizeof (0 - 0x81) -> 2 richtig [/pre] Da darf man sich nicht wundern, wenn da mal eine nicht nachvollziehbare Overflow-Warnung ausgegeben wird.
-
Thread
Filter ohne Wertverlust
summe -= merker[N_FIR_ORDER-1]; memcpy( &(merker[1]), &(merker[0]), (N_FIR_ORDER-1)*sizeof(int32_t)); merker[0] = u; summe += u; int32_t y = summe/N_FIR_ORDER; // Noch ziemlich teuer int32_t rest = summe%N_FIR_ORDER; summe += rest;
-
Thread
C-> Größe eines Array in einem Union initalisieren?!
_t _firstChar; uint8_t _charCount; uint8_t _widths[11]; uint8_t _fontData[sizeof(fontData)]; }; }; [/c]
t _widths[11]; Aber hier hast du doch schon gerechnet. X = die größe gesamten Arrays y = sizeof(_width)+sizeof(_height)+....+sizeof(-widths) dann (X-Y) / sizeof(uint8_t) Vielleich so?
-
Thread
STM32 - 16Bit Integer Wert über UART senden
uint32_t b; uint8_t *c }mystruct_t; mystruct_t my; HAL_UartSend( UART1 , (uint8_t*) &my , sizeof(mystruct) );
-
Thread
MLX90393 - NACK beim Schreiben
0x3F) << 0x02)}; I2C_Error_t ErrorCode = I2CM_WRITEBYTES(MLX90393_INTERFACE, MLX90393_ADDRESS, sizeof(Tx), Tx, FALSE); // ToDo: Add timeout if(ErrorCode == I2C_DATA_ERROR) { ErrorCode = I2CM_WRITEBYTES(MLX90393_INTERFACE, MLX90393_ADDRESS, sizeof(Tx), Tx, FALSE); } ErrorCode = I2CM_READBYTES
-
Thread
Datenübertragung mit NRF24le1 auf A. Nano als interrupt
printMessage(); sendMessage(); } } void sendMessage(){ radio.write(&message, sizeof(message)); } void printMessage(){ for(int i = 0; i < 6; i++){ Serial.print(message[i]);//Sending the message to receiver } Serial.println(""); } boolean updateMessage(){
]); receivedMessage = false; } } void incommingmessage() { radio.read(&settings, sizeof(settings)); //Reading the data receivedMessage = true; // Variable setzen, dass eine neue Nachricht zur Auswertung bereit steht } //void attachSettings(){} void colorWipe(uint32_t color