-
Thread
Anfängerproblem mit C
int main(void) { int array_of_ints[] = {3,5,7,11}; for (unsigned long idx = 0; idx < sizeof(array_of_ints)/sizeof(int); idx++) { printf("%d\n", arr(array_of_ints, idx)); } return 0; } [/c]
Norbert schrieb im Beitrag #8070199: > for (unsigned long idx = 0; idx < sizeof(array_of_ints)/sizeof(int); > idx++) { "unsigned long". <tiefes Durchschnaufen> der Rückgabewert von sizeof ist size_t
-
Thread
Tipps zur Speicheranalyse gesucht
am Ende malloc hinter. [c] kiss_fft_alloc (nfft, inverse_fft, NULL, &subsize); memneeded = sizeof(struct kiss_fftr_state) + subsize + sizeof(kiss_fft_cpx) * ( nfft * 3 / 2); if (lenmem == NULL) { st = (kiss_fftr_cfg) KISS_FFT_MALLOC (memneeded); } else { if (*lenmem >= memneeded
Portpin oder irgendwas ... Anmerkung: Es ist immer blöd, wenn der Speicherbedarf der Struktur a von sizeof(Struktur b) + komische Rechnungen ("sizeof(Struktur c) * n * 3 / 2") abhängig ist.
-
Thread
Problem mit malloc() und free()
[c] char* recbuf = (char*)malloc(sizeof(RECBUFFER_SIZE)); [/c] Das macht sehr sicher nicht das, was beabsichtigt ist. Was mag "sizeof (RECBUFFER_SIZE)" liefern? Na?
das gleiche wie sizeof RECVBUFFER_SIZE ist.
-
Thread
Arduino und struct gefallen sich nicht !
Nick schrieb im Beitrag #8022601: > stattdessen sizeof verwenden > zu müssen und dann Zeichen für Zeichen in die UART zu schubsen. sizeof ist auch oft ein Ort für vertippsler. Seit C++11 kann man den "range based for loop" verwenden. Oder per
type, the result is the size of the referenced type. https://en.cppreference.com/w/cpp/language/sizeof.html
-
Thread
[C] enum Warnungen
FOO_B } foo_enum; int enum_test (foo_enum p1) { int i32; printf ("%ld %ld\n", sizeof i32, sizeof (time_t)); i32 = time (NULL); if (p1 == FOO_A) { p1 = time (NULL); } switch (p1) { case FOO_A: printf ("A\n"); break; case 42: printf
nicht long sein. Warum gibst du die Größe hier nicht einfach mit aus? > printf ("%ld %ld\n", sizeof i32, sizeof (time_t)); (übrigens: der korrekte Format-Specifier für size_t ist %zu) aber ja, der enum sollte die gleiche Größe wie int haben. Bauform B. schrieb im Beitrag #8015775: > Au weia
-
Thread
ADC-gesteuerte PWM mit LED-Anzeige
geschafft. Heute fällt das kaum noch auf [c] static char *FileMask; FileMask = (char*)malloc(sizeof(char) * STRINGSIZE);[/c] Zwischendurch sah es mal so aus: [c] int main(int argc, char **argv) BEGIN char *Env,*ph1,*ph2; String Dummy; int i; static Boolean First=TRUE;
Bauform B. schrieb im Beitrag #8014456: > sizeof(char) sizeof (char) ist per Definition *immer* 1 und kann daher weggelassen werden.
-
Thread
FTDI libMPSSE SPI-Problem
In der Funktion SPI_ReadWrite() heißt es da: [code] status = FT_Channel_Write(SPI, handle, sizeof(cmdBuffer),cmdBuffer, &noOfBytesTransferred); [/code] Richtig wäre: [code] status = FT_Channel_Write(SPI, handle, 3, cmdBuffer, &noOfBytesTransferred); [/code] sizeof(cmdBuffer) ist 4, es
CurrentXferSize); [/code] Das war wohl irgendwann mal so und da hätte dann (vielleicht) auch sizeof(cmdBuffer) (also 4) funktioniert. Und was mache ich jetzt mit dieser Erkenntnis? Es wäre sinnvoll, wenn das Problem "an der Wurzel" gepackt, d.h. von FTDI in deren Quellcode offiziell korrigiert
-
Thread
GCC Statische initialisierung.
usw. }; constexpr uint8_t ANZAHLPINS = ( sizeof(baseAddr) / sizeof(baseAddr[0]) ) ; } ---------------------------------------------------------------------------- AVRxDB_Pin.h (wird in main.cpp inkludiert) #pragma once namespace
usw. }; constexpr uint8_t ANZAHLPINS = ( sizeof(baseAddr) / sizeof(baseAddr[0]) ) ; } ---------------------------------------------------------------------------- AVRxDB_Pin.h (wird in main.cpp inkludiert) #pragma once namespace
-
Thread
NRZI Decoder Code gesucht
transitions at 1st, 4th, 5th positions) uint8_t nrzi_signal[] = {1, 0, 0, 0, 1, 1}; int length = sizeof(nrzi_signal) / sizeof(nrzi_signal[0]); uint8_t decoded_bits[32]; // Buffer for decoded data int decoded_length = nrzi_decode(nrzi_signal, length, decoded_bits); printf("NRZI Input
-
Thread
CH32V003 und Arduino
[], const bool mode) { char buffer[32]; // anpassen if (mode) { snprintf(buffer, sizeof(buffer), "%s %d.%02d %s", s1, (value/100), (value%100), s2); } else { snprintf(buffer, sizeof(buffer), "%s %d %s", s1, value, s2); } out.println(buffer); } [/c]
const bool mode) > { > char buffer[32]; // anpassen > if (mode) { > snprintf(buffer, sizeof(buffer), "%s %d.%02d %s", s1, (value/100), > (value%100), s2); > } > else { > snprintf(buffer, sizeof(buffer), "%s %d %s", s1, value, s2); > } > out.println(buffer); > } Okay
-
Thread
Fühlt sich der gcc hier veralbert?
, dass ein char pointer in ein Array nach einem increment 4 Bytes weiter zeigt. Oder ein pChar + sizeof(char) äquivalent zu pChar + 4 ist. Aber sizeof(char) trotzdem 1 ist. Und folglich muss unterschieden werden, ob der ponter in ein statisches oder in ein allokiertes array zeigt. Oder irgendwie so
wieder direkt aufeinander folgend im Speicher. Um es nochmal klipp und klar zu sagen: 1) sizeof(char) ist immer 1. 2) wenn du einen Zeiger auf ein char inkrementierst, dann wird er um 1 erhöht. 3) in einem Array liegen alle Zeichen direkt hintereinander. 4) das ist völlig unabhängig vom Alignment
-
Thread
Bizarrer Firmware crash - ATmega4808. Wie Debuggen?
coder.encode_block((unsigned char*) rxpacket.payload, tinytx_fec, datalen); interleave(tinytx_fec, sizeof (tinytx_fec)); radio.send(tinytx_fec, sizeof (tinytx_fec)); } // No FEC else { if (Cfg->InterleaverEnable) { interleave(rxpacket.payload, datalen
coder.encode_block((unsigned char*) rxpacket.payload, tinytx_fec, datalen); interleave(tinytx_fec, sizeof (tinytx_fec)); radio.send(tinytx_fec, sizeof (tinytx_fec)); } // No FEC else { if(Cfg->FecEnable) //if (Cfg->InterleaverEnable) {
-
Thread
[C] Tachometer Radius Verlauf berechnen
500, 263 }, { 600, 291 }, { 700, 314 }, { 800, 336 } }; #define SCALE_COUNT (sizeof(scale)/sizeof(scale[0])) #define DEG_OFFSET float interpolSpeedToAngel(float value) { // Begrenzen if (value <= scale[0].value) return (scale[0].angle)+DEG_OFFSET; if
-
Thread
UDP-Netzwerke(l)n mit kleinen Mikrocontrollern und WizNet W5100/W5500
udp.parsePacket(); if (packetSize > 0) { int len = udp.read(buf, min(packetSize, (int)sizeof(buf))); IPAddress remote = udp.remoteIP(); uint16_t rport = udp.remotePort(); Serial.print(F("RX ")); Serial.print(len); Serial.print(F(" bytes from "));
Enter device name for DHCP : ")); String s = readLine(); s.toCharArray(cfg.dhcpName, sizeof(cfg.dhcpName)); Serial.println(F("OK")); break; } case 'W': case 'w': saveConfigToEeprom(); Serial.println(F("Saved to EEPROM.")); break;
-
Thread
USB CDC mit CubeMX2 und HAL 2.0 auf STM32C5
cdc_acm != NULL) { ULONG n = 0; unsigned r = ux_device_class_cdc_acm_read_run(cdc_acm, buf, sizeof(buf), &n); if (r == UX_STATE_NEXT) { doSomethingWithInput(buf, n); } } [/code] Natürlich mit geeigneter Variable buf ungefähr so: [code] static UCHAR buf[64]; [/code] Noch Fragen?
-
Thread
Kleine c-routine um auf Pixelbasis Kreise und Striche zu zeichnen
+ "TUPLTYPE RGB_ALPHA\nENDHDR\n", img.width, img.height); +#endif fwrite(data, 1, sizeof(data), stdout); [/code]
-
Thread
Byte bitweise und als ganzes zugreifen als Datentyp in c
Martin S. schrieb im Beitrag #7946363: > nachher wirklich ein byte? Teste es mit "sizeof"! Martin S. schrieb im Beitrag #7946363: > struct > { > bool bit0 :1; > bool bit1 :1; > bool bit2 :1; > bool bit3 :1; > bool bit4 :1; > bool
-
Thread
ITM Meldungen ausgeben (Cortex-M3 und höher)
size if needed va_list args; va_start(args, format); vsnprintf(buffer, sizeof(buffer), format, args); va_end(args); debug_print(buffer); } } int main() { ... debug_print("Hello World! \n"); int i=42; debug_printf("value of i is
-
Thread
UART und I2C Konflikt mit STM32duino STM32G070
serial_in_command, serial_in_buff); // strcpy(serial_in_buff,""); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); chr_cnt = 0; if(strlen(serial_in_command)) { Serial.println(F("")); Serial.print(serial_in_command); Serial.println(F(" -> erkannt!!!!")); #if defined(__AVR_ATmega1284P
-
Thread
Kommunikation zwischen 2 MC
if(c!= '\n'){ // Überprüfe, ob das Zeichen nicht ein Zeilenumbruch ist if(index < sizeof(buffer)-1){ buffer[index++] = c; } } else{ buffer[index] = '\0'; // Beende den String mit einem Null-Byte index = 0; // Setze den Index zurück für
-
Thread
TJA1020 mit ESP32 betreiben
lin_parser_t *parser, uint8_t byte) { // Byte in Buffer hinzufügen if (parser->buffer_len >= sizeof(parser->buffer)) { // Buffer voll - verwerfe älteste Bytes (sliding window) memmove(parser->buffer, parser->buffer + 1, sizeof(parser->buffer) - 1); parser->buffer_len--;
-
Thread
Externes 8zoll zu usb Floppy Laufwerk (z.B. Shugart SA85? Oder komp.)
Wenn man mit dem Source Code ein wenig experimentiert und ein paar Dinge passend macht (z.B. "sizeof(int)") kann man die Dumps von den 8-Zoll Disketten korrekt auswerten, also z.B. alle Dateien inklusive Verzeichnisstruktur extrahieren. Als Nebenbemerkung: Das Tektronix 8560 Systems von 1983/84
-
Thread
AVR: ENC28J60 Ethernet Multicast
ENC_REG_ERDPTH, HI8(enc_next_packet_ptr) ); // read enc rx packet header enc_read_buf( rxheader, sizeof(rxheader) ); enc_next_packet_ptr = rxheader[0]; enc_next_packet_ptr |= ((unsigned)(rxheader[1])) << 8; len = rxheader[2]; len
-
Thread
Mein neues C-Buch braucht ehrliche Kritik
ich mal den tcc geprüft, der übersetzt auch einige Grundprogramme gar nicht (Trigraphen z.B. oder sizeof Ints) - da fragt man sich warum eigentlich nicht.)
-
Thread
Arduino Uno R4: Besonderheiten und Abhilfen
auf AVR > als ARM 32 bit hat? Wenn du der Referenz nicht vertrauen möchtest, könntest du auch sizeof() befragen, oder die limits.h oder limits nutzen sprintf und seine Brüder schmecken dir ncht?
-
Thread
I2C Kommunikation zum DS3231 in Espressif-IDF 5.5 zickt plötzlich rum
: [code] // I2C für DS3231 initialisieren und Handle erzeugen i2c_dev_t dev; memset(&dev, 0, sizeof(i2c_dev_t)); ESP_ERROR_CHECK(ds3231_init_desc(&dev, I2C_MASTER_NUM, I2C_MASTER_SDA_IO, I2C_MASTER_SCL_IO)); // Alarmzeit stellen gpio_set_level(DS3231_VCC_PIN, 1); vTaskDelay(pdMS_TO_TICKS(100
-
Thread
Schulnotenbewertung eines Arduino-Programms
unendlich oft getestet wurde. Und z.B. RAII implementiert. Soweit ich mich erinnern kann, sagt sizeof 6 Byte zu String
-
Thread
Esp32 und PCM510x Mute Problem
sample[0] = sample[1] = (int16_t)s; size_t bytes_written; i2s_write(I2S_NUM_0, sample, sizeof(sample), &bytes_written, portMAX_DELAY); phase += 2.0 * M_PI * 440.0 / SAMPLE_RATE; if (phase > 2.0 * M_PI) phase -= 2.0 * M_PI; } [/code]
-
Thread
LED Matrix Ansteuerung mit STM32F4 ohne CPU Last
Helligkeitsstufen exponentiell ansteigende RAM Verbrauch. Für 9 Bit PWM sind das so pro Zeile 2^9 * sizeof(uint16_t) = 1KiB. Außerdem müssen die Ausgänge alle Zeilen und Spalten jeweils auf einem gemeinsamen Port liegen, was das ganze mit zwei DMA Kanälen auf eine 16x16 Matrix begrenzt. Werden auf dem
-
Artikel
Gleitkommazahlen
Ergebnissen). Ab Version 10 kann avr-gcc 64bit double. Für portablen Code kann man das #define __SIZEOF_DOUBLE__ verwenden, um die Anzahl Bits zu prüfen. Siehe dazu die Release Notes des GCC. Zusammenfassung. Gleitkommazahlen sind kein Allheilmittel, im Gegenteil. Sie sollten nur mit Bedacht eingesetzt