-
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
Datenzuweisung an Struct
in ein u_int casten (zum zählen, sonst zählt er dabei bei (&STRUKTUR)+i das i als vielfache von sizeof(STRUKTUR) ) und dann diesen neuen u_int als charpointer casten um auf einzelne Bytes schreiben zu können //löschen des structs for(unsigned int i =0;i<sizeof(STRUKTUR);i++) { *(unsigned
musst, kannst du alternativ [C] AssignTime( &a, 0, 0, 0 ); [/C] oder [C] memset( &a, 0, sizeof( a ) ); [/C] benutzen.
-
Thread
Präprozessor Kontrolle der Übergabe
erlaubt sind. Hier mal ein aus dem Internet geklautes Beispiel: [C] #define ct_assert(e) ((void)sizeof(char[1 - 2*!(e)])) #define einMakro(einWert) einWert*2 int main() { ct_assert(einMakro(5) == 10); // Ok ct_assert(einMakro(5) == 11); // Fehler } [/C] Da kommt ein Fehler vom Compiler
nutze folgendes um die größe eines Arrays (empfaengermaske) zu überprüfen: [c]typedef int dummy[sizeof(empfaengermaske) == KANAL_ENDE ? 1 : -1];[/c]
-
Thread
Erste Schritte mit Renesas M16C und GCC
schon eine Möglichkeit für eine Ausgabe? Wenn ja int main() { printf( "int: %d\n", sizeof( int ) ); printf( "long: %d\n", sizeof( long ) ); } Oder was du auch immer anstelle von printf nehmen kannst. Zur Not müsste auch ein Port gehen, an dem dir das Bitmuster (die Bytezahlen sind ja nicht gross) die Anzahl Bytes verrät. Wichtig ist eigentlich nur: sizeof verrät dir die Größe. > Wo finde ich spezielle Befehle bzw. Erklärungen? z.b.: > #define rmad1 (*(volatile union rmad1_def *) (0x0014)) Da du es hier mit einem µC zu tun hat, stehen die Chancen
-
Thread
gcc komischer fehler: sbrk() Gesperrt
m_file._bf._base = m_outbuf; // the buffer (at least 1 byte, if !NULL) m_file._bf._size = sizeof(m_outbuf); // the buffer (at least 1 byte, if !NULL) m_file._lbfsize = -sizeof(m_outbuf); // 0 or -_bf._size, for inline putc m_file._read = NULL; // no read m_file._write = charout
aber dann müsste man eben für den vorherigen Ausdruck die umständlich zu lesende Form [c] i = sizeof("Foo!") - 1; [/c] wählen.
-
Thread
Client/Server verbindung überprüfen
AF_INET, SOCK_STREAM, 0); opt = 1; setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); server.sin_family = AF_INET; server.sin_port = htons(src_port); server.sin_addr.s_addr = inet_addr(src_addr); bind(server_sock, (struct sockaddr*) &server, sizeof(server)); listen(server_sock, 5); len = (int) sizeof(client); accept_sock = accept(server_sock, (struct sockaddr*) &client, &len); recv_len = recv(accept_sock, buf, 1024, 0); for(;;) { // do something // wie kann ich die Verbindung überprüfen
-
Thread
C Struct arbeiten
offsetof(x, speedL), offsetof(x, encR), offsetof(x, encL) }; for (int i = 0; i < sizeof(at)/sizeof(at[0]); ++i) { int element = ((const int*)&x)[at[i]/sizeof(int)]; printf("%d\n", element); } [/code]
-
Thread
Warum funktioniert dieser code nicht [C]
size = (int) sprintf(buffer, "%d", inputvalue); outpointer = (int *) malloc((size + 1) * sizeof(int)); for (i=0;i<size;i++) outpointer[i] = atoi(buffer[i]); return outpointer; } int main() { int testvalue = 8392, *pointer , size = 4, i; pointer = splitToDigits
Da M. schrieb im Beitrag #6368767: > outpointer = (int *) malloc((size + 1) * sizeof(int)); das +1 brauchst du nicht. Üblicherweise macht man so eine Zerlegung übrigens über Ganzzahldivision und Modulo-Operator. Die Rückgabe des Pointers ist auch keine gute Lösung, weil du außerhalb
-
Thread
log2() mit Preprocessor
)))[/c] Der Cast ist überflüssig; __builtin_clz nimmt nen int: [c]#define BITSIZE(n) (8 * sizeof (int) - __builtin_clz ((n)))[/c] oder eben [c]#define BITSIZE(n) (8 * sizeof (long) - __builtin_clzl ((long)(n)))[/c]
auch die 32 falsch. Korrekt wäre wohl: [c] #include <limits.h> #define BITSIZE(n) (CHAR_BIT * sizeof(unsigned) - __builtin_clz((n))) [/c]
-
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
länge eines arrays
ich habs jetzt so gemacht: [c] sizeof(song)/sizeof(song[0]) [/c]
Könntest auch ein define basteln #define arr_size(x) ( sizeof(x) / sizeof(x[0]) )
-
Thread
Danneggers Entprellroutine im AVR benutzen
Prellzeit in Millisekunden byte buttonPins[]={2,3,4,5,6,7,8}; // Arduino Pins #define NUMBUTTONS sizeof(buttonPins) byte buttonState[NUMBUTTONS]; void setup() { Serial.begin(9600); for (int i=0;i<NUMBUTTONS;i++) pinMode(buttonPins[i],INPUTMODE); } void loop() { for (int i=0;i<NUMBUTTONS
Zeit für einen SHORTCLICK byte buttonPins[]={2,3,4,5,6,7,8}; // Arduino Pins #define NUMBUTTONS sizeof(buttonPins) byte buttonState[NUMBUTTONS]; // Aktueller Status des Buttons HIGH/LOW enum {NONE, SHORTCLICK, LONGCLICK}; byte buttonResult[NUMBUTTONS]; // Aktueller Klickstatus der Buttons NONE/
-
Thread
Größe eines Array-Abschnittes ermitteln
LED5,110,LED6,110,LED7,110,LED8,110,LED1,110,LED2,110,LED3,110,LED4,110 }; größeAbschnitt = sizeof(AbschnittEnde-AbschnittAnfang); <-funktioniert nicht!
LED5,110,LED6,110,LED7,110,LED8,110,LED1,110,LED2,110,LED3,110,LED4,110 }; #deine ARRAY_SIZE(x) ( sizeof(x) / sizeof(*x) ) int main() { ... showLeds( ledAnimSeqProlog, ARRAY_SIZE( ledAnimSeqProlog ) / 2 ); for( i = 0; i < 20; ++i ) showLeds( ledAnimSeqBody, ARRAY_SIZE( ledAnimSeqBody
-
Thread
Bascom ist gut
eeprom halten sich in Grenzen: [c] void loadConfig() { eeprom_read_block(&cfg,&config_ee,sizeof(Config_t)); } void saveConfig() { eeprom_write_block(&cfg,&config_ee,sizeof(Config_t)); } [/c] Ähnlich kompakt sind die Funktionen zum senden und empfangen der Config via serielle Schnittstelle
uint8_t p3; }eeprom_data; int main( void ) { eeprom_read( &eeprom_data, EE_ADDR, sizeof(eeprom_data) ); eeprom_data.p0++; eeprom_write( EE_ADDR, &eeprom_data, sizeof(eeprom_data) ); for(;;){ } } [/c] Peter
-
Thread
Nach den Reset oder Stromausfall verliert EEPROM die Daten
() { // read the eeprom data eeprom_read_block(&m_DataHeader, (void*)EEPROM_DATA_HEADER_POS, sizeof(EEPROM_DATA_HEADER)); //--- check if version is correct, if not write a default setting if ( m_DataHeader.version == DATA_VERSION ) { return; } //--- version is not valid, build
main_SaveEEProm() { eeprom_busy_wait(); eeprom_write_block(&m_DataHeader, (void*)EEPROM_DATA_HEADER_POS, sizeof(EEPROM_DATA_HEADER)); } VOID main_SaveMotorData(BYTE byteNodeID, UINT16 cmdID, UINT16 statusID) { //--- clear the old status register can_WriteStatus(m_DataHeader.node_id, 0, 0, 0);
-
Thread
Bit-Felder per structs verschachteln
bit-Feldern lösen. Das folgende Beispiel, auf einem STM32F070 mit Atollic Studio erzeugt laut sizeof eine Größe von 2 Byte. Kann ich dem Compiler sagen, dass es das trotzdem in einem Byte packen darf/soll? [c] typedef struct{ uint8_t MSB : 6; } s_component; typedef struct { uint8_t
auf Anhieb ob für dieses Problem relevant sein könnte, aber ich habe vor einigen Wochen C-Code für sizeof() und offsetof() für Bitfelder (insb. in structs) entwickelt (dabei heisst es ja man kann die C-Operatoren sizeof und offsetof nicht bei Bitfeldern benutzen, was ja auch stimmt; meine Lösung ist ein
-
Thread
Daten empfangen und senden mit DMA
USB_DMA_DESCRIPTOR DDListEp5[DD_COUNT] int Usb_Dma_Init() { int error, n; memset(DmaUdcaList, 0, sizeof(DmaUdcaList)); memset(DDListEp4, 0, sizeof(DDListEp4)); memset(DDListEp5, 0, sizeof(DDListEp5)); memset(DmaTransmitbuffer, 0, sizeof(DmaTransmitbuffer)); memset(DmaReceivebuffer, 0, sizeof
DDListEp5[n].max_packet_size = MAX_PACKET_SIZE << 5; DDListEp5[n].dma_buffer_length = (sizeof(DmaTransmitbuffer)) / DD_COUNT; DDListEp5[n].dma_buffer_addr = &(DmaTransmitbuffer[n]); DDListEp5[n].status = 0; } return error; #define USB_DD_SIZE sizeof
-
Thread
Sendefunktion
fülle Rest mit Nullen auf } } HAL_UART_Transmit(&UART1_HANDLER, string, sizeof(string), 1000); // Drucke dann alle Zeichen im string aus [/c]
index] = '-'; } else { index++; } HAL_UART_Transmit(&UART1_HANDLER, string + index, sizeof(11 - index), 1000); }[/c]
-
Thread
DCB Einstellungen
mark,space Wie initialisierst Du die Struktur vor dieser Zeile hier? > PortDCB.DCBlength = sizeof (DCB);
> > > Wie initialisierst Du die Struktur vor dieser Zeile hier? > >> PortDCB.DCBlength = sizeof (DCB); Gar nicht. Wie soll das denn gehen?
-
Thread
Arduino - 2 dimensionales Array an Funktion übergeben
{0, 1, 1, 1, 0}}; void tuWasMitFeld(const DatenFeld & feld) { const size_t dim1count = sizeof(feld)/sizeof(feld[0]); const size_t dim2count = sizeof(feld[0])/sizeof(feld[0][0]); for (int i=0; i<dim2count; i++) { for (int ii=0; ii<dim1count; ii++) { if (feld[ii
-
Thread
Struct hat unerwartete Größe
Bei mir auch 2. Zeige doch bitte mal auf welche Weise Du sizeof(tmc222Diag_t) ermittelst und ausgibst. Am besten wäre natürlich ein minimales, compilierbares und ausführbares Codebeispiel.
char unexpectedBehaviour : 1; } __attribute__((packed)) tmc222Diag_t; static_assert(sizeof(tmc222Diag_t)==5,"miscalulated size"); [/c] Er hat also den uint16_t-Teil nicht an der tatsächlichen Bitbreite, sondern an 16 Bit ausgerichtet. Die 8 Bit danach wieder an 8 Bit.
-
Thread
DTMF decoder
32649, // 1336 Hz 26169, // 1477 Hz 18629 // 1633 Hz }; const int CoeffCnt = sizeof(CoeffArr)/sizeof(*CoeffArr); for(int f=650; f<1700; f+=10) { const uint8_t Cnt = 160; // 20ms lange Blöcke const short fSample = 8000; int16_t q[Cnt]; for(int i=0; i<Cnt
fSample*256/2/1336, fSample*256/2/1477, fSample*256/2/1633 }; const uint8_t StepCnt = sizeof(StepArr)/sizeof(*StepArr); for(uint8_t iCoeff=0; iCoeff<StepCnt; iCoeff++) { short Step = pgm_read_word(&StepArr[iCoeff]); short s = 0; short c = 0; { // "Sin-Summe
-
Thread
WinAVR sizeof PROGMEM struct mit char[] Element
des Strings in size: PROGMEM struct lenTest myTest = { 0, sizeof(myTest), "text" }; Mir ist klar, der Precompiler kann das nicht. Gruß Ingo
Klar geht das so nicht. Was geht ist: PROGMEM struct lenTest myTest = { 0, sizeof(myTest)+sizeof("text"), "text" }; es ist aber auch nicht schön, den Text zweimal aufzuführen. Gruß Ingo
-
Thread
malloc, string größer als reservierter Speicherplatz für string
ListElem*root; // root = (struct ListElem*) malloc (sizeof(struct ListElem)); // Erzeugung eines neuen Elements und Anhängen an Root(1.4) platz = (char*)malloc(strlen("Michael")+1); strcpy(platz, "Michaelaaaaaaa"); [/c]
struct ListElem*root; root = (struct ListElem*) malloc (sizeof(struct ListElem)); [/c] schreibt man übrigends besser so: [c] struct ListElem*root; root = malloc (sizeof(*root)); [/c] Warum? Weniger Stellen,
-
Thread
Probleme mit Übergabe eines Arrays
mit einem #define in dem die Längenangabe steht, oder mit einem #define, welches die Länge mittels sizeof bestimmt, würde ich momentan erst mal als nicht ganz so wichtig abtun. OK, mit dem 0 Pointer im Array spart man sich Funktionsargumente.
[c] const char * const cmd_list[] = { "TYPE?", "ID?", "MOMVALUE" }; #define NR_OF_COMMANDS (sizeof(cmd_list) / sizeof(cmd_list[0])) [/c] in der ich mich um das #define überhaupt nicht mehr kümmern muss, wenn ich neue Strings hinzufüge. Aber darüber will ich mich jetzt nicht streiten. Man kann
-
Thread
20 Variablen unterschiedlichen Typs seriell einlesen
(unsigned long*)buffer; und die Schleife da oben, schreibst Du besser so: for(i=0; i < sizeof( unsigned long); i++) buffer[i]=x.u8[i]; (Also: Anstatt der fest kodierten 2 oder 4 einen sizeof Ausdruck benutzen. Dann brauchst Du Dir nicht den Kopf zerbrechen, ueber wieviele Bytes
kannst Du auch ersetzen durch: *(unsigned long*)buffer = *(unsigned long *)ptr; buffer[ sizeof( unsigned long) ] = 0; uart_puts( buffer ); dann erledigt Dir der Compiler die ganze Kopiererei, ganz analog zum Code im empfangen. Generell: Wenn man solche Uebertragungsfunktionen schreibt
-
Thread
Umwandlung eines Strings (hex) in Long Long int
0 for( iByte=0; iByte<sizeof(*pll_dest); ++iByte ) { if( p_aktuell>p_src ) { // es können noch mindestens 2 Zeichen benutzt werden: *p_dest = hexdigit2value( *p_aktuell ) | hexdigit2value( p_aktuell[
; uint8_t parse_string( uint8_t *s ) { uint16_t val; uint8_t i; for( i = 0; i < sizeof( dds_data ); i++ ){ // convert up to 12 digits val = get_hex_byte( s ); if( val & 0x8000 ) // no valid hex digit break; dds_data[i] = val; s +
-
Thread
Arduino Rs232
strcpy(serial_in_command, serial_in_buff); chr_cnt = 0; memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); } } // if (Serial.available() > 0) if(strlen(serial_in_command)) { // fuer dich int16_t int_var = atoi(serial_in_command); /* Serial.println
serial_in_command, "hellp") ) */ *serial_in_command=0; // oder // memset(&serial_in_command[0], 0, sizeof(serial_in_command)); // oder // memset(serial_in_command, 0, sizeof(serial_in_command)); } // if(strlen(serial_in_command)) [/c]
-
Thread
Länge eines Strings (aus Struct) bestimmen?
zugewiesen. Nun würde mich die Länge des Strings Bezeichnung interessieren. Das meinte ich mit itoa (sizeof(*(Param).Bezeichnung)), buffer, 10); ermitteln zu können. Das liefert mir aber nur die Fehlermeldung "request for member `Menu_Name' in something not a structure or union" :=( Wie komme ich an
sizeof liefert doch nicht die Länge eines Strings, sondern die Größe des Feldes, in dem z.B. der String steht. Der String ist immer kürzer oder gleich dem reservierten Speicherplatz. sizeof und strlen
-
Thread
EEPROM Verständnis
value); } eeprom_read_block (PWM_Values_OFF, 0x00, sizeof(PWM_Values_OFF)); eeprom_read_block (PWM_Values_STD, 0x12, sizeof(PWM_Values_STD)); eeprom_read_block (PWM_Values_AKT, 0x24, sizeof(PWM_Values_AKT)); SendToLamps
-
Thread
float via UART am ATMega16 empfangen (in C)
dazuschreiben wie die bytes uebertragen werden: .... union{ float r; uint8_t v[sizeof(float)]; } u; unsigned char send_command[7]; .... u.r = 123.456; //hier die float Variable speichern //... protocol implementieren ... send_command[0]=0xFE; //STX send_command[1]=
auf eine Float-Variable zeigen laesst und dann inkrementiert... werden die Speicherstellen dann um sizeof(unsigned char) oder um sizeof(float) inkrementiert, das muss man ja manuell machen; bei der Union ist das automatisch der Fall, dass die Variablen auf die gleiche Speicherzelle zeigen und sie sind
-
Thread
Pointer & AVRGCC
Probier's mal mit t += *(dat + 2000 * sizeof(unsigned int))
richtig. Also den 1000. Eintrag von dat. Die Adresse liegt in Deinem Fall bei dat+2000 (dat+1000*sizeof(unsigned int)). Ich gehe mal davon aus, das sizeof(int) == 2 ist. Fazit: Das Mischen von Pointerarithmetik und Arrayzugriffen macht immer wieder viel Freude. Dazu dann noch Adressbereiche am
-
Thread
float im EEPROM
Ich habe: float epromwert EEPROM; float wert=0; ... eeprom_read_block(&wert, &epromwert, sizeof(float)); Wenn ich wert mit dtostrf (wert, 6, 3, text); konvertiere, bekomme ich bei einem leeren EEPROM (FF) "NAN". Ok, so weit ja auch brauchbar. Jetzt dachte ich, ich prüfe mit isnan
Hi beim AVRGCC ist sizeof(double) == sizeof(float) Double ist (im Prinzip) nur eine typedef auf ein float. Matthias
-
Thread
Sipdial per ESP8266 an Fritzbox
Udp.parsePacket(); if (packetSize>0) { caSipIn[0]=0; packetSize=Udp.read(caSipIn, sizeof(caSipIn)); if (packetSize>0) { caSipIn[packetSize]=0; #ifdef DEBUGLOG IPAddress remoteIp = Udp.remoteIP(); Serial.printf("\r\n----- read %i bytes from:
SendUdp(); } void Sip::Ack(const char *p) { char ca[32]; bool b = ParseParameter(ca, (int)sizeof(ca), "To: <", p, '>'); if (!b) return; pbuf[0] = 0; AddSipLine("ACK %s SIP/2.0", ca); AddCopySipLine(p, "Call-ID: "); int cseq = GrepInteger(p, "\nCSeq: "); AddSipLine("CSeq
-
Thread
Dynamisch Speicher reservieren (Array)
("sizeof(uint16_t)") oder reicht es, mit malloc die Anzahl der Elemente zu reservieren? Sprich alloziiert malloc "automatisch" (dadurch das tempArray bereits uint16_t ist) die korrekte Größe von 10 Byte und
vom Gleichheitszeichen ein Pointer auf uint16_t steht. Du musst also wie gezeigt Anzahl Elemente * sizeof(uint16_t) rechnen um die richtige Größe zu kriegen.
-
Thread
html in c array
w"); if(!output) { fclose(html); return -1; } char read; fread(&read, sizeof(char), 1, html); fprintf(output, "char array[] = {%d", read); fread(&read, sizeof(char), 1, html); while(!feof(html)) { fprintf(output, ", %d", read); fread(&read, sizeof(char
-
Thread
uint16_t Division compilerabhängig? HardFault bei bestimmtem Compiler
Hallo, wenn Du den Pointer hochzählst sollte das mit der "sizeof" des Datentyps sein. Es kommt auch drauf an wie die Daten hintereinander liegen, ist eine 32Bit Architektur aber Du hast ein Datum von 16Bit, ein 16Bit-Wert kann in einer Zelle liegen, aber auch
Seastian schrieb im Beitrag #4655160: > wenn Du den Pointer hochzählst sollte das mit der "sizeof" des Datentyps > sein. wie meinst du das?
-
Thread
Pointer bei AtMega128
der Pointer anzeigen lassen: volatile unsigned char (*funktion)(char daten); volatile int k = sizeof(PGM_P); volatile int l = sizeof(char *); volatile int m = sizeof(funktion); Die Größe ergibt immer 2 Bytes. Müssten nicht der Funktionspointer under PROGMEM Pointer 4 Byte groß sein? Ich denke
-
Thread
PI mit 8-Bit Controller auf viele DEZIMALSTELLEN genau berechnen
n_digits = 0; putchar ('3'); putchar ('.'); putchar ('\n'); size_t n_bytes0 = sizeof (BYTES) / sizeof (*BYTES); for (size_t n_bytes = n_bytes0; n_bytes != 0; ) { n_bytes = put_digit (BYTES, n_bytes, 10); if (++n_line == 40) { n_line
putchar ('\n'); return n_digits; } int main (void) { printf ("Hex-Digits = %u\n", 2 * sizeof (BYTES) / sizeof (*BYTES)); PERF_START_CALL (1); size_t n_digits = out_digits(); PERF_DUMP_ALL; printf ("Dec-Digits = %u\n", n_digits); return 0; }[/c] I.W. eine Schleife
-
Thread
goto verpönt - was dann nehmen?
gZ6_g, Z7_g }; if (z_measurement_g) { motion *priorRankedAxis = findPriorRankedAxis(allAxes,sizeof(allAxes)); if (priorRankedAxis != NULL){ stepper_handle(priorRankedAxis); } } else{ for (int i = 0; i < sizeof(allAxes); i++) { stepper_handle(&allAxes[i]); } } [/c]
Zeigern: [c] motion *allAxes[]{ &Z1_g, &Z2_g, &Z3_g, &Z4_g, &Z5_g, &Z6_g, &Z7_g }; int axesCount = sizeof(allAxes) / sizeof(*allAxes); if (z_measurement_g) { motion *priorRankedAxis = findPriorRankedAxis(allAxes, axesCount); if (priorRankedAxis != NULL) { stepper_handle(priorRankedAxis);
-
Thread
Über Funktionen "loopen" (Arduino IDE)
{ int zeit = 30; // Iteriere durch ganzes Array, d.h. von 0 bis 3 for (size_t j = 0; j < (sizeof(ledPwm)/sizeof(ledPwm[0])); ++j) { ledPwm [j].led(4096,0,0); delay(50); } }[/c]
potentielle Fehlerquelle, ins besondere wenn man was ändern muss. [c] const size_t anzahlLED = sizeof(led_lut)/sizeof(led_lut[0]); [/c] So könntest du die "<= 17" durch "< anzahlLED" ersetzen, und bräuchtest dich nicht zu kümmern, wenn eine LED hinzugefügt oder weg genommen wird. Was allerdings
-
Thread
constexpr Argument-Wrapper
Argumente diesen Typs zu übergeben? Da kann man doch einfach den Typ selbst nutzen? So wie wenn ich sizeof verwende. [c]size_t get_size (int i) { return sizeof (i); }[/c] Hier brauch ich gar kein Objekt und kein Argument, da die Info im Typ selber steckt: [c]size_t get_size (void) { return sizeof (int); }[/c] Irgendwie versteh ich die ganze Denke nicht, und da werden wohl Probleme gelöst, die durch ein Übermaß an Sprachmitteln erste entstehen, und durch noch kompliziertere — Verzeihung,
-
Thread
Float als 4 Byte im EEprom speichern
nichts mit i2c. float eeFooFloat EEMEM; float f; eeprom_write_block (eeFooFloat ,&f, sizeof(f));
Adressierung oder so..... Kann man: uin8t_t *p = (uint8_t *)&zahl; und dann p[0], p[1], ... p[sizeof(zahl)-1] verwenden. Unions sind ein Weg, das ist ein anderer.
-
Thread
strtok geht nicht beim Atmega168p
SMS receivers uint8_t volatile tel_len; eeprom_read_block((void *)&tel_len, (uint8_t *)0 + sizeof(SIM_PIN), sizeof(tel_len)); char volatile TeleNumbers[45] = {0}; // max of 3 telephone numbers if (tel_len <= sizeof(TeleNumbers)) eeprom_read_block((void *)TeleNumbers, (uint8_t *)0 + sizeof(SIM_PIN) + sizeof(tel_len), tel_len);[/c] Debuggen tu ich mit dem JTAGICE mkII und wenn ich mir dann Online im IRAM das Array TeleNumbers ansehe passt alles: 2B 34 ..... 2C 2B 34 ... 00 Nun parse
-
Thread
eeprom_read_block() liefert 'keine' Daten beim ersten lesen
werden alle DAten korrekt gelesen. Code: [c] uint8_t data[8]; eeprom_read_block(&data, 0x00, sizeof(data)); [/c] ich verwende: AVR Studio: 4.14 AVR Libc 1.6.2 Kennt jemand das Problem?
yeyo wrote: > Code: > [c] > uint8_t data[8]; > eeprom_read_block(&data, 0x00, sizeof(data)); > [/c] Probier mal: [c] uint8_t data[8]; while(!eeprom_is_ready()){} //Warten bis EEPROM bereit eeprom_read_block(&data, 0x00, sizeof(data)); [/c] Wahrscheinlich willst du was aus
-
Thread
C, Mingw, UDP-Pakete, Startschwierigkeiten
= INADDR_ANY; if(setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq)) == SOCKET_ERROR) printf("setsockopt() error: %d\n", WSAGetLastError()); // try SYNC_LENGTH_SEC seconds to get any answer time_t timetotry = time(NULL)+SYNC_LENGTH_SEC;
fflush(stdout); // now socket is synced while(1){ // endless memset(buf, 0, sizeof(buf)); if(recvfrom(sock, buf, sizeof(buf), 0, NULL, NULL) == SOCKET_ERROR) printf("recvfrom() error\n"); if((buf[0] == 'M') || (buf[0] == 'N')) {// only M-SEARCH and
-
Thread
Probleme mit Funktion "itoa"
buffer[BUFLEN]; // buffer anlegen [..] printf("buffer @%p, size %d, content %s\n", buffer, sizeof(buffer), buffer); [..] Sowas schon mal ausprobiert? BTW: RTFK&R ;)
Hallo! Stimmt dieser Ausdruck wirklich? printf("buffer @%p, size %d, content %s\n", buffer, sizeof(buffer), buffer); Jetzt komme ich total durcheinander. (verwendeter Compiler CodeVision AVR)
-
Thread
gcc auf dem pc ausführen
von C etwas anderes als das was du glaubst. https://stackoverflow.com/questions/11868211/does-sizeof-return-the-number-of-bytes-or-the-number-of-octets-of-a-type-in-c
Doch, auch sonst, bis auf wenige Ausnahmen. Wenn sie links von einem Zuweisungsoperator oder in sizeof stehen, dann passiert das nicht.