-
Thread
WatchdogMeldung automatisch entfernen
Pattern gesucht wird. Die Array Ausgabe kann man sich so vorstellen: [code]for (int i = 0; i < sizeof(my_array); i++) { printf(" %02X", my_array[i]); //Pruefen nach Watchdog und ggf entfernen }[/code]
-
Thread
Problem mit dem NRF24L01
temp = sensorValue(tempSensor); dtostrf(temp, 5, 2, storage); radio.write(&storage, sizeof(storage)); Serial.println(storage); delay(3000); } float sensorValue(byte deviceAddress[]){ tempC = sensors.getTempC(deviceAddress); return tempC; }[/c] und hier der Code vom
-
Thread
[ARM-GCC] malloc Page Size 4096 Byte änderbar?
malloc immer mindestens 4096 Byte - auch wenn ich nur Speicher für ein Struct anfordere, das selbst sizeof(x)=28 Byte hat. Da ich kein OS und keine MMU mit virtueller Speicherverwaltung hab, erschließt sich mir der Sinn einer 4096-Byte "Page-Size" absolut nicht ... Kann man das dem Malloc austreiben
immer mindestens > 4096 Byte - auch wenn ich nur Speicher für ein Struct anfordere, das > selbst sizeof(x)=28 Byte hat. > > Da ich kein OS und keine MMU mit virtueller Speicherverwaltung hab, > erschließt sich mir der Sinn einer 4096-Byte "Page-Size" absolut nicht > ... > > Kann man das dem
-
Thread
Pointer auf Struct - Unterschiede
mit_ptr = &ohne_ptr; test_t *new_ptr = new test_t; // C++ test_t *malloc_ptr1 = (test_t *)malloc(sizeof(test_t)); // C/C++ test_t *malloc_ptr2 = malloc(sizeof(test_t)); // C [/c]
einen char an? [c] char *ptr = NULL; int main(void){ printf("Size of Pointer %d\n\r",sizeof(*ptr)); } [/c]
-
Thread
Hex-Wert in char-Array umwandeln?
z.B. das Struct in ein "unsigned char" array casten, damit Du byteweisen Zugriff erhälst und mit sizeof kannst du die Grösse des structs ermitteln.
-
Thread
unaligned acces bei einem imx6q
code] int main(int argc, char **argv) { long long i, temp, number=10; char *ptr = malloc(sizeof(long long) * number+1); long long *unaligned = (long long *)&ptr[2]; for(i = 0; i < number; i++) temp = unaligned[i]; return(0); } [/code] Int Variante ============= [code] int main(int argc, char **argv) { int i, temp, number=10; char *ptr = malloc(sizeof(int) * number+1); int *unaligned = (int *)&ptr[2]; for(i = 0; i < number; i++) temp = unaligned[i]; return(0); } [/code]
-
Thread
Frage zu Zeiger
printf("New Value of p_char : %u\n", p_char); printf("Size of datatype char : %u\n", sizeof(char)); printf("Size of p_char : %u\n\n", sizeof(p_char)); printf("New Value of p_int : %u\n", p_int); printf("Size of datatype int : %u\n", sizeof(int)); printf("Size of p_int : %u\n\n", sizeof(p_int)); printf("New Value of p_ui64 : %u\n", p_ui64); printf("Size of datatype uint64_t : %u\n", sizeof(uint64_t)); printf("Size of p_ui64 : %u\n\n", sizeof(p_ui64)); printf
-
Thread
Arduino Uno Programm auf Micro
void loop() { int z; if (myRadio.available()){ i=150; myRadio.read(&z, sizeof(int)); Serial.println("Ein, z = "+String(z)); } if(i>0)i--; digitalWrite(4,i>0); ausgabe++; if(ausgabe==100){ ausgabe=0; // Ausgabe if (i>0) {
myRadio.openWritingPipe( addresses[0]); } void loop() { int x =0; myRadio.write(&x,sizeof(int)); Serial.print("EIN"); delay(1000); } [/c] So sieht der Funktionsablauf des Programms in etwa aus.
-
Thread
USART Probleme beim atmega324p
while (1) { char Line[40]; // String mit maximal 39 zeichen uart_gets( Line, sizeof( Line ) ); uart_puts(Line); } return 0; }
-
Thread
was heisst ->
Hallo, Was wird hiermit zum Ausdruck gebracht PlayFile->filename[ sizeof(PlayFile->filename) -6 ] = destime.minute/10 + '0'; mir gehts speziell um PlayFile->filename. Was wird hiermit gemacht -> Vielleicht köönte mir das kurz jemand erklären. mfg
Beitrag #5030209: > Hallo, > > Was wird hiermit zum Ausdruck gebracht > > PlayFile->filename[ sizeof(PlayFile->filename) -6 ] = destime.minute/10 > + '0'; > > mir gehts speziell um PlayFile->filename. > Was wird hiermit gemacht -> Welche Sprache? Haskell?
-
Thread
FreeRTOS Taskaufruf nur, wenn eine Task vorhanden
pvParameters; > for(;;) > { > > Error = UART_SendBlock(MySerialPtr, pcTaskName, > sizeof(pcTaskName)); /* Send block of characters */ > Es ist nun > aber so, dass mir die sizeof() Funktion nicht 20 zurückgibt, wie ich > eigentlich erwarte? > Woran mag das liegen? pcTaskName ist definiert als pointer auf char, nicht als char-Array. sizeof() liefert dir also die Größe des Pointers, nicht die Große des Arrays worauf der Pointer zeigt. Entweder musst du die Größe irgendwie mitübergeben als Task-Parameter, oder im Task den String Byte
-
Thread
UART Receive vom PC. Erstes Zeichen ist ständig 0
object.connect("COM4"); object.sendArray(sendBuffer, sizeof(sendBuffer)); object.disconnect(); [/c] Empfangsseite Mikrocontroller, im UART-receive-Interrupthandler: [c] if(USART_GetITStatus(USART2, USART_IT_RXNE)) { USART_ClearITPendingBit
50) und einmal Sleep(200) jeweils zwischen object.connect(); und object.sendArray(sendBuffer, sizeof(sendBuffer));
-
Thread
UART array auslesen
, wenn dieser 100 oder 1000000 ist. uint8_t aaa='z'; HAL_UART_Transmit(&huart2, &aaa, sizeof(aaa),100); zudem würde ich gerne wissen, warum ich so Zeichen senden kann, aber folgendes nicht funktioniert uint8_t array[] = {1, 2, 3, 6, 5, 4}; HAL_UART_Transmit(&huart2, &array, sizeof
array[] = {'m', 'a', 'x', 'd', 'e', 'n', 'g', 'e', 'r'}; HAL_UART_Transmit(&huart2, &array[0], sizeof(array), 100); [/c] Jedoch würde ich trotzdem gerne wissen, wofür die Timeout ist. Das habe ich leider nicht gefunden. [c] HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8
-
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
STM32F105 Parameter im Code zur Laufzeit updaten
FLASH_ErasePage(0x08019200); FLASH_ProgramWord(0x08019200, data1); FLASH_ProgramWord(0x08019200 + sizeof(uint32_t), data2); FLASH_ProgramWord(0x08019200 + 2 *sizeof(uint32_t), b); FLASH_ProgramWord(0x08019200 + 3 * sizeof(uint32_t), c); FLASH_ProgramWord(0x08019200 + 4 * sizeof(uint32_t), (uint8
FLASH_ErasePage(0x08019200); FLASH_ProgramWord(0x08019200, data1); FLASH_ProgramWord(0x08019200 + sizeof(uint32_t), data2); FLASH_ProgramWord(0x08019200 + 2 *sizeof(uint32_t), b); FLASH_ProgramWord(0x08019200 + 3 * sizeof(uint32_t), c); FLASH_ProgramOptionByteData(0x08019200 + 4 * sizeof(uint32
-
Thread
ATxmega256A3 Problem mit avrdude (avrosp.exe funktioniert)
0x10000 ) { char cmd[3]; cmd[0] = 'A'; @@ -432,6 +437,19 @@ butterfly_send(pgm, cmd, sizeof(cmd)); butterfly_vfy_cmd_sent(pgm, "set addr"); + + } else { + + char cmd[4]; + + cmd[0] = 'H'; + cmd[1] = (addr >> 16) & 0xff; + cmd[2] = (addr >> 8) & 0xff; + cmd[3] = addr & 0xff; + + butterfly_send(pgm, cmd, sizeof(cmd)); + butterfly_vfy_cmd_sent(pgm, "set extaddr"); + } } [/code] Leider werde ich avrdude aber aufgrund der GPL sowieso nicht verwenden können/dürfen... //EDIT: Würde den Faden gerne
-
Thread
Deklaration von main()
Pointer auf allozierte Speicherbereiche. Wesentlicher Unterschied: [c]int *ptr; ptr = calloc(a, sizeof(int)); ptr++;[/c] ist legal. [c]int arr[a]; arr++;[/c] ist nicht legal.
s1; const char* cs2 = s2; // decay f1(cs1); f2(cs2); // decay assert(sizeof(s1) == 4); assert(sizeof(s2) == 10); assert(sizeof(cs1) == sizeof(char*)); assert(sizeof(cs2) == sizeof(char*)); } [/c] [1] hier ist zu beachten, dass der Address-Operator den
-
Thread
Datentypen und ihre Breite MSP430
In <limits.h> und <float.h> steht was und du kannst es selber mit sizeof heraus bekommen.
-
Thread
Wemos D1 mini RS232
(device_id == 2) { Serial.println("AN"); //Beamer Serial.write(BeamerAN, sizeof(BeamerAN)); //das ist die Asuführung Beamer an delay(20000); //Sollte die Pause sein die nicht Funktioniert Serial.write(Video3, sizeof(Video3)); //soll auf Video3 schalten } [/code] das was jetzt noch nicht klappt ist die Pause zwischen "BeamerAN" und "Video3". Der Beamer Soll jedesmal
-
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
Malloc selber schreiben
heap[i] = 0; } Size_OF_Free_Space = SIZE_OF_HEAP; headerstart = mem_init_alloc(sizeof(struct header)); Size_OF_Free_Space -= sizeof(struct header); headerstart->size = SIZE_OF_HEAP-sizeof(struct header); // Header 12 Byte headerstart->state = 'F'; headerstart->speicher =
== NULL) { help = &heap[SIZE_OF_HEAP - Size_OF_Free_Space]; Size_OF_Free_Space -= sizeof(struct header); headerstart->size = Size_OF_Free_Space; help->size = size; help->state = 'A'; help->next = NULL; help->speicher = &heap[SIZE_OF_HEAP - Size_OF_Free_Space
-
Thread
Binärdaten sauber in Logdatei schreiben
. Ich definiere meine Logdaten als struct (in C) und schreibe die Daten in dieser Größe binär sizeof(struct ....) auf die Platte. Dadurch ist, solange die struct statisch ist, gewährleistet, dass immer die Satzgröße gleich ist. Damit braucht man sich keine Satztrenner einfallen lassen und hat auch
-
Thread
STM32 C++ Memberfunktion in Interrupt
auch zusätzlches RAM. Im Beispiel würde man die Größe des heaps auch nicht einfach nur auf 2 * sizeof(SomeClass) dimensionieren, sondern noch etwas Reserve drauf geben, um nicht bei jeder Änderung an den Linker-Einstellungen herum drehen zu müssen. (und je nach Implementierung des heaps müsste der
-
Thread
avr-gcc: __DATE__ formatieren / "initializer element is not constant"
setup() { Serial.begin(9600); Serial.print(F("Date of Compilation:")); for (int i=0;i<sizeof(compileDate);i++) Serial.write(pgm_read_byte(&compileDate[i])); Serial.println(); } void loop() { // put your main code here, to run repeatedly: } [/c]
setup() { Serial.begin(9600); Serial.print(F("Date of Compilation:")); for (int i=0;i<sizeof(compileDate);i++) Serial.write(pgm_read_byte(&compileDate[i])); Serial.println(); Serial.print(F("Nach der Umformatierung:")); char buf[20]; sprintf_P(buf, PSTR("%04d/%02d/%02d_%02d
-
Thread
AVR: Resetpin als GPIO --> Problem
die LED-Helligkeit verändert: [c] if( get_key_long(1<<KEY1) ){ if( brightnessValue >= sizeof(brightnesses)/sizeof(uint8_t)-1 ) brightnessValue = 0; else brightnessValue += 1; for(index = 0;index < 3;index += 1){ LEDS[index].brightnessReduction = brightnesses
-
Thread
Socket UDP Verbindung und mehrere Clients
; } objectUDPPort *UPort[2]; void main(void) { UPort[0] = (objectUDPPort *)malloc(sizeof(objectUDPPort)); UPort[1] = (objectUDPPort *)malloc(sizeof(objectUDPPort)); _objectUDPPort(UPort[0], "192.168.0.1", 1000, 1001); // UDP-Client _objectUDPPort(UPort[1], "192.168.0.2", 1000
name.sin_addr.S_un.S_addr = htonl(INADDR_ANY); if (bind(pInst->Socket, (sockaddr*)&name, sizeof(name)) == SOCKET_ERROR) { closesocket(pInst->Socket); pInst->Socket = INVALID_SOCKET; } else { int result = 0; int Timeout_ms = 1; if (result
-
Thread
Pointer verstehen mit malloc und free
printf("pxx: \t%p\t Addr: %p\n\n", ppx, &ppx); } void f2(){ int x = 0; int *px = malloc(sizeof(int)); int **ppx = malloc(sizeof(int *)); *px = x; *ppx = &px; printf("x: \t%d\t\t Addr: %p\n", x, &x); printf("px: \t%p\t Addr: %p\n", px, &px); printf("pxx: \t%p\t Addr:
=NULL; und auch prüfen ob du von malloc auch speicher bekommen hast ! [c] int *px = malloc(sizeof(int)); if(px){}; [/c] Außerdem gibt malloc den Type void zurück besser ist int *px=(int*)malloc(sizeof(int)); warum wirt du noch Festellen
-
Thread
'return' with no value, in function returning int
Rück Kehrer schrieb im Beitrag #4993320: > if (index >= sizeof SHM_DATA_TYPES) { Das ist übrigens falsch, du meinst vermutlich: [c]if (index >= sizeof(SHM_DATA_TYPES) / sizeof(SHM_DATA_TYPES[0]))[/c]
ausgeborgt; danke, Giovanni Di Sirio). Dr. Sommer schrieb: > Rück Kehrer schrieb: >> if (index >= sizeof SHM_DATA_TYPES) { > Das ist übrigens falsch, du meinst vermutlich:if (index >= > sizeof(SHM_DATA_TYPES) / sizeof(SHM_DATA_TYPES[0])) Ja, das ist ein heikles Thema. Eigentlich hast du Recht. Aber
-
Thread
OpenCL mit Code::Blocks einrichten.Probleme
maxDevices = 5; cl_device_id* deviceIDs = (cl_device_id*)malloc(maxDevices*sizeof(cl_device_id)); cl_platform_id* platforms = (cl_platform_id*)malloc(sizeof(cl_platform_id)); cl_int err; cl_uint num_entries = 1; cl_uint available
maxDevices = 5; cl_device_id* deviceIDs = (cl_device_id*)malloc(maxDevices*sizeof(cl_device_id)); cl_platform_id* platforms = (cl_platform_id*)malloc(sizeof(cl_platform_id)); cl_int err; cl_uint num_entries = 1; cl_uint available
-
Thread
Speicher reservieren mit malloc
pTest; uint32_t Var1; uint16_t Var2; }; test *ptr_test; ptr_test = (test*)malloc(sizeof(test)); [/c]
[/c] Ansonsten passt das. Bei [c] ptr_test = (test*)malloc(sizeof(test)); [/c] scheiden sich die Geister, ob man den Rueckgabewert von malloc nun casten sollte oder nicht. In C++ musst du casten, in C kannst du casten, musst du aber nicht. Beachte, dass bei
-
Thread
fgetc(.) gibt EOF zurück obwohl das Dateiende noch nicht erreicht wurde
%d%d%d", &width, &height, &maxbrithness); ppixel = (char*)malloc ( (width * height) * sizeof ( char ) ); if(!ppixel){ printf_s ( "Es konnte kein Speicherplatz reserviert werden !\n" ); return -1; } printf_s("lese %d Pixel ein\n",(width
-
Thread
C Code in C# Code konvertieren
tTEST; Types u16Frametype; uint32_t u32Count; }Header_t; #define HEADER ( sizeof( Header_t ) - 2 ) typedef struct { Header_t tHeader; uint8_t au8Data[ 100 ]; }Tele_t; [/c]
-
Thread
memcpy funktioniert nicht
(&(pStruct->Info),(uint8_t*)pLocalInfo,sizeof(TypeInfo)); [/c] und so: [c] TypeInfo tempInfo; memcpy(&(tempInfo), pLocalInfo,sizeof(TypeInfo)); [/c] Seht ihr in der Verwendung irgendein Problem, oder muss ich den Fehler in pStruct
Hast du mal im Assemblerlisting nachgeschaut, ob [c] memcpy(&(pStruct->Info),pLocalInfo,sizeof(TypeInfo)); [/c] und [c] memcpy(&(pStruct->Info),(uint8_t*)pLocalInfo,sizeof(TypeInfo)); [/c] tatsächlich unterschiedlich übersetzt werden? Ich kann mir das nicht vorstellen und
-
Thread
Arduino Variabel Typ abfragen möglich? Boolean Variable über 1
gesetzt werden können... Anyway, hier noch der Code in dem das Mysteriöse geschieht: for(i=0;i<sizeof(sequence2x)/4;i++){ xdiffs2[i] = sequence2x[i+1] - sequence2x[i]; ydiffs2[i] = sequence2y[i] - sequence2y[i+1]; Serial.println
-
Thread
Viele Flags effizient speichern und schreiben/Byte in Bitfeld?
empfangsroutine */ void receiveMsg(TTypMsg typ, void *msg, int len) { if(typ == TYP_MSG_1 && len == sizeof(RcvMsg1)) { memcpy(RcvMsg1, *msg, len); } } /* senden (geschieht auch mit memcpy)*/ sndMsg(TYP_MSG_2, &msg2, sizeof(msg2)); [/c]
/ > void receiveMsg(TTypMsg typ, void *msg, int len) > { > if(typ == TYP_MSG_1 && len == sizeof(RcvMsg1)) > { > memcpy(RcvMsg1, *msg, len); > } > } > > /* senden (geschieht auch mit memcpy)*/ > sndMsg(TYP_MSG_2, &msg2, sizeof(msg2)); Auch das ist nicht portabel.
-
Thread
16x2 LCD Kontrast Einstellung
)0); lcd.print(" 21,3" + String(char(223)) + "C "); lcd.setCursor(0,1); lcd.print(sizeof(charMap)); } void loop() { }[/c] Also den Fehler hab ich noch nicht gefunden, konnte die Darstellung durch die Verwendung der Kondensatoren jedoch ausreichend verbessern, sodass eine Verwendbarkeit