-
Thread
Asynchrone Kommunikation programmieren
das Protokoll geändert, ohne den Puffer anzupassen. Ich nehme daher für den Überlauftest immer sizeof() und keine magische Nummer. Dann macht der Compiler den Test immer richtig.
-
Thread
STM32 - UART Ausgabe - Wie richtig?
UART_HandleTypeDef *huart, uint16_t Size ){ //if(huart -> Instance == USART2 ){ for(int i=0;i < sizeof(MainBuf) ; i++){ MainBuf[i] = '0'; } memcpy ( MainBuf, RxBuf, Size ); for(int i=0;i < Size ; i++){ RxBuf[i] = '0'; } HAL_UARTEx_ReceiveToIdle_DMA(&huart2
-
Thread
Dauerkontakt vom Schalter in Impuls umwandeln
Serial.print("\t"); } Serial.println(); } uint8_t InputCount() { return sizeof(inputPins) / sizeof(int); } void ReportConfigReadable(int idx) { inputs[idx].ReportConfigReadable(); } void ReportValues() { Serial.write("V"); for (int i = 0; i < InputCount
-
Thread
Suche nach Schaltung für Signalverzögerung
Verzögerungszeit kann man leicht über die Bufferlänge anpassen, die Bufferverwaltung passt sich per sizeof() an die vorgegebene Länge an. Der Watchdog hier ist eine Trantüte, der macht aus den 15 ms gute 20 ms. Da müsste man die Bufferlänge entsprechend justieren. Das Oszi ist grausig angeschlossen
-
Thread
Welchen Sinn hat der Datentyp "bool"?
Wobei der fehlende Ptr viele weitere Dinge impliziert, z.b. Ansicht im Debugger, Arraxs, memcpy, sizeof...
Datentypen keine Angst zu haben, dass nur die unteren Bits beachtet werden. 0x40000 in einen bool mit sizeof(bool) == 1 zu casten, liefert 1. Das gleiche in einen uint8_t zu casten, liefert 0.
-
Thread
Turbo51 und CH55x
case-Abfrage im Quelltext) [pre] ... {product} $302 : begin move( prod, buf0, sizeof( prod ) ); stage := data; ... [/pre] Frage: Warum zeigt der USB Device Tree Viewer "String descriptor not found"? [pre] ------------------ Device Descriptor --
-
Thread
ILI9341 SPI Pixel auslesen geht teilweise. ID4 auslesen nicht
aux_spi_setCS(2); char rxBuf[4] = { 0x00, 0x00, 0x00, 0x00 }; bcm2835_aux_spi_transfern(rxBuf, sizeof(rxBuf)); bcm2835_gpio_write(RPI_BPLUS_GPIO_J8_36, HIGH); //CS High to end transmission bcm2835_gpio_fsel(RPI_BPLUS_GPIO_J8_36, BCM2835_GPIO_FSEL_ALT4); //Back to
-
Thread
Austausch C Coden sehr abstrakt
(dann noch > als Erweiterung von GCC) gern benutzt habe. Sowas fasse ich nicht ohne Not an. sizeof(struktur) liefert nicht mehr die reale Datensatzgröße. Damit erforderlich: Noch mehr Obacht mit memcpy() usw. Und der Compiler kann einen nicht warnen. Natürlich gibts in C keinen Copy Konstruktor
noch >> als Erweiterung von GCC) gern benutzt habe. > > Sowas fasse ich nicht ohne Not an. > sizeof(struktur) liefert nicht mehr die reale Datensatzgröße. Es liefert halt die Größe ohne das flexible array, also mit einem leeren Array, genau so, wie es auch hingeschrieben wird. Immer noch besser
-
Thread
Offset eines Struktur-Elements bestimmen ohne vorhandene Variable
typeA_t varA; typeB_t varB; int main (void) { eeprom_read_block (&varA, &eeprom.varA, sizeof (varA)); eeprom_read_block (&varB, &eeprom.varB, sizeof (typeB_t)); return 0; } [/c] Beim Zugriff hat man die entsprechenden Objekte doch zur Hand.
<eeprom source address>; copy_from_eeprom_to_ram(&ram_destination, &(eeprom_source->common), sizeof(common_data)); [/c] Ach ja, alles unter der Annahme man hat das Allignment im Griff.
-
Thread
WinUI3 Dateioperationen
string"; int numwritten; fopen_s(&pfile, "c:\\PlanetCNC\\test.txt", "w+t"); fwrite(s, sizeof(char), 30, pfile); fclose(pfile); } [/code]
-
Thread
EEPROM Arduino long zahl
Atmega2560 hat 4K Eeprom, die Adressen laufen also bis 4095. Die Größe einer Variablen in byte liefert sizeof(). Damit kannst du die die Adressen deiner Daten im Eeprom ausrechnen anstatt sie hart zu codieren. Oder du benutzt, noch eleganter, das EEMEM-Konstrukt des gcc wie oben von arduinof schon beschrieben
-
Thread
Diverse fragen zu Hash Maps in C
hash2(PCSTR key, SIZE_T len){ // Round up to multiple of the size of UINT unsigned char a[(len+sizeof(UINT)-1)/sizeof(UINT)*sizeof(UINT)]; memset(a, 0, sizeof(a)); memcpy(a, key, len); unsigned char b[sizeof(a)]; hash(len, b, a); return *(UINT*)b+(sizeof(b)-sizeof(UINT)); } [/c]
hash2(PCSTR key, SIZE_T len){ // Round up to multiple of the size of UINT unsigned char a[(len+sizeof(UINT)-1)/sizeof(UINT)*sizeof(UINT)]; memset(a, 0, sizeof(a)); memcpy(a+(sizeof(a)-len), key, len); unsigned char b[sizeof(a)]; hash(len, b, a); return *(UINT*)b; } [/c]
-
Thread
Einlesen einer Hex Zahl von stdin
return 1; } // 10 Zeichen aus der Datei lesen size_t elements_read = fread(buffer, sizeof(char), 10, file); if (elements_read != 10) { if (feof(file)) { printf("Ende der Datei erreicht.\n"); } else { printf("Fehler beim Lesen der Datei.
unsigned long adresse; ínt datum1 ínt datum2 }buffer; [/c] size_t elements_read = fread(buffer, sizeof(TELEGR), 1, file); Wichtig ist zu beachten ist, dass die Order (MSB ...LSB), abhängig vom μP, passt
-
Thread
ESP8266 - SoftAP Stopps Working
captivePortal"); if (isCaptivePortalAllowed(request->host().c_str())) { snprintf(SSEWrapperPuffer, sizeof(SSEWrapperPuffer), "%s", "8.8.8.8"); snprintf(CaptivePortalBuffer, sizeof(CaptivePortalBuffer), "http://%s/", SSEWrapperPuffer); if (!isIp(request->host().c_str()) && strcmp(request->host().c_str
-
Thread
Wie Objekte in einem Array aktuell halten und umgekehrt?
[/c] Gespeichert wird alles mit: [c] eeprom_write_block ((void*)&Eepdata, (void*)EEP_START, sizeof(Eepdata)); [/c]
include <Wire.h> #include "MyFRAM_I2C.h" namespace MY_FRAMCONTROL { consteval uint32_t sizeofObject (const auto &data) { return sizeof(data); } consteval uint32_t lengthStructure (const auto &data, const size_t N) { return sizeofObject(data)/N; } constinit uint8_t TWI_BUFFER_SIZE
-
Thread
Tastgrad für 10Hz-Blinken LED
Feldanzahl ist Größe des Feldes in Byte / Variablaengröße hier --> Integer 2 Byte feldanzahl = sizeof(ledFeld)/2; //Alle Pins des Feldes auf Ausgang setzen for (i=0; i < feldanzahl; i++) { pinMode(ledFeld[i], OUTPUT); } pinMode(4, INPUT_PULLUP); //button linker Blinker pinMode
-
Thread
ESP8266 - WiFi "stoppt" seinen Betrieb - kein Crash - keine Funktion mehr
systemParameters.LedwithinEket); } systemParameters.LedwithinEket = (uint8_t*)malloc(_size * sizeof(uint8_t)); } [/c] Die Funktion für das WiFi: [c] uint8_t WiFiSetup(uint8_t _variant, bool* _switchMode){ if(*_switchMode){ DEBUG_SERIAL.println("[WiFi] Mode Changing!"); if(
aufrufer() { IPAddress ipAddress = ...; char buffer[20]; sseWrapper.toStringIp(buffer, sizeof(buffer), ipAddress); // buffer contains the IP address now } [/c] So entfällt die dynamische Nutzung des Heap. Die Variable ipStr gehört zum Stack der aufrufenden Funktion und wird von ihr
-
Bild
Präsentationsfolie mit Programmcode und Person
multinet = multinet; g_sr_data->model_data = model_data; ESP_LOGI(TAG, "load multinet:%d,%d", mn_name, sizeof(esp_mn_iface_t), sizeof(esp_mn_iface_t)); esp_mn_commands_update_from_sdkconfig(multinet, model_data); esp_mn_commands_add(50, "TURN ON THE KITCHEN LIGHT"); Qianhui Wan 23 Here we are adding two new
-
Thread
Hilfe um 8 Bitfelder in uint8_t umzuwandeln (ESP32)
vorgestellt: [c] // -->: in eigene Library-Header template<uint8_t N, typename T> requires (N < (sizeof(T) * 8)) auto bit(T& v); namespace detail { template<uint8_t N, typename T> requires (N < (sizeof(T) * 8)) struct Bit { friend auto bit<N, T>(T& v); template<typename
explicit Bit(T& v) : d{v}{} T& d; }; } template<uint8_t N, typename T> requires (N < (sizeof(T) * 8)) auto bit(T& v) { return detail::Bit<N, T>{v}; } // <-- Ende Library-Header // Beispiel zur Verwendung std::byte v; int main() { bit<3>(v) = true; bit<7>(
-
Thread
Größe einer beliebigen Reihe, auch unterschiedlich viele Elemente, berechnen.
= {1}; int x2[] = {2, 7, 56, 12, 1, 78}; int x3[] = {2, 3, 4}; struct krempel y[] = { {sizeof (x0) / sizeof (x0[0]), x0}, {sizeof (x1) / sizeof (x1[0]), x1}, {sizeof (x2) / sizeof (x2[0]), x2}, {sizeof (x3) / sizeof (x3[0]), x3}, }; [/c] Das entspricht dem Beispiel von yalu, mit
Harald K. schrieb im Beitrag #7489950: > {sizeof (x0) / sizeof (x0[0]), x0} Was spricht, in diesem Fall, gegen meine Variante? > #define SIZEOF(arr) sizeof(arr) / sizeof(*arr) > > {OutputArray(Array, SIZEOF(Array));} Ist das nicht
-
Thread
uin8_t array to uin32_t
diese Zwecke ein htonl() vor (*) [c] uint32_t value = 0; uint32_t rdata; for (uint8_t i = 0; i < sizeof(data); i+=4) { rdata = *(uint32_t*) (data[i]); //memcpy(&rdata,&data[i],sizeof(uint32_t)); if (MSB_FIRST) rdata = htonl(rdata); value ^= rdata; } //do something with value [/c] (
-
Thread
PIC16F1509/Sansmart LCD2004/I2C , benötige etwas Hilfe
unsigned char Data) { unsigned char tmpData = Data; I2C1_Host.Write(lcdAddress, &tmpData, sizeof(tmpData) ); } void IO_Expander_Write(unsigned char Data) { I2C__Write(Data | BackLight_State); } void LCD_Write_4Bit(unsigned char Nibble) { // Get The RS Value To LSB OF Data..
address, uint8_t *data, size_t dataLength) // & ? I2C1_Host.Write((uint16_t)lcdAddress, &data, sizeof(data) ); // Wire.endTransmission(); } [/c] Da in [c] I2C1_Host.Write((uint16_t)lcdAddress, &data, sizeof(data) ); [/c] alles "versteckt ist" was die I2C-Schnittstelle betrifft wird
-
Thread
for-Schleife - Bit verschieben
Prozessoren von TI, da ist ein char sogar 32 Bit breit. Mancher ist dabei verwirrt, wenn er sieht, dass sizeof (float) == 1 ist. ───────────── ¹) Wieso eigentlich in cstddef, wo ich doch nur C-Datentypen und -Makros erwarten würde? ²) Wegen der Deklaration von std::byte als enum class sind auch die
Prozessoren von TI, da ist ein char sogar 32 Bit breit. Mancher ist > dabei verwirrt, wenn er sieht, dass sizeof (float) == 1 ist. Ja, er hat 16/16/32, so wie es TI beschreibt. Der C++-Compiler ist auf dem Stand C++03, also es dauert von ein paar Jahrzehnte, bis auch da ein std::byte Einzug hält. >
-
Thread
Wertzuweisung Arduino - Kann mir das jemand erklären?
für echte 32 Bit CPUs definieren int mit 32 bit, da besteht das Problem so nicht, denn dort gilt sizeof(int)==sizeof(long). Frag nicht, wer und warum er den Käse so erfunden hat.
-
Thread
Nicht Kompilieren bei einem bestimmten Wert in einem const array
const int test[][4] = {{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4} }; #define ARRAY_COUNT(a) (sizeof(a)/(sizeof(a[0]))) int main() { // Assertions: Parameter 2 jedes Datendsatzes muss kleiner 5 sein // Schleife wird durch -O1 vollständig raus optimiert. for(size_t i=0; i<ARRAY_COUNT(test
if( !(cond)) {assert_by_nonexisting_function__##msg();} \ } while(0) #define ARRAY_COUNT(a) (sizeof(a)/(sizeof(a[0]))) const int test[][4] = {{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,222,3,4},{1,2,3,4}, {1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4}}; /* Const Assertions
-
Thread
Statische 2D Char Arrays mit verschiedenen Größen
jeweils 10 Chars. Kann ich jetzt die ersten 2 Char Arrays mit 100 Bytes deklarieren ? So daß sizeof(a[0]) = 100 sizeof(a[1]) = 100 sizeof(a[2]) = 10 sizeof(a[3]) = 10 sizeof(a[4]) = 10 Ich möchte keine dyn. Arrays auf dem Heap haben. Viele Grüße Werner
> sizeof(a[0]) = 100 > sizeof(a[1]) = 100 > sizeof(a[2]) = 10 > sizeof(a[3]) = 10 > sizeof(a[4]) = 10
-
Thread
Optimierung von Funktionen
pResultCount) { int* ptr; bool valueExisting; *pResultCount = 0; ptr = (int*)calloc(count, sizeof(int)); ptr[*pResultCount] = values[0]; (*pResultCount)++; if (count >= 1) { for(size_t x=1; x<count; x++) { valueExisting = false; for (size_t y=0; y<*pResultCount
= uniqueIndex; } int main() { int values[] = {1, 1, 1, 2, 3, 0, 2}; size_t count = sizeof(values) / sizeof(values[0]); removeDuplicates(values, &count); // Hier können Sie auf die eindeutigen Werte in 'values' zugreifen // und die Anzahl der eindeutigen Werte ist in '
-
Thread
Zugriff auf struct über Pointer unter Visual Studio macht Probleme.
BMP_DateiKopf_p_type; #pragma pack(pop) int main(array<System::String ^> ^args) { printf("sizeof unpacked: %d\n", sizeof(BMP_DateiKopf_type)); //sizeof packed: 16 printf("sizeof packed: %d\n", sizeof(BMP_DateiKopf_p_type)); // sizeof packed: 14 Boolean b; return 0;
Wo trennst Du das? Schon das da [c] int main(array<System::String ^> ^args) { printf("sizeof unpacked: %d\n", sizeof(BMP_DateiKopf_type)); //sizeof packed: 16 printf("sizeof packed: %d\n", sizeof(BMP_DateiKopf_p_type)); // sizeof packed: 14 Boolean b; return 0; } [/c
-
Thread
Objektinitialisierung mit Parametern im Konstruktor in C++
drin - wenn nicht noch mehr Daten in ClassA gehalten werden > sollen. Warum? Auf meinem PC ist sizeof(ObjectA) == 1, dann wird es das auf einem avr auch sein. Ich wüsste auch nicht, warum es größer sein müsste. > Ach so zur Begrifflichkeit noch: unter 'parametrisiert' verstehe ich > irgendwas mit
-
Thread
Index von Array: welcher Datentyp in C
auf den Anfang des Arrays. Der Code bleibt abgesehen davon, > dass ich die Größe nicht mehr mit sizeof bestimmen kann, genau gleich. Genau, hier hast Du mal ein Beispiel dafür, wo ein array-Bezeichner nicht zerfällt und anschließend, wo er in einen Zeiger zerfällt. > Eurer Argumentation nach
bis +4 int a[] = { 16, 9, 4, 1, 0, 1, 4, 9, 16 }; // Aanzahl der Elemente von a #define n (sizeof a / sizeof a[0]) // Index des mittleren Elements von a (die 0) #define k (n / 2) // Zeiger in die Mitte von a int *p = a + k; // p kann nun wie ein Array mit dem Indexbereich [-4,+4] verwendet
