-
Thread
uin16_t ist/wird negativ bei 0x8000.
anfängt. Aber selbst wenn ich es zu einem uint16_t caste also so: [code] snprintf_P(strBuffer, sizeof(strBuffer), PSTR("Config 3: %d VAR: %d\r\n"), config, (uint16_t)ADS1015_REG_CONFIG_OS_SINGLE); [/code] bleibt das Ergebnis unverändert. Also immer noch negativ. Dadurch sollte der Compiler doch
> Wie gibst du die Zahl auf der Seriellen aus? So: [code] snprintf_P(strBuffer, sizeof(strBuffer), PSTR("Config 3: %d VAR: %d\r\n"), config, (uint16_t)ADS1015_REG_CONFIG_OS_SINGLE); sendToSerial(COMM_INTERNAL, strBuffer); [/code] Comm_Internal gibt nur an das die Daten über den
-
Thread
STM32 USB Übertragungsproblem mit Code von S.F.
if (UsbRxBufferContains('\n')) { char buf[256]; UsbGetStr(buf,sizeof(buf),'\n',0); UsbSendStr(buf,10); } */ // LED Off WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BR5); WRITE_REG(GPIOC->BSRR, GPIO_BSRR_BS13);
{ uint8_t *s = &SerialStr[0]; uint8_t b; int i; for (i=0; i < sizeof(SerialStr); i++) SerialStr[i]=0; //memset *s++ = U_ID_SIZE *2 * sizeof(uint16_t) +2; *s++ = 0x03; i = U_ID_SIZE-1; //0..11 while(i > -1) //rückwärts lesen {
-
Thread
Frage zu Datentypen in C++
Bit-System ist das nicht ungewöhnlich. Auf 32 Bit Systemen Ok, aber auf welchem 64 Bit System ist denn sizeof(double) == sizeof(float)?
= Bytes * 8; oder return number - 1; deine Anwendung von *= und -= ist total komisch sizeof float, double sollte 4 und 8 ergeben, oder machst du sizeof pointer?
-
Thread
AVR C Programmierung unter Linux
volatile double d = 10./9; #include "avrtest.h" int main() { printf ("Layout: %d/%d/%d\n", sizeof (float), sizeof (double), sizeof (long double)); LOG_FMT_FLOAT ("f = %.20f\n", f); LOG_FMT_DOUBLE ("d = %.20f\n", d); LOG_FMT_FLOAT ("81*f^2 = %.20f\n", 81*f*f); LOG_FMT_DOUBLE
; usart0.println("Hallo ich bin USART.0."); usart0.println(sizeof(float)); usart0.println(sizeof(double)); float f = 1.123456789; float g = 3.0; double d = 1.123456789;
-
Thread
attiny85 EEPROM schreiben/lesen
char getByte, eeData[250+1]; uint8_t i=0; while (getByte = EEPROM.read(eeAddr+i) && i!=sizeof(eeData)) { eeData[i++] = getByte; } data[i] = getByte; return String(eeData); }
Schreiben um 1x öfter laufen als der String lang ist. Was ist data[Länge+1]? Beim Lesen: Wie weiss sizeof(eeData) wie lang der String ist?
-
Thread
C++17, Macro-Parameter mit :: Verbinden?
Produktiv-Codes [c] struct MemberInfo { const char* name; size_t alignof_; size_t sizeof_; size_t offsetof_; }; #define MEMBER_INFO( Struct, Member ) MemberInfo { #Member, alignof( Struct##::##Member ), sizeof( Struct##::##Member ), offsetof(Struct,Member) } [/c]
int main() { constexpr MemberInfo mi = MEMBER_INFO(A, b); return mi.sizeof_; } [/c]
-
Thread
C++17, ueber Tuple UND Parameter-Pack iterieren?
habe // Spezialisierungen fuer Typen die // hier Berechnungen,usw. machen return sizeof(value_); } }; template <typename... ValueType> class many { public: using Singles = std::tuple<single<ValueType>...>; static int xyz( const ValueType&... value_ ) {
-
Thread
C Ringspeicher
static u8 txbuf[16], txw; static volatile u8 txr; void uart_putc(u8 c) { u8 w = (txw + 1) % sizeof(txbuf); sleep_while (w == txr); // sleep while txbuf full txbuf[txw] = c; barrier("write txbuf before changing txw"); txw = w; UCSR0B |= B(UDRIE0); } [/c]
-
Thread
Aus X Buchstaben Y Wörter bilden - Programmieren
"nine", "no1", "2no", "n30" }; const size_t num_words = sizeof (words) / sizeof (*words); for (size_t i = 0; i < num_words; i++) { bool is_valid = true; for (size_t j = 0; j < strlen (words[i]); j++) { if (toupper (words[i][j])
"niner", "no1", "2no", "n30" }; const size_t num_words = sizeof (words) / sizeof (*words); for (size_t i = 0; i < num_words; i++) { bool is_valid = true; for (size_t j = 0; j < strlen (words[i]); j++) { if (toupper (words[i][
-
Thread
Arduino & EEprom
also Adresse 29 und 30 Was vorher auf 30 stand, ist unwiederbringlich verloren Ein einfaches sizeof(12) beweist dir das.
nicht mit der Eeprom Lib blind vergleichen. Doch! Wenn man in die Lib schaut, sieht man, dass sizeof() verwendet wird. [c] template< typename T > const T &put( int idx, const T &t ){ EEPtr e = idx; const uint8_t *ptr = (const uint8_t*) &t; for( int count = sizeof(T
-
Thread
uCTest: unit test framework
filter_bq_init( &filter, &f_cfg ); int16_t y; int i; for( i = 0; i < ( int ) ( sizeof( data ) / sizeof( int16_t ) ); i++ ) { int16_t x = data[ i ]; y = filter_bq_compute( &filter, x ); ASSERT_EQ( y, res[ i ] ); } EXPECT_NEAR( y, 0, 5 ); } [/c
-
Thread
Verständnisproblem in AVR C Syntax Gesperrt
Und das ist eben char. Welches keineswegs auf 8Bit fixiert ist. Ein char ist immer 1 Byte groß (sizeof(char) == 1). Ein Byte ist aber nicht unbedingt 8 Bit groß. In C ist nur definiert, dass es mindestens 8 Bit breit ist. Auf einem DSP, der nativ 24 Bit hat und in nichts kleinerem rechnen kann, könnten
-
Thread
AVR Flash jenseits der 64kB
function for array tab located in .flash1 uint8_t getTab(const uint16_t idx) { return (idx < sizeof(tab)) ? tab[idx] : 0; } [/c]
-
Thread
verständisfrage zu pointer auf array
setze a[4] auf 44\n"); a[4] = 44; printf("wert b0: %i\n", b[0]); printf("groesse a: %u\n", sizeof(a)); printf("groesse b: %u\n", sizeof(b)); printf("wert b12: %i\n", b[12]); printf("wert a16: %i\n", b[16]); return 0;[/c] die Ausgabe ist [code] adresse b: 00400080 adresse
-
Thread
Arduino und die String Klasse
allozierbarer Speicher. Muss aber im Linker definiert sein wie gross und wo der liegt. [c] p = malloc(sizeof(int)); if(p != NULL) { *p=99; printf("Allokation erfolgreich ... \n"); } [/c]
-
Thread
Bitte um Mithilfe bei Identifizierung Mikrocontroller
/ Letztes nibble (msg[8]&0xF) soll Prüfsumme erhalten: uint8_t chksum = 0; for (uint8_t i=0; i<sizeof(msg); i++) { chksum += msg[i]>>4; if (i<sizeof(msg)-1) { chksum += msg[i]&0xF; } } chksum &= 0xF; msg[8] = (msg[8]&0xF0) | (0xF^chksum); [/c] Oder hab ich mich wieder
-
Thread
Raspberry - Timer
timer; /* Installiere timer_handler als Signal Handler fuer SIGVTALRM. */ memset(&sa, 0, sizeof (sa)); sigemptyset(&sa.sa_mask); sa.sa_handler = &timer_handler; sigaction(SIGVTALRM, &sa, NULL); /* Timer konfigurieren fuer 10 ms ... */ timer.it_value.tv_sec = 0;
-
Thread
Atmega128: Werte vom Poti speichern
uint8_t i; nummer = 0; for(i = 0; i < NUMMER; i++) { New = (element *)malloc(sizeof(element)*1); nummer++; New->zaehl = nummer; /* "0" => leer!! */ if(root == NULL) { New->next = New; /* zeigt auf sich selbst, wenn es noch
-
Thread
STM32 FRAM Modul WREN Bit wird nicht gesetzt
spi_buf[1] = (uint8_t)(adress >> 8); spi_buf[2] = (uint8_t)(adress); for(int i = 0; i < sizeof(pdata) / sizeof(pdata[0]); i++){ spi_buf[i+3] = pdata[i]; } HAL_GPIO_WritePin(FRAM_CS_GPIO_Port, FRAM_CS_Pin, RESET); //Enable FRAM SPI HAL_SPI_Transmit_DMA(FRAM_hspi, spi_buf, (sizeof
#6541006: > void SPI_FRAM_WRITE(uint16_t adress, uint8_t* pdata){ > ... > for(int i = 0; i < sizeof(pdata) / sizeof(pdata[0]); i++){ Du gibst einen Pointer auf einen Buffer runter und berechnest dann die zu übertragende Länge als sizeof(pdata) / sizeof(pdata[0]). Das ist hier aber nicht zielführend
-
Thread
Grösse eines Array of pointers
das äußere Array tab hab ich's gefunden [c] sizeof(tab) / sizeof(int *) [/c] Bleiben noch die inneren arrays
Schreibweise voll äquivalent? oder gibt es irgend welche Tücken bei Verwendung von 2.? 1. [c]sizeof(tab)/sizeof(tab[0])[/c] 2. [c]sizeof(tab)/sizeof(*tab)[/c] Ich hab mir so ein define gebastelt. [c]#define LEN_STR_ARR(A) ((sizeof(A)/sizeof(*A))-1)[/c] Läuft zwar, aber hoffentlich
-
Thread
Terminal - Wie heißt das, was ich suche?
wo); DoCommand (Kommandozeile, wo); InitCmd(wo); } else { if (kzi>=(sizeof(Kommandozeile)-1)) return; if (c==8) { Char_Out(8, wo); Char_Out(' ', wo); Char_Out(8, wo); if (kzi) --kzi; Kommandozeile[kzi]=0; } else
-
Thread
AVR, progmenu array mit strings und unsigned char: will nicht so recht !
{1, "mvi a,?"}, {2, "cmpg a,?"}, {3, '\0'}, {4, "cdis"}, }; const byte ANZAHL = sizeof(daten) / sizeof(Struktur); void setup() { Serial.begin(115200); Serial.println("\nStart"); // klassische Variante // for (byte i=0; i<ANZAHL; i++) // for Range-Based Variante
-
Thread
C++17, Template Parameter-Pack Subset?
.. II> struct size_impl<list<II...>> { using type = std::integral_constant<size_t, sizeof...(II)>; }; template<typename> struct front_impl; template<typename F, typename... II> struct front_impl<list<F, II...>> { using type = F; }; } template<typename
-
Thread
Strings verbinden Gesperrt
Zeichen hinein passen. [c] char a[201]; char b[100]; ... (Eingabe) ... strlcat(a, "&", sizeof(a)); strlcat(a, b, sizeof(a)); [/c]
pointer auf den gleichen String zeigen? Stefan ⛄ F. schrieb im Beitrag #6524734: > strlcat(a, "&", sizeof(a)); > strlcat(a, b, sizeof(a)); Erfüllt nicht die Forderung nach einem dritten String, sondern ist destruktiv auf a. Blöd wenn das eine Konstante ist. Jobst Q. schrieb im Beitrag #6524971
-
Thread
Fehlersuche in C Gesperrt
input) fehler("Datenbank zum Lesen öffnen fehlgeschlagen"); size_t size = fread(db, 1, sizeof(db), input); if (size != sizeof(db)) fehler("Datenbank nicht komplett geladen"); fclose(input); } void db_save() { FILE *output = fopen(DBNAME, "wb"); if (!output) fehler("Datenbank zum Schreiben öffnen fehlgelschlagen"); size_t size = fwrite(db, 1, sizeof(db), output); if (size != sizeof(db)) fehler("Datenbank nicht komplett geschrieben"); fclose(output); } void db_clear() { for (int i = 0; i < DBSIZE; i++) { db[i].anzahl
-
Thread
AVR C array Programmierung wo liegt der Fehler?
Werte des Array mit 0b111... > initalisieren Damals gab es aber noch kein memset und auch kein sizeof
Nick M. schrieb im Beitrag #6516650: > Damals gab es aber noch kein memset und auch kein sizeof Also wir haben damals auch mit der Hand die Bits einzeln in die Lochkarten gestanzt.
-
Thread
C++17, Sind Multi Parameter Packs möglich?
struct Obj { template<typename... Second> static void Func() { std::cout << sizeof...(First) << std::endl; std::cout << sizeof...(Second) << std::endl; } }; [/c]
-
Thread
verschiedene
write.param = *param; write.free = 0xFFFF; write.checkSumme = calcChecksumme((uint8*)&write.param, sizeof(write.param)); eepromWrite(adress, (uint8*)&write, sizeof(write)) } [/c] gleiches für struct2, struct3 and struct4 Diese Structuren sind komplett unterschiedlich Gibt es da einen weg
param; > write.free = 0xFFFF; > write.checkSumme = calcChecksumme((uint8*)&write.param, > sizeof(write.param)); > > eepromWrite(adress, (uint8*)&write, sizeof(write)) Ich vermute Du möchtest malloc vermeiden. Dann mach dir Gedanken eepromWrite neu zu schreiben oder zu wrappen. Es macht
-
Thread
In Konstruktor dynamisch instanz einer Klasse generieren, vererbung, C++
+) { RGB_STRING::string[i*sizeof(RGB_LED)]->set_colors(red,green,blue); } } void RGB_STRING::write_RGB_STRING() { for (int i=0; i < RGB_STRING::number_of_LEDs;i++) { RGB_STRING::string[i*sizeof(RGB_LED)]->set_LED
fehlt eine Größe. Auch das ergibt in mehrererlei Hinsicht keinen Sinn: [C] > RGB_STRING::string[i*sizeof(RGB_LED)]=(RGB_LED*)malloc(sizeof(RGB_LED)); [/C] > Bei > RGB_STRING::string[i*sizeof(RGB_LED)]->RGB_LED::RGB_LED(); > bekomme ich ein: > Error cannot call constructor 'RGB_LED::RGB_LED' directly
-
Thread
std::bit_cast nun auch im gcc / avr-gcc
include <array> using to_t = std::array<int16_t, 2>; namespace { volatile uint8_t from2[sizeof(to_t)]{1, 2, 3, 4}; } int main() { constexpr uint8_t from1[sizeof(to_t)]{1, 2, 3, 4}; constexpr auto v1 = std::bit_cast<to_t>(from1); // constexpr bit_cast now working const
below const auto v3 = []{ to_t data; std::memcpy(&data, (void*)&from2, sizeof(to_t)); // not usable in constexpr-context return data; }(); return v1[0] + v2[0] + v3[0]; } [/c]
-
Thread
struct mit Anforderungen (PC, x64, Windows und Linux, C++20)
Fehlermeldung abbricht, wenn die Bedingungen nicht erfüllt sind? Das sollte mit static_assert und ein paar sizeof und alignof möglich sein.
-
Thread
Array und bubblesort um ein Element erweitern
array /oder/ struct - das sind zwei verschiedene Dinge, die sich ergänzen. [c] #define NELEM(x) (sizeof(x) / sizeof(*(x))) struct sensor { byte id, state, index; }; struct sensor sensor_and_1[] = { { 10, 1, 100 }, { 11, 1, 101 }, { ... }, ... }; static void sensor_sort(struct
-
Thread
C++ : Mit for-Schleife über Objekte verschiedener Klassen iterieren
hat es auch entsprechenden overhead. DU kannst deine Klasse auch [[gnu::packed]] machen und dann sizeof(...) vergleichen. https://en.wikipedia.org/wiki/Virtual_method_table#cite_note-4 https://en.cppreference.com/w/cpp/language/virtual
gepackt werden können, denn wie soll die Adresse von Element X berechnet werden, wenn nicht mit X*sizeof(T) ? Daher der Trick, dass im Array nur der Zeiger steht, denn alle Zeiger sind gleich groß. Das impliziert aber, dass die eigentlichen Objekte noch irgendwo anders abgelegt sind, wo der Zeiger dann
-
Thread
AES256 / SHA384 Chiffren bei HTTPS GET requests mit dem ESP32 nutzen
aufgehoben. Änder den Fehler-Pfad mal ab: [c] char message[100]; client->lastError(message, sizeof(message)); Serial.print("Fehler: "); Serial.println(message); [/c]
client->connect("192.168.200.146", 443)) { char message[100]; client->lastError(message, sizeof(message)); Serial.print("Fehler: "); Serial.println(message); } else { Serial.println("Verbunden"); client->println("GET /api/unlock/generate_pin HTTP/1.0"); client->
-
Thread
Struct im Union über array abfüllen
die Adressen von spare und as_array ganz genau an. Oder ein compiletime assert mit der Größe (sizeof) der Union.
float f; char ch1; char ch2; char str[4]; }; printf("size: %zu\n", sizeof(struct test)); printf("alignment: %zu\n", _Alignof(struct test)); [/c] Und trotzdem braucht diese Struktur 12 Bytes (oder 16, oder 20, ...). Man kann ja auch ein Array erzeugen: [c]
-
Thread
Arduino Uno Serial stört Timer1 Interrupts?
[c] void resetLEDs() { for (int i = 0; i < sizeof(LED_PINS); i++) { digitalWrite(i, LOW); } [/c] Nö, so nicht. Da fehlt der Zugriff auf LED_PINS[]. Eher so [c] void resetLEDs() { for (int i = 0; i < sizeof(LED_PINS); i++) {
for (int i = 0; i < sizeof(LED_PINS); i++) { pinMode(i, OUTPUT); } Hier fehlt das auch. Hier ist es drin. void setLEDs(byte input) { for (int i = 0; i < sizeof(LED_PINS); i++) { byte mask = 1 << i;
-
Thread
C pointer in Struct-Array übergeben
= { {"Zähler 1", &cnt}, {"Zähler 2", &cnt2} }; uint8_t nmbr_of_uint32_t_variables = sizeof(uint32_t_variablen)/sizeof(*uint32_t_variablen); [/c] mit der Funktion void MP_update_array(void) möchte ich nun das Array tx_value_buffer updaten. wie folgt: [c] void MP_update_array(void)
kannst Du auch folgendes machen: *reinterpret_cast<uint32_t*>(pos) = *value; pos += sizeof(uint32_t); So bleibt die Endianess aber gleich! Wenn Du aber Little Endian bist und Big Endian rausschreiben willst wie in Deinem Code (Highbyte first), musst Du die Endianess vorher drehen.