-
Thread
Modbus Tcp/Ip Protokoll vs Socket Tcp/Ip Protokoll
int socketctx = socket(AF_INET, SOCK_STREAM, 0); connect(socketctx,(struct sockaddr *)&server, sizeof(server)); MEINE FRAGE: Kann ich mein Ziel Request über Socket so abschicken,dass der Server(Microcontroller) den Befehl identisch bearbeitet als sei es ein Modbus Request ? Anders ausgedrückt,
-
Thread
AVR 32Bit - SDRAM Daten auf USB Stick
ui_test_finish(false); // Test fail continue; } if (!file_write_buf((uint8_t*)MSG_TEST, sizeof(MSG_TEST))) { lun_state |= (1 << lun); // LUN test is done. ui_test_finish(false); // Test fail continue; } file_close();
-
Thread
ARM-GCC: 64 Bit breites enum
default: printf("Pech gehabt\n"); } printf("s1=%d, s2=%d, s3=%d\n", sizeof(e_test1), sizeof(e_test2), sizeof(e_test3)); } [/c] Ausgabe unter Windows: [code] Enum: 8000000080000000 Gl³ck gehabt s1=8, s2=4, s3=4 [/code] Ausgabe auf dem LCD des STM32: [code]
e_test2 = 0x1, } test_t; enum { e_test3 = 0x1, }; printf("s1=%d, s2=%d, s3=%d\n", sizeof(e_test1), sizeof(e_test2), sizeof(e_test3)); printf("enumsize = %d\n", sizeof( (test_t) e_test2) ); [/c] kommt beim ersten printf noch das gewohnte Ergebnis mit unterschiedlichen Größen heraus
-
Thread
ESP8266 C++11 features wie lambdas
function<bool (int32_t, int32_t)> compare) { int32_t value = values[0]; for(uint16_t i = 1; i < sizeof(values); i++) { if(compare(values[i], value)) value = values[i]; } return value; } [/c] wobei *get_value_with_compare* eine private Methode der Klasse Util ist, nur *get_highest_value
-
Thread
Audio Codec (PCM3060) funktioniert nicht. Vorschläge zum weiteren Vorgehen
Unselect device HAL_Delay(10); //Wait //Write configuration registers for(i=0;i<sizeof(reg)/2;i++){ HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,0); //MS low: SPI Select device HAL_SPI_Transmit(&hspi3,(uint8_t *)®[i],1,1000); //Send config register HAL_GPIO_WritePin
-
Thread
Esp32 usb host
may be in PROGMEM, so copy them to RAM for printf char s1[32], s2[64]; strncpy_P(s1, type, sizeof(s1)); s1[sizeof(s1)-1]=0; strncpy_P(s2, string, sizeof(s2)); s2[sizeof(s2)-1]=0; Serial.printf("METADATA(%s) '%s' = '%s'\n", ptr, s1, s2); Serial.flush(); } // Called when there's
string may be in PROGMEM, so copy it to RAM for printf char s1[64]; strncpy_P(s1, string, sizeof(s1)); s1[sizeof(s1)-1]=0; Serial.printf("STATUS(%s) '%d' = '%s'\n", ptr, code, s1); Serial.flush(); } void setup() { Serial.begin(115200); delay(1000); Serial.println("Connecting
-
Thread
STM32 UART HAL
Timeout in ms uint8_t mystring[] = "Hello World!"; HAL_UART_Transmit(&huart2, &mystring, sizeof(mystring), TIMEOUT); [/c] HAL_UART_Transmit ist blockierend, und wartet max. TIMEOUT ms.
-
Thread
C Array copy by reference
uint8_t(*)[2])grosses_array); puts(""); uint8_t test[][2] = {{1,2},{3,4},{5,6}}; example2d(sizeof(test)/sizeof(*test),sizeof(*test)/sizeof(**test),test); } [/c] https://repl.it/repls/MeanLumberingWorker
kleines_array = (kleines_array_p_t)&grosses_array[8]; void example(kleines_array_p_t e) { printf("sizeof(*e) = %I64u\n", sizeof(*e)); for(int i=0; i<sizeof(*e); i++) printf("e[%d] = %d\n",i,(int)(*e)[i]); } int main() { printf("sizeof(*kleines_array) = %I64u\n", sizeof(*kleines_array))
-
Thread
C-Variablen nur vorübergehend?
beschreibst, ist, wie schon erwähnt wurde, malloc() gedacht: [C] uint16_t* werte = malloc(64 * sizeof *werte); [/C] Dann kannst du über diesen Zeiger dein Array benutzen, auch über Funktionsgrenzen hinweg. Und wenn du fertig bist, machst du: [C] free(werte); [/C] Jörg W. schrieb im Beitrag
-
Thread
C - warning: incompatible integer to pointer conversion assigning to 'void *' from 'int' [-Wint-conv
Zeiger-Typen, damit die armen C-Programmierer nicht ständig casten müssen (ala "int* f = (int*) malloc (sizeof(int));"). In C++ schreibt man halt einfach "new int".
> damit die armen C-Programmierer nicht ständig casten müssen (ala "int* f > = (int*) malloc (sizeof(int));"). In C++ schreibt man halt einfach "new > int". Oh, okay. Ich habe bei malloc() immer gecastet... hat immer funktioniert ;-)
-
Thread
Samplefrequenz, welchen Denkfehler mache ich?
bleibt Audiopuffer[(i*4)-4] = (sinus[ ( (k + (sizeof(sinus)/8)) % (sizeof(sinus)/2) ) ] - 32768); Audiopuffer[(i*4)-3] = 0; Audiopuffer[(i*4)-2] = (sinus[k] - 32768); Audiopuffer[(i*4)-1] = 0; k++; k %= (sizeof(sinus
(Siehe 2tes Bild, hier 20ms pro Diverse, beim ersten waren es 10ms/Div). Wenn ich das k modulo (sizeof(sinus)/4) nehme, kommt nur der halbe Sinus raus, und wenn ich modulo (sizeof(sinus) nehme, kommt eine Hälfte der Ausgabe eine ganze Schwingung und nochmal solange "Rauschen", naja hinter dem Sinus
-
Thread
32F746Disco, SW4STM32, kompiliert, nach kleiner Änderung aber nicht.
loop */ /* USER CODE BEGIN WHILE */ while (1) { Lesekopf = j; j++; j %= sizeof(Ringpuffer); i = 0; while( i < sizeof(Ringpuffer) ) { if( (Farbflags & (1 << Rot_run)) != 0) { if ( (Farbflags & (1 << Rot_dir)) == 0)
Textpuffer[i] = Ringpuffer[Lesekopf]; i++; Lesekopf++; Lesekopf %= sizeof(Ringpuffer); } BSP_LCD_DisplayStringAtLine (0, &Textpuffer[0]); HAL_Delay (k); } /* USER CODE END WHILE */ [/c]
-
Thread
ESP8266 startet ständig neu
ICACHE_FLASH_ATTR user_pre_init(void) { if(!system_partition_table_regist(at_partition_table, sizeof(at_partition_table)/sizeof(at_partition_table[0]),SPI_FLASH_SIZE_MAP)) { os_printf("system_partition_table_regist fail\r\n"); while(1); } } extern "C" void ICACHE_FLASH_ATTR user_init
-
Thread
Serial.print() eines uint8_t gibt 4 Bytes aus?!
offensichtlich? Danke! edit: [c] for (uint8_t n = 0; n < 15; n++) { snprintf(printbuf, sizeof(printbuf), "%u: %x", n, packet.buffer[n]); Serial.println(printbuf); } [/c] Gibt übrigens folgendes aus: 0: 54 1: 30 2: ffbc 3: 77 4: 14 5: 73 6: ff90 7: ff84 8: 24 9: ffdc 10: 41
-
Thread
Struktur von Konfigurationsdaten im EEPROM, erweiterbar machen
Sicherheit kannst Du noch in einem weiteren (am besten dem zweiten) Strukturelement das Ergebnis eines sizeof der jeweiligen Strukturdefinition unterbringen. Beim Lesen der Struktur musst Du, sofern Du auf später hinzugekommene Elemente zugreifen willst, halt die Versionskennung/Strukturgröße prüfen.
-
Thread
Projekt wird trotz Parser-Fehlern compiliert. Warum?
required from here /usr/include/c++/8.2.1/bits/unique_ptr.h:79:16: error: invalid application of 'sizeof' to incomplete type 'Ui::MainWindow' static_assert(sizeof(_Tp)>0, ^~~~~~~~~~~ [/code] wie erwartet. Was man aber machen kann, ist einen Destruktor deklarieren und im cpp
from here > /usr/include/c++/8.2.1/bits/unique_ptr.h:79:16: error: invalid > application of 'sizeof' to incomplete type 'Ui::MainWindow' > static_assert(sizeof(_Tp)>0, > ^~~~~~~~~~~ > > wie erwartet. > > Was man aber machen kann, ist einen Destruktor deklarieren und im cpp
-
Thread
c++: Lookup-Table Inhalt zur Compilezeit erstellen
template < typename ... Ts > struct table< std::tuple< Ts... > > { static const int content[ sizeof ...(Ts) ]; }; template < typename ... Ts > const int table< std::tuple< Ts... > >::content[ sizeof ...(Ts) ] = { fkt< Ts >::result... }; template < int I > using int_c = std::integral_constant
template< typename > class F > struct table< std::tuple< Ts... >, F > { static const int content[ sizeof ...(Ts) ]; }; template < typename ... Ts, template< typename > class F > const int table< std::tuple< Ts... >, F >::content[ sizeof ...(Ts) ] = { F< Ts >::result... }; [/c] Und zu guter
-
Thread
C++, Einen Methoden-Dispatcher zur Kompilezeit erzeugen?
die einen Parameter std::index_sequence<I...> hat. Das Argument dazu ist std::index_sequence_for<sizeof...T> (wenn T ein Parameter-Pack ist) oder in deinem Fall wohl eher make_index_sequence<tuple_size<parameter_types_t>::value>{}. In der Hilfs-Templatefunktion kann man dann z.B mit parameter[I]..
-
Thread
int Array abschneiden
zitter_ned_aso schrieb im Beitrag #5716401: > uint16_t* my_array = malloc(sizeof(uint16_t)); Korrektur: uint16_t* my_array = malloc(sizeof(uint16_t)*NEUE_ARRAY_GROESSE);
int value=array[i]; printf("wert=%i\n",value); } } [/c] Die Verwerndung von sizeof(), strlen() und strcat() könnte hier nützlich sein.
-
Thread
Speicher/Array kommt durcheinander/wird überschrieben ?
(wert_min): %u\n", array_min(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer); sprintf(buffer, "\tarray_max(wert_min): %u\n", array_max(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer); sprintf(buffer, "\tarray_avg(wert_min): %u\n\n",array_avg(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer); sprintf(buffer, "\tarray_min(wert_max): %u\n", array_min(wert_max,(sizeof(wert_max) / sizeof(wert_max[0]))));uart_puts(buffer);
-
Thread
ST: CCM, DTCM, ITCM
itcm)); PROVIDE (itcm_load_start = LOADADDR(.itcm)); PROVIDE (itcm_load_end = LOADADDR(.itcm) + SIZEOF(.itcm)); ... [/code] Und dann Ganz wichtig, bevor irgend ein code aus dem ITCM ausgeführt wird, am besten direkt im Reset Handler 1. ITCM aktivieren (falls notwendig) 2. [code] extern
-
Thread
C - Function / Define / Macro / Obfuscated C ?
Zeilen im bzip2 Code gefunden: > > [c] > static > int bz_config_ok ( void ) > { > if (sizeof(int) != 4) return 0; > if (sizeof(short) != 2) return 0; > if (sizeof(char) != 1) return 0; > return; > } > [/c] > > Bei Optimierung auf Codegröße(/O1) oder Schnelligkeit (/O2)
sizeof(int) ergibt 0 statt 4!
-
Thread
Größe einer char wird überschritten?
// Change 'SS' to your Slave Select pin, if you arn't using the default pin if (ether.begin(sizeof Ethernet::buffer, mymac, 8) == 0) Serial.println(F("Failed to access Ethernet controller")); ether.staticSetup(myip); dht.begin(); pinMode(5,OUTPUT); pinMode(6,OUTPUT); pinMode(
initialize_ethernet(void){ for(;;){ // keep trying until you succeed if (ether.begin(sizeof Ethernet::buffer, mymac, ethCSpin) == 0){ Serial.println( "Failed to access Ethernet controller"); digitalWrite(7, LOW);digitalWrite(4, LOW); continue; }
-
Thread
ESP8266 - Error Nachricht beim Start
ICACHE_FLASH_ATTR user_pre_init(void) { if(!system_partition_table_regist(partition_table, sizeof(partition_table)/sizeof(partition_table[0]),SPI_FLASH_SIZE_MAP)) { os_printf("system_partition_table_regist fail\r\n"); while(1); } } void ICACHE_FLASH_ATTR user_init(void) { }
undeclared (first use in this function) if(!system_partition_table_regist(at_partition_table, sizeof(at_partition_table) / sizeof(at_partition_table[0]), SPI_FLASH_SIZE_MAP)){ [/c] Wo ist denn das #define von dieser Konstante?
-
Thread
pragma pack(1) funktioniert nicht
Hallo sizeof(DC) liefert mir unter gcc auf einem ARM LPC1768 compiliert eine Länge von 70 Byte. Bisher waren es 62 Byte. GNU Tools ARM Embedded\7 2017-q4-major [c] DataPacket.DataLen = sizeof(DC); #
Compilieren folgende Warnung: "../Controller/devinfo.h(383): warning: empty declaration" und die sizeof liefert immer noch 70 Byte. >Aber ist natürlich auf einer 32-Bit-Maschine eine blöde Idee, die >verschiedenen Elemente in so einer Form zu mischen. Irgendwer muss dann >hingehen, und CpuClockRate
-
Thread
ISR-Rücksprungadresse feststellen
nicht. Die main sieht folgendermaßen aus: [c] int main(void) { memcpy(&sa, &SaveArea, sizeof sa); initErrorLED(); initWatchdog(WDTO_2S); initializeUART(); set_sleep_mode(SLEEP_MODE_IDLE); sei(); ... assert(!memcmp(&SaveArea, &sa, sizeof sa));
with text uart_puts_P(PSTR("Text: ")); uart_gets(SaveArea.stack, sizeof SaveArea.stack, '\r', 1); printHeadline(); break; case '*': // clear saveArea memset(&SaveArea, 0, sizeof SaveArea);
-
Thread
Serielle Kommunikation zwischen PC(Windows) und µC (STM32)
cout << "Data received." << endl; do{ readStatus = ReadFile(hComm, &TempChar, sizeof(TempChar), &NoBytesRead, 0); SerialBuffer += TempChar; // add tempchar to the string }while (NoBytesRead > 0); SerialBuffer.pop_back(); // Delete last sign in buffer, otherwise one "
-
Thread
Rust - ist das hier um zu bleiben?
Ich lese mir gerade das Rust Tutorial durch: https://doc.rust-lang.org/rust-by-example/index.html Das ganze hört sich ganz nett an, und ich überlege mir, ob ich von C nach Rust wechseln soll. Was mich aber noch etwas zurück hält: Wenn ich ein c99 oder c11 konformes Programm schreibe, dann weiss ich, dass es in 10 Jahren immer noch zahlreiche freie Compiler geben wird, die das problemlos übersetzen können, und das immer noch alles wichtige in C geschrieben ist, und das die Sprache inzwischen nicht gros verhunzt wurde. Aber in Rust gibt es momentan nur den einen Compiler und es ist
-
Thread
stm32 HAL UART Receive_IT(.) sendet nur 1 Byte
strlen zaehlen, bis im Speicher irgendwann mal eine 0 steht. Willst du das? Oder wolltest du eher sizeof nehmen? [c] #include <iostream> #include <string.h> using namespace std; char docklight[10]; int main(void) { cout << "strlen is: " << strlen(docklight) << endl; cout << "sizeof is: " << sizeof(docklight) << endl; return 0; } [/c] [pre] $ c++ -Wall -Wextra -o main main.cpp && ./main strlen is: 0 sizeof is: 10 [/pre]
-
Thread
C: Alternative zu switch case "mit Lücken"
des Codeblocks der switch... case Anweisung ins RAM, oder? Die struct wäre im RAM. Dann würde 10*sizeof(cmd) zusätzlich verbraucht. Wolfgang schrieb im Beitrag #5697639: > Es kommt drauf an, ob Effizienz, Codegröße, Speicherbedarf, > Schreibaufwand beim Programmieren, Lesbarkeit des Quellcodes oder
-
Thread
stm32 Hal Bibliothek Transmit via Interrupt
docklight,10); if(a == 1){ a = 0; HAL_UART_Transmit(&huart3,(int)&docklight,sizeof(docklight)/4,10); } } In der ISR: extern a; extern docklight; void USART3_IRQHandler(void) { /* USER CODE BEGIN USART3_IRQn 0 */ a = 1; //if(TIM2->CCR1 == 2048) TIM2->CCR1
-
Thread
Arduino Compiler Speicherverwaltung
char init937[5] = { 1,2,3,4,5}; // anonymes statisches Array char var[5]; memcpy(var, init937, sizeof(init937)); [/c]
-
Thread
Typkonvertierung
int do_fft(int* daten,int points) { Complex *f_arr; f_arr=(Complex*)malloc((points+1)*sizeof(Complex)); if(f_arr==NULL) { cerr << "Kein Ram vorhanden"<<endl; exit(1); } int i=0; //Float Werte erzeugen for(i=0;i<points;i++) {
Michael schrieb im Beitrag #5690064: > f_arr=(Complex*)malloc((points+1)*sizeof(Complex)); Du verwendest C++. Was soll da /malloc/? [c] f_arr = new Complex[points + 1]; [/c] Michael schrieb im Beitrag #5690064: > const Complex test[] = { 1.0, 1.0, 1.0, 1.0, 0.0, 0.0