-
Thread
WS2812 mit Nucleo und Lib
updateRateTimer; void blankBuffer(pixelInfo *Ptr) { memset( (void *)Ptr, 0, chainLen*sizeof(pixelInfo) ); } void setPixel(unsigned int index, pixelInfo *colourToUse) { if (index < chainLen) { pixelData[index].R = colourToUse->R; pixelData[index].G = colourToUse->G;
-
Thread
Kontinuierlich in eine Datei schreiben
baer schrieb im Beitrag #4688962: > char * data = "test" > > fwrite( data, sizeof(data), 1, pFile ); Was gibt hier der sizeof-Operator zurück?
Vor dem snprintf Buffer Initialisieren mit memset(buffer, 0, sizeof(buffer)) Grüsse, René
-
Thread
Anfänger C / C++ Pointerarithmetik
acGUI_Fontff_0020 } /* code 0020 */ [/c] das hier schreiben: [c] { 4, 4, 2, acGUI_Fontff_0020, sizeof acGUI_Fontff_0020 } /* code 0020 */ [/c] Der sizeof-Operator liefert Dir die gewünschte Größe.
-
Thread
C String in uint32 und zurück?
os_printf("spi_flash_erase_sector: %d\n", i); int o = spi_flash_write(0x8c000, (uint32*)ssid, sizeof(ssid)); os_printf("spi_flash_write: %d\n", o); int p = spi_flash_read(0x8c000, &toread, sizeof(toread)); os_memcpy(ssid2, &toread,sizeof(&toread)); os_printf("Read from flash: %s\
dafür sorgen, das die länge durch 4 Teilbar ist. [c] spi_flash_write(0x8c000, (uint32*)ssid, sizeof(ssid)); spi_flash_read(0x8c000, (uint32*)ssid, sizeof(ssid)); [/c]
-
Thread
ATSAMD21G18 und Atmel Studio 7
/c] [c] uint8_t string[] = "Hallo\n"; usart_write_buffer_wait(&usart_instance,string, sizeof(string)); [/c]
; uint8_t string[] = "Hello World\r\n"; usart_write_buffer_wait(&usart_instance, string, sizeof(string)); }[/c] ...trotzdem funktioniert es nicht. Keine Ausgabe an der seriellen Schnittstelle :( Hardwaremässig ist aber alles ok, mit dem Arduino sketch kann ich an den Pins senden und empfangen
-
Thread
BME280 per OneWire mit DS28E17
reset(); _bme280_onewire->select(onewire_address); _bme280_onewire->write_bytes(packet, sizeof(packet), 1); // Write the packet and hold the bus while(_bme280_onewire->read_bit() == true) { // Wait for not busy delay(1); } _bme280_onewire->read();
-
Thread
PIC24f32KA304 EEPROM lesen und schreiben
offset = __builtin_tbloffset(&eeData); // Initizlize lower word of address offset += index * sizeof(int); return __builtin_tblrdl(offset); // read EEPROM data } int EEP_Write(int index, int data){ unsigned int offset; if(index > 0xff) return -1; if(index < 0)
offset = __builtin_tbloffset(&eeData); // Initizlize lower word of address offset += index * sizeof(int); __builtin_tblwtl(offset, data); asm volatile ("disi #5"); // Disable Interrupts For 5 Instructions __builtin_write_NVM(); // Issue Unlock Sequence and Start Erase Cycle
-
Thread
STM32F4 GCC Linker section nur global?
> ram /* _siccmdata is used in startup code to init vars in ccm */ _siccmdata = __etext + SIZEOF (.data); .ccmdata : AT ( _siccmdata ) { _sccmdata = .; *(.ccmdata*) . = ALIGN(4); /* All data end */ _eccmdata = .; } > ccm _usedromend = _siccmdata + SIZEOF (.
stack_dummy section */ __StackTop = ORIGIN(ccm ) + LENGTH(ccm ); /*__StackLimit = __StackTop - SIZEOF(.co_stack);*/ PROVIDE(__Stack = __StackTop); /* Check if data + heap + stack exceeds ram limit */ /*ASSERT(__StackLimit >= __HeapLimit, "region ram overflowed with stack")*/ ASSERT
-
Thread
Double channel RAM speed
p; cpu_set_t mask; CPU_ZERO(&mask); CPU_SET(0,&mask); sched_setaffinity(0, sizeof(cpu_set_t), &mask); nice(-10); p = aligned_alloc(64*KIB, GIB); assert(p); memset(p, 0, GIB); return p; }[/C] Dann erst finden die Tests statt. Es werden dann zehn mal hintereinander
-
Thread
Teilstring aus String auswählen und in neuen string kopieren, AVR
denn "svn" und "src" existieren, dann benötigst du den Abstand als ein abgerundetes Vielfaches von sizeof(uint16_t)? Dein Nachfolgender Code sieht eher so aus, als ob du den Abstand in char benötigst. > branchStr[50] = Das ist das 51. Zeichen. Du hast aber nur 50 Zeichen definiert. > return
reinsoll, zusammen mit einer expliziten Information, wie lang der übergebene Speicherbereich ist. Sizeof funktioniert nicht mit arrays, die an FUnktionen übergeben werden, daher die explizite Längenangabe. Vorteil: Wenn mehrere Stellen die Funktion aufrufen, kriegen sie alle ihr Ergebnis korrekt.
-
Thread
[C] Arrays zusammenführen, oder: Array als Funktionsrückgabe
/w/c/language/sizeof Gruß Herby
(sizeof eines Arrays mit variabler Größe) Herby
-
Thread
Serielle daten vom Raspberry lesen
/printf("Open successfully\n"); char * msg = argv[1]; //funktioniert!!! iOut = write(fd, msg, sizeof(msg)); //geht so leider nicht!!! read(rd, reply, 10); printf("%s\n", reply); close(fd); } ... [/code] ich bin für jeden Tipp dankbar ;) wie schon oben erwähnt, arbeite ich mit einem
-
Thread
Portierung eines Mikrocontrollers
z.B. "int" alles mögliche sein mit mindestens 16 bit. Das wird speziell dann "lustig", wenn statt sizeof überall magic numbers verteilt wurden. - wurden Bitfields wirklich nur benutzt, um über Membernames zuzugreifen? Die sind sonst nicht portabel. - Performance: Auf 8bit-Controllern sind logischerweise
-
Thread
GCC - Länge eines Const Array in ein anderes bringen
1000.0} }; //Länge des dynamischen Array herausfinden const unsigned elements_anzeigeelemente = sizeof(anzeigeelemente)/sizeof(struct dispwert); [/c]
unterstuetzt) 0x01, //bNumDescriptors = 1 0x22, //bDescriptorType = 0x22, //sizeof(rep_desc), low(sizeof(rep_desc)),high(sizeof(rep_desc)), /*** EP1 Descriptor ***/ 0x07, //bLength = 0x07, Groesse Deskriptor in Byte 0x05, //bDescriptorType = 0x05,
-
Thread
C++ alle Daten mit recv() empfangen?
> > /* Empfangende Daten auslesen */ > rc = recv(this->_s, &recvBuf[readSize], sizeof(recvBuf), 0); sizeof(recvBuf)? > /* Wurde etwas ausgelesen? */ > if(rc > 0) { > > /* Anzahl der ausgelsenen Daten hochzählen */ > readSize += rc; >
Kilian K. schrieb im Beitrag #4660643: > Mikro 7. schrieb im Beitrag #4660622: >> sizeof(recvBuf)? > > Lese halt nicht jedes Byte einzelnd aus sondern immer 4... Warum "tarnen" mit sizeof(recvBuf)? Bug: Was passiert wenn bereits BUFFER_LENGTH Daten gelesen wurden? > Mikro
-
Thread
V-USB Übertragungsproblem
bytesRemaining = rq->wLength.word; // store the amount of data requested if(bytesRemaining > sizeof(buffer)) // limit to buffer size bytesRemaining = sizeof(buffer); return USB_NO_MSG; // tell driver to use usbFunctionWrite() } return 0; // ignore
-
Thread
SAMD21 UART SERCOM ASF
SYSTEM_INTERRUPT_SYSTICK); uint8_t buf[] = "Hello World\r\n"; usart_write_buffer_wait(&usart_instance, buf, sizeof(buf)); while (true) { } } [/c] Bis auf die UART Ausgabe funktioniert soweit alles. Denke es liegt an der Konfiguration der UART. TX = PA00, RX = PA01
-
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
Wie auf Union mit Bitfeldern direkt zugreifen?
main(){ { // same memory, const changes in bla char a[]="\0Hello World"; bla(a+1,a+sizeof(a)-1); puts(a+1); } { // different memory, const doesn't changes in bla char a[]="\0Hello World"; const char b[]="\0Hello World"; bla(a+1,b+sizeof(b)-1); puts(a+1);
Und man muß soviel Speicher belegen, wie man denn wirklich braucht. Da gibt's ja Spezis, die den sizeof-Operator nicht kennen und dann mit magic numbers arbeiten. Das zerbricht natürlich bei der kleinsten Änderung, und ganz besonders, wenn man von 32bit auf 64bit geht, wo die Pointer auf einmal 8 Byte
-
Thread
C Array - neuen Wert in Array aufnehmen und die Werte zuvor nach rechts schieben
ständig rumzuschubsen. Benutz doch einfach einen Zeiger. Temp[index++]=TempRead; if (index >=sizeof...) index=0;
schmeissen, so die libc das hergibt. Damit wird das ganze Geschiebe zu: [c]memmove(Temp+1,Temp,sizeof(Temp)-sizeof(Temp[0])); Temp[0]= TempRead;[/c] Gruss WK
-
Thread
Zeiger auf konstante Arrays in Typdeklaration
: const int feld[] = > {1,2,3}; Die Anzahl der Elemente ist auch hier einfach zu bestimmen: sizeof(feld)/sizeof(feld[0])
-
Thread
Umstieg auf C
auch stapeln düfen. Eine direkte Beschränkung habe ich auf die Schnelle nicht gefunden, aber: - sizeof(bool) kann nicht kleiner als 1 sein. - sizeof(char), sizeof(signed char) und sizeof(unsigned char) ist 1. - Der address-of-Operator muss funktionieren (bool * muss existieren). - sizeof(bool[8])
düfen. > > Eine direkte Beschränkung habe ich auf die Schnelle nicht gefunden, > aber: > - sizeof(bool) kann nicht kleiner als 1 sein. > - sizeof(char), sizeof(signed char) und sizeof(unsigned char) ist 1. > - Der address-of-Operator muss funktionieren (bool * muss existieren). > - sizeof(bool
-
Thread
Fehler beim generieren eines Arrays
dein x=y=z=(double*)malloc(n*sizeof(double*)); sizeof(double*) im malloc verkneife dir mal. Ein Pointer (Adresse) auf double ist auf einem 32Bit-System 4 Bytes groß, dagegen double selbst 8 Bytes. double *x=(double*)malloc(3*n*sizeof(double)),*y=x+n,*z=x+n+n; wäre möglich.
-
Thread
C Katastrophen.
Abfangen von derart groben Schnitzern selber verantwortlich. Man könnte z.B. schreiben: [c] if(c < sizeof(a)/sizeof(a[0])){ a [c] = 0; }else{ printf("Programmierer war besoffen oder stoned!\n"); exit(-1); } [/c]
-
Thread
ATmega328P - Input liefert keinen Wert
Serial.println(data.humidity); // Serial.println(); // printf("Now sending "); // printf("",sizeof(data)); //unsigned long time = millis(); radio.stopListening(); //bool ok = radio.write( &time, sizeof(unsigned long) ); bool ok = radio.write(&data,sizeof(data)); radio.startListening
-
Thread
Problem mit C struct auf ARM
size_t length, struct bla* res ){ if( !res || !res->data && res->buffer_max || length < sizeof(struct bla_serialized) ) return false; struct bla_serialized* s = buffer; long data_len = ntoh(s->len); if( s->buffer_max < data_len || length < data_len + sizeof(struct bla_serialized
res->len = data_len; res->a = s->a; res->b = ntoh(s->b); memcpy(res->name,s->name,sizeof(res->name)); memcpy(res->data,s->data,res->len); return true; } [/c]
-
Thread
Float ins Externe EEPROM schreiben. Funkt. nicht so ganz
I2C_Device_Address + I2C_WRITE); i2c_write(eepromaddress & 0xFF); i2c_writeBlock((uint8_t*) &data, sizeof(data)); i2c_stop(); _delay_ms(5); } [/c] Gruß, Stefan
readEEPROM_Float): [c] float floatData; ... i2c_writeBlock((unsigned char*) &floatData, sizeof(data)); ... i2c_readBlockNak((unsigned char*) &floatData, sizeof(data)); ... [/c] Alles aus dem Stegreif geschrieben und ungetestet! Gruß, Stefan
-
Thread
Pointer auf Integerwert im Flash (ohne explizit eine Variable anzulegen)
doch auch nur > ein Zeiger). Weil ein Array kein Zeiger ist und ein Zeiger kein Array. 1) sizeof verhält sich anders. 2) Einem Zeiger kann ein Wert zugewiesen werden, einem Array nicht (damit ist nicht ein /Element/ des Arrays gemeint). [c] void test (void) { int *p; int array[5]; p = array; // Ok array = p; // Fehler sizeof (p); // = sizeof (int*) sizeof (array); // = 5 * sizeof (int) }[/c]
-
Thread
[VB2010] Laufwerksnummer aus Laufwerksbuchstaben herausquetschen
DWORD bytesReturned = 0; ::DeviceIoControl(h, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0, &info, sizeof(info), &bytesReturned, NULL); [/code] > Weis da jemand Schlagwörter [...] Evtl. WMI.