-
Thread
Array definieren und zuweisen
const int array2[] = {0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00}; ... memcpy(array, array2, sizeof array); > Ist in meinem Fall unpraktisch. C ist nun einmal eine skalare Sprache. Das kann gelegentlich unpraktisch sein.
auch folgende Schreibweise: [c] memcpy(array, (int[]){0xFF,0x00,0xFF,0x00,0x00,0x00,0x00}, sizeof array); [/c] Wenn das häufig vorkommt, kann man den etwas komplizierten Ausdruck auch in ein Makro packen: [c] #define ASSIGN_INT_ARRAY(a, ...) memcpy(a, (int[]){__VA_ARGS__}, sizeof a)
-
Thread
ESP8266 D1 Mini zeigt immer HIGH an obwohl nix angeschlossen ist
0b11100110 // = 9 }; // assert(digit < 10); const size_t ENTRY_COUNT = sizeof(seven_seg_digits)/sizeof(seven_seg_digits[0]); if(digit >= ENTRY_COUNT) { Serial.println("sevenSegWrite, argument out of range!"); return; } digitalWrite(latchPin
-
Thread
Strukturgröße bestimmen - TI320F2808
Parametersatz[] (von der Struktur Parametertabelle) besitzt. Hatte dies so vor: [c] test=sizeof(Parametersatz)/sizeof(Parametersatz[0]); [/c] test ist vom Typ unsigned char. Bekomme leider immer einen Fehler - dieser liegt an dem Teil "sizeof(Parametersatz)", deshalb zeige ich mal diesen Teil mit dem Fehler: [c] test=sizeof(Parametersatz); // Fehler: incomplete type is not allowed // oder ein anderer Versuch test=sizeof(Parametersatz[]); // Fehler: expected an expression [/c] Der Fehler im zweiten Fall
-
Thread
wortbreite void*
Mal sizeof (void *) ausgeben lassen? Ansonsten: Deine Annahme ist korrekt, in avr-gcc ist ein Pointer 16 Bit breit.
PROGMEM = "0123456789ABCDEF"; pgm_read_byte(&hex[i]); strcpy_p(buf, "unsinn"+(sinn ? 2 : 0));[/c] sizeof(char)==1 per Definition. Geht also nur, wenn pro Wort nur 1 Byte gespeichert wird.
-
Thread
String in Serial.write einbinden
Array mit einer Stringkonstanten initialisiert wird: [c] char load[] = "000000"; [/c] Ein sizeof(load) wird 7 ergeben. Wenn so initialisiert wird, wie zu Anfang* des Threads [c] char load[] = {'0','0','0','0','0','0'}; [/c] *dann* ist das Array nur 6 Bytes groß, und ein sizeof(load) ergibt
-
Thread
struct zu char array casten
keinen String hast. Also kannst du auch keine Stringfunktionen benutzen. [C] for( i = 0; i < sizeof( struct data ); ++i ) printf( "%02x ", p_Char[i]; printf( "\n" ); [/C]
Daten.data_h=55; Daten.eof =';'; Daten.header='h'; p_Char = (char*)&Daten; for( int x = 0; x <sizeof( struct data );x++ ) { printf("%02x",p_Char[x]); printf("\n"); } scanf("%i",&i); return 0; } [/c]
-
Thread
Größe von short-Variablen in C bei Linux-64bit
auf der Zielplattform mal [c] printf("%i", sizeof(unsigned short)); [/c] ausprobieren
Peter schrieb im Beitrag #3952375: > auf der Zielplattform malprintf("%i", sizeof(unsigned short)); > ausprobieren soviel dazu: > Selber habe ich nur > Linux-32bit installiert und kann es nicht ausprobieren.
-
Thread
Fehler bei strlen() in mspgcc ?
return si; } wobei die Funktion so aufgerufen wird : len_str = strlen_self(dummystr, sizeof(dummystr)) /*char dummystr[50*/ BTW: Gibt es eine Möglichkeit, die maximale Länge eines per "char *str" übergebenen Strings auch innerhalb der Funktion mit sizeof() festzustellen ?
-
Thread
Array als pointer in Funktion übergeben, dort beschreiben und wieder zurück
include <stdint.h> #include <stdio.h> #define NUMBER_OF_ELEMENTS 110 #define ARRAY_SIZE(a) (sizeof (a) / sizeof (a[0])) uint8_t array [NUMBER_OF_ELEMENTS] = {0}; void generate_stuff (uint8_t* array_ptr, size_t array_size) { for (size_t i = 0; i < array_size; ++i) { uint8_t fancy_value_to_assign
-
Thread
strcat Problem Nullbyte
ungewöhnliches Problem: [c] char pfad[1024]; char datei[1024]; FILE* stream; fgets(pfad,sizeof(pfad),stdin); // Pfad eingeben: pfad=="C:\\meinPfad" fflush(stdin); fgets(datei,sizeof(datei),stdin); // Dateinamen eingeben: datei=="text.txt" fflush(stdin); strcat(pfad,datei); stream=fopen
-
Thread
32 GPIO Sender und Empfänger via Bus/Ethernet
portF; buffer.aIn; // send data err = sock.sendto(remoteAddr, &buffer, sizeof(buffer)); // receive data (receiver should echo data err = recvfrom(nullptr, &buffer, sizeof(buffer)); // wait before sending again ThisThread::sleep_for(1ms
-
Thread
attiny2313 UART bzw. Speicher Initialisierung
while(1) { _delay_ms(1000); usart_transmit('a'); for(j = 0; j < sizeof(text); j++) { usart_transmit('a'+text[j]); } } while(1) {} } [/c] Führt zur Ausgabe von a```````````a```````````a```````````a```````````. Das lässt mich schließen
int j = 0; usart_init(1); while(1) { _delay_ms(1000); for(j = 0; j < sizeof(text); j++) { usart_transmit(text[j]); } text[0] = 'h'; text[1] = 'a'; text[2] = 'l'; text[3] = 'l'; text[4] = 'o'; text[
-
Thread
int-Wert in char-Wert packen
unsigned char array[4]; } test; test.u = 0x98765432; [/c] Vorausgesetzt natürlich, es gilt sizeof (unsigned int) == 4
> Vorausgesetzt natürlich, es gilt sizeof (unsigned int) == 4 Und die Endianess (Little oder Big) der Zielarchitektur passt.
-
Thread
long zu ascii - ARM7
Sorry, da war ich etwas unaufmerksam. Auf den meisten Systemen, auf denen ich unterwegs bin ist sizeof (int) == sizeof (long).
-
Thread
String über Uart empfangen STM32<--->Arduino
Dann solltest du deinen Aufruf so gestalten [C] char text2[10]; uart_gets( text2, sizeof(*text2) ); [/C] an der Stelle, an der du tatsächlich das Array noch als Array 'siehst', kannst du mit sizeof die Arraygröße feststellen. Es bringt nichts, wenn du gets anlügst. Wenn dein Array
-
Thread
C - Übergabe und Verwendung Tabelle
int main(int argc, char** argv) { char Textzeilen[3][10]; memset(Textzeilen, 0, sizeof(char[3][10])); strcpy(Textzeilen[0], "1te Zeile"); strcpy(Textzeilen[1], "2te Zeile"); EineFunktion(Textzeilen); return 0; } [/c] Wenn man das etwas lesbarer
main(int argc, char** argv) { Dreizeiler_t Textzeilen; memset(Textzeilen, 0, sizeof(Dreizeiler_t)); strcpy(Textzeilen[0], "1te Zeile"); strcpy(Textzeilen[1], "2te Zeile"); EineFunktion(Textzeilen); return 0; } [/c]
-
Thread
Probleme mit Variablen bei Ansteuerung eines FTD232
dwBytesWritten = 0; //write start code = 0 bData = 0; if (FT_Write(handle, &bData, sizeof (bData), &dwBytesWritten) == FT_OK) { // etc.pp. } [/c] Und wenn Du die Kanalnummer /iChannel/ als 16-Bit-Wert versenden willst, sieht der Aufruf so aus: [c] if (FT_Write(handle, &iChannel, sizeof (iChannel), &dwBytesWritten) == FT_OK) { // etc.pp. } [/c]
-
Thread
C-> Rückgabewerte?!
zurückgegeben? [c] uint8_t PICC_IsNewCardPresent() { byte bufferATQA[2]; byte bufferSize = sizeof(bufferATQA); // Reset ModWidthReg RFIDWrite(ModWidthReg, 0x26 ); StatusCode result = PICC_RequestA( bufferATQA, &bufferSize ); return (result == STATUS_OK || result == STATUS_COLLISION
#6069904: > uint8_t PICC_IsNewCardPresent() > { > byte bufferATQA[2]; > byte bufferSize = sizeof(bufferATQA); > > // Reset ModWidthReg > RFIDWrite(ModWidthReg, 0x26 ); > > StatusCode result = PICC_RequestA( bufferATQA, &bufferSize ); > return (result == STATUS_OK || result == STATUS_COLLISION
-
Thread
F_Mount /FATFS / STM32F401RE
Test."; f_open(&myFILE,MyPath,FA_WRITE|FA_CREATE_ALWAYS); f_write(&myFILE,MyData,sizeof(MyData),&testByte); f_close(&myFILE); f_mount(&myFATAFS,SDPath,0); } } [/c] -> Funktioniert, Datei und Inhalt können z.B. am PC gelesen werden. [c] { if(received) {
Test."; f_open(&myFILE,MyPath,FA_WRITE|FA_CREATE_ALWAYS); f_write(&myFILE,MyData,sizeof(MyData),&testByte); f_close(&myFILE); f_mount(&myFATAFS,SDPath,0); } received=0; }[/c] -> funktioniert nicht. Der Code bleibt bei f_mount stehen. Nichts geht mehr.
-
Thread
Präprozessor(?): Zeichen in Zeichenkette ersetzen
> struct IntegerSequence { using value_type = T; static constexpr size_t size () { return sizeof... (I); } }; namespace Helper { template <typename T, typename S1, typename S2> struct ConcatSequence; template <typename T, T... S1, T... S2> struct ConcatSequence<T, IntegerSequence<T, S1...>, IntegerSequence<T, S2...>> { using type = IntegerSequence<T, S1..., (sizeof...(S1) + S2)...>; }; template <typename T, T N, bool isZero, bool isOne> struct GenSeqI; } template <typename T, T N> using GenSeq = typename Helper::GenSeqI<T, N, N == 0, N == 1>::type
-
Thread
40 Bit in 5 Bytes abbilden mit Bitfeld
Hast Du dir mal sizeof(tx_data) angesehen? Ich würde erwarten, dass entweder die Größe nicht deinen Erwartungen entspricht, oder aber Padding Bits an stellen sitzen, an denen Du sie nicht erwartest.
Micha schrieb im Beitrag #4802124: > Hast Du dir mal sizeof(tx_data) angesehen? Mathias G. schrieb im Beitrag #4801393: > Ich komme auf 8 Byte
-
Thread
winForms C++ auseinandernehmen einer Zahl
#include <iostream> #include <stdlib.h> //(...) char buffer [10]; size_t bufferSize = (sizeof(buffer) / sizeof(buffer[0])); int radix = 10; int input = 123; _itoa_s(input, buffer, bufferSize, radix); cout << buffer[0] << buffer[1] << buffer[2] << endl; [/c]
-
Thread
I2C - 2 Atmega32 - 1 Atmega328P - 1 DS1307
255,255,255); lcd.setBackColor(0,0,0); lcd.setFont(BigFont); RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t)); RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); RTC.getTime(); RTC.ctrl = 0x00; RTC.setCTRL(); } void loop() { printtime();
RTC.fillByHMS(01,30,0); RTC.setTime(); TimeIsSet = 0xaa55; RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); RTC.startClock(); } void calcTime( char* timeBuffer, int time, int max ) { if ( time < max ) { timeBuffer[0] = '0' + time / 10; timeBuffer[1]
-
Thread
wieder mal ft800
(255,255,255); FTImpl.Finish(); } void loop() { char buf[30]; memset (buf, 0, sizeof(buf)); snprintf(buf, sizeof(buf)-1, "%d", millis()); FTImpl.DLStart(); FTImpl.Clear(1,1,1); FTImpl.ColorRGB(255,255,255); FTImpl.Cmd_Text(240, 138, 31, FT_OPT_CENTER
-
Thread
Platformunabhängiges iterieren über alle floats
<stdio.h> long isfloat = 0; long isnotfloat = 0; union { float f; unsigned char c [sizeof(float)]; } t; void doit() { isfloat++; } void loop(int pos) { if (pos < 0) { if (isnan(t.f)) isnotfloat++; else doit(); } else { t.c[pos] = 0; while
(pos -1); if(++t.c[pos] == 0) return; } } } void main() { loop(sizeof(float) - 1); printf("float %ld nan %ld\n", isfloat, isnotfloat); } [/code]
-
Thread
Linux C "free(): double free detected in tcache2
[c] while( 1){ size = sizeof( a1); fd = accept( s, (struct sockaddr*) &a1, &size); if ( ( pid = fork()) < 0) { printf( "\nfork err %s", strerror( errno));
A alloc err tmp"); size = GetRecData( fd, &tmp, ip); memset( http_header, 0, sizeof( http_header)); mopen( tmp, strlen( tmp)); st = 0; while ( mgetstrim( str)){ if ( ! *str) break; appsprintf( http_header
-
Thread
Probleme mit der Verbindung PWM + ADC
uint16_t pwmtable_8B[8] PROGMEM = {0, 4, 8, 16, 32, 64, 128, 255}; #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) [/C] ... [C] for(tmp=0; tmp < ARRAY_SIZE(pwmtable_8B); tmp++) { OCR1A = pgm_read_word( &pwmtable_8B[tmp] ); my_delay(delay); } [/C] Lass den Compiler für
-
Thread
Beim Byte die Bits am schnellsten umsetzen.
b4 : 1; unsigned b5 : 1; unsigned b6 : 1; unsigned b7 : 1; }; static_assert(sizeof(struct b8) == sizeof(uint8_t)); struct b8 in; memcpy(&in, &u8, 1); const struct b8 out = { .b0 = in.b7, .b1 = in.b6, .b2 = in.b5, .b3 = in.b4, .b4 = in.b3, .b5
-
Thread
C++ Datei als Short int array einlesen.
unsigned short int[size/2]); file.seekg(0,file.begin); file.read(matrix,(size/2) * sizeof(unsigned short int)); Vielleicht hast du aber dann noch Endian-Problem...
werden können, was manche 32-Bit-Architektur möglicherweise machen könnte. Das lässt sich mit dem sizeof-Operator prüfen, wie groß ist ein Array aus zwei uint16_t? Doppelt so groß wie ein einzelner uint16_t?
-
Thread
fernbedienung - IR protokolle !
SIG_INTERRUPT0){ unsigned char werte[64]; unsigned char temp, i,c; semi_delay_1p125ms(); for(i=0;i<sizeof(werte);i++){ werte[i] = bit_is_set(PIND,2) ? '1' : '0'; delay_1p125ms(); } led_mask(LEDMASK_ALL); for(c=0;c<sizeof(werte)/16;c++){ lcd_clear(); for(i=0;i<16;i++) lcd_putchar(
-
Thread
String zu Integer (Wer findet den Fehler?)
PC oder auf einem AVR getstet? Kai hat das Problem schon richtig erkannt. Auf einem AVR ist sizeof(int) == 2 und daher wird die Multiplikation mit 10000 für viele Zahlen überlaufen. Um das zu umgehen, muss die Multiplikation als long gemacht werden. [C] ((*string - 0x30) * 10000L); [/C] Auf einem PC wirst du das Phänomen whrscheinlich so nicht sehen, da dort sizeof(int) heutzutage meistens 4 ist.
-
Thread
fwrite() funktioniert nicht!
messwerte.txt", "w"); printf ("Zahl eingeben! "); scanf ("%d",&temp); fwrite(&temp,1,sizeof(temp),pFile); fclose(pFile); } [/c] Danke
Habe die Übergabe-Parameter sizeof() mit "1" vertauscht, hat auch nix gebracht.
-
Thread
Temperatursensor mit maximaler Genauigkeit auswerten
struct tab table[] = { { 980, -55 }, { 1030, -50 }, ... }; const int num_values = sizeof(table) / sizeof(table[0]); [/c] Mit dem gemessenen Widerstandswert gehst Du dann in die Tabelle und interpolierst: [c] int temp(int res) { int temp; int i = 0; do {
-
Thread
ESP32 Wrover 4MB SPI-RAM mit Arduino nutzen
nutze ich es falsch. [c] const int N = 128*1024; byte* buff; if (buff = (byte*)ps_malloc(sizeof(byte)*N)) Serial.println("ps_malloc succeeded"); else Serial.println("ps_malloc failed"); [/c] Ergibt [c] -> ps_malloc failed [/c] Hier nochmal mein geändertes Testprogramm:
Serial.printf("\n%d Bytes free.\n\n", ESP.getFreeHeap()); // ps_malloc if (buff = (byte*)ps_malloc(sizeof(byte)*N)) Serial.println("ps_malloc succeeded"); else Serial.println("ps_malloc failed"); // heap_caps_malloc if (buff = (byte*)heap_caps_malloc(sizeof(byte)*N, MALLOC_CAP_8BIT)
-
Thread
LED - Cube, if anweißung
1,1,1), NEXT, }; const prog_char *program_pointer = program_1; unsigned int program_length = sizeof(program_1); // Main int main(void) { // Initialisierung init(); // Hauptschleife while (1) { unsigned char instruction = pgm_read_byte(&(program_pointer[program_counter
1,1,1), NEXT, }; const prog_char *program_pointer = program_1; unsigned int program_length = sizeof(program_1); danke schonmal... mfg.: J. adler
-
Thread
Funktion: Berechnung WeekOfDay
include <stdlib.h> int dow(const char * date) { struct tm myTime; memset (&myTime, '\0', sizeof (myTime)); myTime.tm_year = atoi(date); myTime.tm_mon = atoi(date+5)-1; myTime.tm_mday = atoi(date+8); mktime(&myTime); return myTime.tm_wday; } [/c] Statt den drei
berechnet. [c] int dow(const char * date) { struct tm myTime; memset (&myTime, '\0', sizeof (myTime)); myTime.tm_year = atoi(date)-1900; myTime.tm_mon = atoi(date+5)-1; myTime.tm_mday = atoi(date+8); mktime(&myTime); return myTime.tm_wday; } [/c]
-
Thread
Zugriff auf SD-Karte mit Atmega168
reservieren muss... kann man die Größe des Stacks wahrend des Programmablaufs abfragen z. B. mit sizeof()? Die Zahl könnte ich dann auf einem LCD ausgeben...
#2392290: > kann man die > Größe des Stacks wahrend des Programmablaufs abfragen z. B. mit > sizeof()? Die Zahl könnte ich dann auf einem LCD ausgeben... Die einzig sinnvolle Auswertung die auch einigemaßen stimmen könnte währe innerhalb eines Timerinterupts den Stackpointer zu lesen und den niedrigsten
-
Thread
uint32_t - stolperfalle ?
Warum uint32_t statt "unsigned long"? Weil sizeof (unsigned long) nicht unbedingt 32 ist. Das kann, je nach Maschine, auch einen ganz anderen Wert annehmen.
* Korrektur * Weil sizeof (unsigned long) nicht unbedingt _4_ ist. (und einen Trottelpunkt von meinem Konto abziehen)
-
Thread
C-Compiler ohne schnick-schnack
gesehen, dass jemand mal eben hingekritzelt hat int * array = malloc (n * 4); // blinde Annahme: sizeof (int) == 4 anstatt ... malloc (n * sizeof (*array)), wie es richtig wäre? Jetzt kannst du sagen, "jaha, das sind ja auch Fehler, wenn man sich nicht an die Regeln hält". Richtig, aber um solche
-
Thread
Probleme mit CC3000 auf dem MSP-EXP430FG4618
ulSocket2 < 0) { rs232_printf("Error in Socket deskriptor\n"); } // memset(&tSocketAddr, 0, sizeof(sockaddr)); // TODO REVEIVE UDP DATA********************************************************** memset(tSocketAddr.sa_data, 0, sizeof(sockaddr)); tSocketAddr.sa_family = AF_INET; tSocketAddr.sa_data
[1] = 01; // rs232_printf("\nbind = %d\n", // bind(ulSocket2, (sockaddr*) &socketAddr, sizeof(sockaddr))); if (bind(ulSocket2, &tSocketAddr, sizeof(sockaddr)) != 0) { rs232_printf("Bind connection FAILED== %d\n"); } sockLen = sizeof(sockaddr); rs232_printf("sockLen =
-
Thread
double belegt weniger Speicher als float?
natürlich nicht. Ob das bei dir auch so ist, müsstest du bei deinen Unterlagen finden (oder einfach sizeof(double) und sizeof(float) ausgeben und vergleichen).
-
Thread
int Umwandlung
10, wert%10); Ach Blödsinn du hast da ne andere Ausgabe: char buffer[9]; snprintf(buffer, sizeof(buffer), "%d.%d\n", wert/10, wert%10); LCD_Print(buffer,...
holger schrieb im Beitrag #2811521: > char buffer[9]; > snprintf(buffer, sizeof(buffer), "%d.%d\n", wert/10, wert%10); > LCD_Print(buffer,... Das mit dem char Array hatte ich auch schon probiert. Aber ich wollte dann einfach das Array irgendwie ausgeben, ohne es vorher umzuwandeln
-
Thread
(Speicher?-) Problem mit STM32 + VCP
if(ButtonUp) { while(ButtonUp); SendStringLength = sizeof(SendString); USB_SIL_Write(EP1_IN, SendString, SendStringLength); SetEPTxValid(ENDP1); }; // if(ButtonDown) // { // while(ButtonDown
if(ButtonUp) { while(ButtonUp); // SendStringLength = sizeof(SendString); // USB_SIL_Write(EP1_IN, SendString, SendStringLength); // SetEPTxValid(ENDP1); }; // if(ButtonDown) // { // while(ButtonDown
-
Thread
Daten über UDP senden
/----------------------------sendto()---------------------------------- for(;;) { tolen = sizeof(addr); byte_count = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr *)&addr, &tolen); //byte_count = sendto(new_fd, buf, sizeof(buf), 0); if (byte_count == -1) printf("\nFehler mit sendto
-
Thread
Linux C-Programm - Zeitmessung per Interrupt
werden buffer[0] = (char)'A'; //printf(buffer); //printf("\n"); write(port, buffer, sizeof(buffer)); //printf("Zeichen wurde gesendet\n"); // Zeichen von der seriellen Schnittstelle einlesen // es wird bis Zeilenende oder max. 80 Zeichen gelesen y=0; for (x=0; x<80; x++) { // Jetzt können Daten gelesen werden bytes = read(port, buffer, sizeof(buffer)); printf(buffer); if (buffer[0] >= ' ') { puffer[y]=buffer[0]; y++; } if (buffer[0] == '\n') { break; } } puffer[y] = (
-
Thread
struct / pointer => Verständnisproblem
pFunction, uint8_t subMenueCount, MENUE* subMenues) { MENUE* newMenue = (MENUE*) malloc(sizeof(MENUE)); (*newMenue).menueName = menueName; (*newMenue).pFunction = pFunction; (*newMenue).subMenueCount = subMenueCount; // 4 Frage: Wie weise ich das ganze hier zu? (*newMenue
pFunction, uint8_t subMenueCount, MENUE* subMenues) { MENUE* newMenue = (MENUE*) malloc(sizeof(MENUE)); (*newMenue).menueName = menueName; (*newMenue).pFunction = pFunction; (*newMenue).subMenueCount = subMenueCount; (*newMenue).subMenues = subMenues; // << error laut compiler }