-
Thread
Arduino Mega2560 mit externem RAM: linker flag für .data section geht nicht
*/ Serial.println(); Serial.print("Dynamic buffer 1 of "); Serial.print(arraysize * sizeof(uint32_t)); Serial.print(" bytes created, address: 0x"); Serial.println((uintptr_t)dataBuffer1, HEX); Serial.print("Dynamic buffer 2 of "); Serial.print(arraysize * sizeof(uint32_t));
uintptr_t)dataBuffer2, HEX); Serial.print("Dynamic buffer 3 of "); Serial.print(arraysize * sizeof(uint32_t)); Serial.print(" bytes created, address: 0x"); Serial.println((uintptr_t)dataBuffer3, HEX); Serial.print("Dynamic buffer 4 of "); Serial.print(arraysize * sizeof(uint32_t));
-
Thread
type/typedef of struct member element?
#define QOVRP_ON return QOVERRUN //write protection on //helper function #define mQSIZE(s) (sizeof(s)/sizeof((s)[0])) /*****************************************************************************/ #define QUEUE(QNAME, QTYPE, QNUM, QCALL_RV, QOVRP
schrieb im Beitrag #6923735: > Einfach die 0 weglassen... ... dann gibt es eine Brandmauer mit sizeof()
-
Thread
PAL-Röhren TV auf NTSC umbauen
receive_event); Wire.onRequest(request_event); // Master simulation memset(&bbi2c, 0, sizeof(bbi2c)); bbi2c.bWire = 0; // use bit-bang bbi2c.iSDA = 2; // Port "D2" (green) bbi2c.iSCL = 3; // Port "D3" (blue) I2CInit(&bbi2c, 50000L); // 50 kHz clock } /** * Data is send from
-
Thread
ITOA ohne Division/Modulo
uint16_t val) { //asm volatile("BKPT #0"); static char digit[5]; for(uint8_t x = 0; x < sizeof(digit); x++) digit[x] = '0'; while(val > 9999) { val -= 10000; digit[0]++; } while(val > 999) { val -= 1000; digit[1]++; } while(val > 99) { val -= 100; digit[2]++; } while(val
-
Thread
[C++] Was passiert mit globalen Variablen nach Programmausführung?
überschreiten. [c] int main(int argc, const char *argv[]) { char myarr[10000000]; myarr[sizeof(myarr)-1]=22; return 0; } [/c] zeigt einem schnell wo die Grenzen sind.
5 int main(int argc, const char *argv[]) 6 { 7 char myarr[10000000]; 8 myarr[sizeof(myarr)-1]=22; 9 printf("%d\n", myarr[sizeof(myarr)-1]); 10 return 0; 11 } [/c]
-
Thread
printf ersetzen
Controller wohl nicht für u32. man könnte jeden Parameter von __VA_ARGS__ erst überprüfen lassen if(sizeof(u32var) >4 then (int) weil der wert eh nicht mehr als 1 ist.. zumindest in dem programmteil den ich gesehen habe
die Hexadezimaldarstellung einer int-Variable. Das ändert nur das Aussehen, nicht die Größe (sizeof) der Variablen.
-
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
ESPnow sendet nur die ersten 32 Bit
Eine Möglichkeit: Versuch mal ein unsigned char Array zum Testen. Zweite Möglichkeit: sizeof() durch festen Wert ersetzen.
void OnDataRecv(const uint8_t * mac, const uint8_t *temp, int len) { int lenLim =len; if(lenLim>sizeof(inmstrg)) { lenLim = sizeof(inmstrg); } memcpy(&inmstrg, temp,lenLim); Serial.print("Bytes received: "); Serial.println(lenLim); for ( int i = 0; i < 4; ++i ) { // loop through
-
Thread
struct list_head Funktionalität auf Cortex-M4 nutzen
{ "get", &moduleIO_get } }; const Module moduleIO { "IO Module", &moduleIO_functions, sizeof(moduleIO_functions)/sizeof(moduleIO_functions[0]) }; [/c] modules_def.h: [c]#include <stddef.h> #include "module.h" extern const Module modules [3]; static const size_t numModules = 3;
-
Thread
Größe eines #define String mit sizeof ermitteln
Länge bis zur ersten 0 liefert, sizeof beim string literal dagegen die bis zur letzten. Beispiele: [c] strlen("test"); // 4 sizeof("test"); // 5 strlen("test\0test"); // 4 sizeof("test\0test"); // 10 char *test = "test"; strlen(test); // 4 sizeof(test); // sizeof(char +) [/c]
-
Thread
Wert wird nicht übernommen in Struktur
ich nämlich noch nicht! Naja, malloc allokiert Speicher mit der angegebenen Größe in Bytes. sizeof(vtss_state) würde jetzt hier die Größe einer Adresse nehmen, weil vtss_state ein pointer zu einem pointer ist. sizeof(*vtss_state) würde jetzt hier die Größe einer Adresse nehmen, weil *vtss_state
vtss_inst_create(const vtss_inst_create_t *const create, vtss_inst_t *const inst) { vtss_state = malloc(sizeof(*vtss_state)); memset(vtss_state, 0, sizeof(*vtss_state)); vtss_state->cookie = 123; vtss_state->create = *create; (*inst) -> create = *create; // beispielsweise...
-
Thread
Wie FSM mit Events in Tabelle umsetzen (C)?
state= stateNr, .eventTable= &(struct eventTransTab_s []){ ##__VA_ARGS__ }, \ .eventTableSize = sizeof((struct eventTransTab_s []){ ##__VA_ARGS__ }) / sizeof( struct eventTransTab_s )} #define CREATE_FSM_TABLE( ... ) .stateTableSize= sizeof((struct fsm_state_data_s []){ ##__VA_ARGS__ }) / sizeof
= sizeof((struct eventTransTab_s []){{ . eventId= (event_id_t)EV_TWO, . nextState = (uint16_t)STATE_ZERO, . transFunc = 0 }, }) / sizeof( struct eventTransTab_s )}, }) / sizeof( struct fsm_state_data_s ),
-
Thread
C Frage zu Subtraktion
puts("8 Bit"); uint8_t c=1; uint8_t d=0xFF; printf("%X + %X = %X (%d bytes)\n",c,d,c+d,sizeof(c+d)); printf("%X - %X = %X (%d bytes)\n\n",c,d,c+d,sizeof(c-d)); puts("16 Bit"); uint16_t e=1; uint16_t f=0xFFFF; printf("%X + %X = %X (%d bytes)\n",e,f,e+f,sizeof(e+f)); printf("%X - %X = %X (%d bytes)\n\n",e,f,e+f,sizeof(e-f)); puts("32 Bit"); uint32_t g=1; uint32_t h=0xFFFFFFFF; printf("%lX + %lX = %lX (%d bytes)\n",g,h,g+h,sizeof(g+h)); printf("%lX - %lX = %lX (%d bytes)\n\n",g,h,g+h,sizeof(g-h
-
Thread
structs in char*
Endianess bestimmt ist sicher nur ein Versehen. Und die genaue Größe der Struktur ist relativ egal, sizeof & co berücksichtigen das.
so groß, dass es passt. Probleme gibt es nur, wenn Du irgendwelche Dinge selbst ausrechnest (ohne sizeof oder []), vor allem wenn es um Arrays von Strukturen geht. Aber wenn bei Dir doch alles funktioniert, dann OK, freut mich!
-
Thread
Arduino->WS2812B-> Arduino
TestData[idx]; pixels.setPixelColor(NUMPIXELS, data); pixels.show(); idx++; if(idx>=sizeof(TestData)/sizeof(uint32_t))idx=0; //data++; // increase test data transmittet after last LED // NeoPixel Lauflicht ledPos++; if (ledPos >= NUMPIXELS)ledPos = 0; delay(2000); }
-
Thread
AVR-Debugging: Speicherstelle überwachen
Index und ich muß nichts atomar kapseln. Auch kann ich den Index einfach auf Überlauf testen (mit sizeof vergleichen), unterlaufen kann er ja nicht.
-
Thread
AT90USB162 Endpoint Interrupts funktionieren nicht
UTF-16 codieren. [c] { .bLength = sizeof(struct string_descriptor) + sizeof(USB_VENDOR_NAME) - sizeof(wchar_t), .bDescriptorType = STRING_DESC, .bString = USB_VENDOR_NAME }; [/c] mit USB_VENDOR_NAME [c] #define
auch völlig logisch. Diese Berechnung: [c] #define WCHAR_TO_STRING_DESCRIPTOR(wchar) { \ sizeof(USB_String_Descriptor) + sizeof(wchar) - 2, \ DESCRIPTOR_TYPE_STRING, \ wchar \ } [/c] setzt ja voraus, dass sizeof(USB_String_Descriptor) eben *nicht* bereits den tatsächlichen
-
Thread
C++/placement new: irgendein Grund warum std::string problematisch sein sollte?
{ char buffer[sizeof(std::string)]{}; std::string* c = new (buffer) std::string(); std::string& rc = *c; rc = "hallo"; rc = "bert"; rc = std::string("uwe"); rc.assign(std::string
in dem buffer initialisiert jetzt ist im buffer der Aufbau --- 0: sizeof(double) bytes 8 8: sizeof(int8_t) bytes 1 10: sizeof(std::string(der hat selbst einen Zeiger)) bytes (~30-40) --- der buffer sieht jetzt exakt so aus wie ein C++ struct der Art im Speicher -
-
Thread
Beim Byte die Bits am schnellsten umsetzen.
b4 : 1; unsigned b5 : 1; unsigned b6 : 1; unsigned b7 : 1; }; static_assert(sizeof(struct b8) == sizeof(uint8_t)); struct b8 in; memcpy(&in, &u8, 1); const struct b8 out = { .b0 = in.b7, .b1 = in.b6, .b2 = in.b5, .b3 = in.b4, .b4 = in.b3, .b5
-
Thread
USB-Stringdeskriptor ohne Abzählen
auto landingpageurldesc_f(byte h,const char*s) { landingpageurldesc_t<N>A={}; static_assert(sizeof A<256,"URL too long!"); A.l=sizeof A; A.t=3; // Descriptor type: string (really!) A.h=h; // protocol, 0=http, 1=https for (int i=0;i<N;i++) A.s[i]=s[i]; return A; } #define LP(h,s) (landingpageurldesc_f
landingpageurldesc_f(byte h,const char*s) > { > landingpageurldesc_t<N>A={}; > static_assert(sizeof A<256,"URL too long!"); > A.l=sizeof A; > A.t=3; // Descriptor type: string (really!) > A.h=h; // protocol, 0=http, 1=https > for (int i=0;i<N;i++) A.s[i]=s[i]; > return A; > } > #define
-
Thread
C arithmetic promotion Fallstricke
auf Lager. Wer hat schon mal > probiert, was bei > > [code] > const char c = 'A'; > printf("sizeof(c) = %d\n", sizeof(c)); > printf("sizeof 'A' = %d\n", sizeof 'A'); > unsigned char c2 = 0xff; > printf("%02x %02x\n", c2, (char) c2); > > > [/code] > > rauskommt (und warum)? > Extrapunkte
Überraschung auf Lager. Wer hat schon mal > probiert, was bei > const char c = 'A'; > printf("sizeof(c) = %d\n", sizeof(c)); > printf("sizeof 'A' = %d\n", sizeof 'A'); > unsigned char c2 = 0xff; > printf("%02x %02x\n", c2, (char) c2); > > rauskommt (und warum)? Der Code hat undefiniertes
-
Thread
If statement wird nicht ausgeführt trotz korrektem Vergleich? (TMS320F28388D)
zum TMS320F2808 hat, mit dem hab ich damals in der Diplomarbeit gearbeitet. Schau dir bitte mal sizeof(char) an. Beim 2808er sind das nämlich 16 Bit, d.h. der Chip kann keine kleineren Dateneinheiten verarbeiten (evtl. Bits einzeln noch) bei [code] uint8_t command_code=buffer[0]; [/code] könnte
-
Thread
Array - Summe berechnen in C
Das Array muss vor der Benutzung initalisiert werden. Beispiel: [c] memset(my_array,0,sizeof(my_array)); [/c]
-
Thread
C++ template Funktion doppelt definiert in header und cpp
peripheral->spi)) { return queue_transfer(tx_buffer, tx_length, rx_buffer, rx_length, sizeof(Type) * 8, callback, event); } start_transfer(tx_buffer, tx_length, rx_buffer, rx_length, sizeof(Type) * 8, callback, event); return 0; } [/code] und in SPI.cpp
range" error uint16_t rx_data[8] = {0}; spi.transfer(tx_data, tx_word_len * sizeof(*tx_data), rx_data, rx_word_len * sizeof(*rx_data), nullptr); [/code] das ist Teil von einem Testcode, deshalb die 'komische' Größenangabe.
-
Thread
C: Kann man mittels #define einen Wert zurück geben?
einen "byte-Puffer". Dann ist kein Makro für Create: Beispiel: [c] #define STRUCT_SIZE(n) (sizeof(myStruct_t) + sizeof(unsigned)*n) static unsigned char buf_A[STRUCT_SIZE(50)]; p_myA = CreateMyStruct(buf_A, sizeof(buf_A), "myA" ); [/c] Aufruf nur mit Speicher, Größe und Namen. CreateMyStruct
/* und aufruf Deiner Funktion wie bisher */ return _CreateStruct(p, name, a, size/(sizeof unsigned) ); } [/c]
-
Thread
STM32 HAL UART Mysterium oder bin ich dumm?
UART_Init(); ... uint8_t tx_buffer[100]; serial_init(&serial2, &huart2, rx2_buffer, sizeof(rx2_buffer), tx2_buffer, sizeof(tx2_buffer)); while(1) { ... // senden sprintf((char *)tx_buffer, "hallo."); serial_write_buf(&serial2, tx_buffer, strlen((char
-
Thread
microchip user space api wie nutzen für phi ?
board. Assign point to the board definition board = &board_table[0]; memset (&board_table[0], 0, (sizeof(vtss_appl_board_t) * MAX_BOARD_INSTANCES)); [/code] // Sie initialisieren das Board: --- [code] vtss_board_phy_init(board); //sie kreieren ein Board: // "Create" the board vtss_inst_get(board
, buffer); T_N("mmd_read_rbt: %s", buffer); socket_write(&buffer[0]); memset(buffer, 0, sizeof(buffer)); socket_read(&buffer[0]); [/code] (Aber es ist seltsam, da dieses Beispiel einen Socket für SPI verwendet. Vielleicht hat jemand eine Idee dazu) Ich sollte also meine eigene Board-Definition
-
Thread
Verwendung von Serial.readStringUntil
test[56]; template<typename T> void zeigeArrayGroesse(T &array) { cout << F("zellengr: ") << sizeof(*array) << endl; cout << F("anzzellen: ") << (sizeof(array)/sizeof(*array)) << endl; } void setup() { Serial.begin(9600); cout << F("Start: ") << F(__FILE__) << endl; zeigeArrayGroesse
typename T, size_t anzzellen> void zeigeArrayGroesse(T (&)[anzzellen]) { cout << F("zellengr: ") << sizeof(T) << endl;//*array cout << F("anzzellen: ") << anzzellen << endl; } [/c] Hier ist die Referenz dann gar anonym.
-
Thread
I2C Implementierung ATmega32 in C funktioniert nicht
read_temperature_pressure_humidity(&t, &p, &h); > [/c] > sein? Man könnte wohl auch float *p; p= (float*) malloc( sizeof(float) ); ms8607_read_temperature_pressure_humidity(t, p, h); t und h entsprechend.
-
Thread
Wechselrichter Hoymiles HM-xxxx 2,4 GhZ Nordic Protokoll?
uint8_t ch; Serial.println(richtung); // drucke zuerst als Zeichen for (int i = 0; i < sizeof(mBuffer); i++) { ch = mBuffer[i]; if (ch >= 32 && ch < 127) Serial.print(ch); else Serial.print ('.'); } Serial.println(); // jetzt das ganze in Hex for (i = 0; i < sizeof(mBuffer
2, 100 }, { FLD_T, UNIT_C, CH0, CMD83, 7, 2, 10 } }; #define HM800_LIST_LEN (sizeof(hm800assignment) / sizeof(byteAssign_t)) [/c]
-
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
Struct Array an Funktion übergeben
dieser Stelle äquivalent zu &arr[0] my_array* p2 = &arr; printf("Größe von arr: %zd\n", sizeof arr); // bei sizeof ist &arr[0] nicht äquivalent zu arr printf("Größe von &arr[0]: %zd\n", sizeof &arr[0]); printf("Größe von dem, worauf p1 zeigt: %zd\n", sizeof *p1); printf("Größe von dem, worauf p2 zeigt: %zd\n", sizeof *p2); } [/c]
-
Thread
STM32H743ZI - SPI DMA HAL Interrupt Probleme
SCB_CleanDCache_by_Addr(reinterpret_cast<uint32_t*>(((uint32_t)spiTxBuffer) & ~uint32_t(0x1F)), sizeof(spiTxBuffer) + 32); SCB_InvalidateDCache_by_Addr((uint32_t*)(((uint32_t)spiRxBuffer) & ~(uint32_t)0x1F), sizeof(spiRxBuffer) + 32); const auto ret = HAL_SPI_TransmitReceive_DMA(this->spi_handle
-
Thread
int32_t eeprom_write_block
eeprom_read_dword(&eeCalibrationAddend_b); eeprom_write_block(&calibrationAddend_b, &eeCalibrationAddend_b, sizeof(eeCalibrationAddend_b)); } void save_Cali() { ... //eeprom_update_dword(&eeCalibrationAddend_b, calibrationAddend_b); eeprom_update_block(&calibrationAddend_b, &eeCalibrationAddend_b, sizeof(eeCalibrationAddend_b)); } [/c] Passt das so oder habe ich noch grobe Schnitzer drin?