-
Thread
I2C Fehler beim anzeigen.
(0x05); i2c_write(0x03); i2c_stop(); uart_puts( dtostrf( Stunden, 1,0,string ) ); uart_puts(":"); uart_puts( dtostrf( Minuten, 1,0,string ) ); uart_puts(";"); zur Anzeige nutze ich HTERM
(); i2c_start(); i2c_write(RV3029_lesen); Minuten = i2c_read(1); Stunden = i2c_read(0); i2c_stop(); uart_puts( dtostrf( Stunden, 1,0,string ) ); //Senden an USART uart_puts(":");
-
Thread
uart raspberry pi, warum neuer pointer zum senden?
Stefanus F. schrieb im Beitrag #5979882: > Funktions-Argumente sind in C immer "by value" (eine Kopie). Trifft bei Pascal zu, aber nicht bei C! Funktions-Argumente von Arrays, Strukturen und Strings sind in C immer "called by reference" .
Stefanus F. schrieb im Beitrag #5979884: > char* TX_BUFFER="Raspberry Pi"; Bei C++ mit dem Typ *string* anstelle von char* funktioniert es auch. [c] string tx_buffer = "Raspberry Pi"; [/c] https://www.w3schools.com/cpp/cpp_strings.asp
-
Thread
aus string '.' heraustrennen
für normale C-Strings kannst du memmove() benutzen: [C] char x[] = "10.10"; memmove(x + 2, x + 2 + 1, strlen(x) - 2 - 1 + 1); [/C] Dabei stehen die Zweien für die 2 aus deinem erase(), die Einsen für die
Falls du die Position des '.' nicht kennst.. [C] char *pp = strchr(x, '.'); if(pp != NULL) memmove(pp, &pp[1], strlen(pp)); [/C]
-
Thread
Textausgabe lcd c
verwenden. Die Füllzeichen kann man im Prinzip frei wählen nachdem man den Puffer gefüllt hat. [C] { char puffer[8]; memset(puffer, 0, 8); // #include <string.h> erforderlich strncpy(puffer, "test1", 8); // #include <string.h> erforderlich // hier ggf. Nullbytes durch Füllzeichen ersetzen displ_print(puffer); } [/C] Siehe auch [[String-Verarbeitung in C]]
-
Thread
USART_Transmit fehler
lang ist? Wenn der Messert 5 ist, dann ist der String auch nur 1 Zeichen lang! ALs ersts schreibst du dir jetzt erst mal eine Hilfsfunktion, die einen String ausgeben kann [C] void USART_Transmit_String( char* s ) { while( *s != '\0' ) {
Sonst siehts du am Terminal im Zahlenwust nicht wo eine Zahl aufhört und wo die nächste anfängt [C] ... char Werte[10]; while(1){ int i = ADC_Read(0); itoa( i, Werte, 10 ); USART_Transmit_String( Werte ); USART_Transmit( ' ' ); } } [/C] und achte ein bischen
-
Thread
Problem mit dem Umwandeln von einem Char-Array in Char-String AtMega128
="ok"; USART_Transmit_String("empfangen"); USART_Transmit_String(einlesen); s=0; } } } [/c]
") == 0) einlesen[5]="ok"; USART_Transmit_String("empfangen"); USART_Transmit_String(einlesen); s=0; } } } [/c]
-
Thread
BASH -Code auf Linux Mint ausführen, brauche bitte Hilfe
Moin, - ich habe eine aktuelle Debian-Maschine aufgesetzt, xmllint und strings installiert. Dann all_set.FR4 in ALL_SET.FR4 umgenannt. [c] BASH_VERSION='5.1.4(1)-release' [/c] Einmal ausprobieren: [c] tom@xml:/tmp/abc/prg$ ./FR_extract_sets_from_set_all.sh -:2:
Moin, - wenn man das Programm anguckt, ist ein Magic-String einprogrammiert: [c] SET_BINARY_HEADER="\\xEF\\xBB\\xBF\\x00\\x00\\x03\\x28" [/c] Wenn man die set_all.fr4-Datei anguckt: [c] 000000 ef bb bf 00 00 08 2f 3c 3f 78 6d 6c 20 76 65 72 >......
-
Thread
Teile eines Strings in Integer umwandeln
Parameter Identifier, hier Kühlertemperatur "43" ist der tatsächliche Wert: 4*16 + 3 = 67, jetzt noch 40°C abziehen und dann ist die Kühlertemperatur von 27°C berechnet (ist auch korrekt so ;-)) Im Programm selbst habe ich den String als char* vorliegen, habe schon mit sprintf und sscanf versucht, der
inbuffer[7]; > > scheint das zu sein, was du suchst. Oder wenn das Hex Zahlen sein sollen: [C] void atohex( char c ) { if( c >= '0' && c <= '9' ) return c - '0'; if( c >= 'A' && c <= 'F' ) return c - 'A' + 10; return 0; } .... tmp_CoolantTemp = atohex( inbuffer
-
Thread
Problem mit UART RX und Atmega32
nextChar != '\n' && nextChar != '\r' && uart_str_count < UART_MAXSTRLEN - 1 ) { uart_string[uart_str_count] = nextChar; uart_str_count++; } else { uart_string[uart_str_count] = '\0'; uart_str_count = 0; uart_str_complete = 1; } } } [/c
geht und auch der Atmega wieder läuft. Verkabelt habe ich jetzt so: MAX PIN 1 -> "+Pol ELKO (C2)" -> "-Pol ELKO (C2)" -> MAX PIN 3 MAX PIN 2 -> "+Pol ELKO (C4)" -> "-Pol ELKO (C4)" -> +5V MAX PIN 4 -> "+Pol ELKO (C3)" -> "-Pol ELKO (C3)" -> MAX PIN 5 MAX PIN 6 -> "-Pol ELKO (C5)" -> "+Pol ELKO
-
Thread
Zeichen im String zählen
herausfindet, wie viele Werte in einer Datei stehen. Dafür hab ich mir überlegt, das ich die Datei in einen String lade, um anschließend die Anzahl des Zeichens ";" zu zählen. Denn nach jedem Wert folgt ein Semikolon. Das Programm benötige ich in C. Kann mir jemand helfen? Danke. Carola
Rückkehrcode von fread() nicht ausgewertet. Die lehrbuchmäßige Version einer derartigen Schleife wäre: [c] int c; while ((c = getc()) != EOF) { if (c ... ) ... } [/c]
-
Thread
String Anfangswert zuweisen
8) DDRH |= (1<<PH5); //OCR4C auf Ausgang uart_init(); // USART initialisieren sei(); while (1) { char tmp[5]; strcpy ( tmp, uart_string); uint16_t x = atoi( tmp ); OCR4C = x;
der String empfangen wurde, wird er in eine Zahl umgewandelt. Andreas H. schrieb im Beitrag #2316578: [c] volatile uint16_t x; : { uint16_t x = atoi( tmp ); OCR4C = x; } : itoa
-
Thread
LCD KS0073 am AVRATMega128
|= (1<<LCD_EN); asm("nop"); LCD_CONTROL &= ~(1<<LCD_EN); lcd_busy(); } void lcd_string (unsigned char *string) { while (*string) lcd_char (*string++); } void lcd_init(void) { delay(20); LCD_CONTROL_DIR |=((1<<LCD_RW)|(1<<LCD_EN)|(1<<LCD_RS)); //Ausgänge
LCD_CONTROL|= (1<<LCD_EN); asm("nop"); LCD_CONTROL &= ~(1<<LCD_EN); lcd_busy(); } void lcd_string (unsigned char *string) { while (*string) lcd_char (*string++); } void lcd_init(void) { delay(20); LCD_CONTROL_DIR |=((1<<LCD_RW)|(1<<LCD_EN)|(1<<LCD_RS)); //Ausgänge
-
Thread
Printf-Lib im GCC-Tutorial
nicht begriffen hast. ;-) Hmm, ich müsste dich jetzt allerdings in den Kurs ,,Grundlagen von ANSI-C (ISO-C 1990)'' zurückschicken, zum Stichwort string literal concetanation. Du versuchst, ohne dass du dieses Feature von C verstanden hast, es mit trial&error zu benutzen. Das geht nicht gut.
Was auch immer Du da gefunden haben magst, C ist das nicht. Strinverkettung mit "+" ist Java/JavaScript oder -je nach Implementierung der Klasse "string"- C++.
-
Thread
Send response (Action *Var)
Statement nun mal nur mit integralen Datentypen umgehen kann und nicht mit Zeichenketten (zumindest in C). Und um nochmal Lothar zu zitieren: Lothar M. schrieb im Beitrag #4426719: > Dann solltest du dir ansehen, wie in C aus einzelnen Chars dann > komplette Strings zusammengebaut und wie die dann
0. "uint8_t" ist normalerweise das selbe wie "unsigned char", wärend ein Zeichen eines c-string den Type "char" mit unbekannter signedness hat. Der C-String selbst hat dann den Typ "char[n]" oder "char*". Ein "unsigned char" ist gleichgross wie ein "char" und somit meistens gleich gross
-
Thread
Textersetzung innerhalb eines String
MAXSPEED_S ">")); [/c] Aber da muss ich natürlich die #defines jeweils als int/String haben. Geht das irgendwie einfacher? Gruß und schönen Sonntag
MAXSPEED_S XSTRINGIFY(MAXSPEED)[/c] Die zwei Ebenen sind deshalb nötig, weil Du am Ende den String "512" haben willst und nicht den String "MAXSPEED".
-
Thread
Variablen ins ROM speichern C18
das sollte mit memcpyram2pgm eigentlich gehen. Ich habe jedenfalls schon oft folgendes genutzt, um Strings aus dem Flash ins Data Memory zu kopieren: [c] unsigned char data_text[25]; // data memory rom unsigned char rom_text[] = "meintext"; strcpypgm2ram ((char*)&data_text, (const far rom char*) rom_text); [/c] Gruss, Dirk
-
Thread
LCD per 4-bit ansteuern mit C
speicherstelle = speicherstelle + 64; lcd_write_ctrl(speicherstelle); } void lcd_text(char string[]){ laenge = strlen(string); for(i = 0; i < laenge; i++){ lcd_write_data(string[i]); } }[/c] Seltsamerweise erscheinen nur in der zweiten Zeile seltsame Zeichen
speicherstelle.F7 = 1; lcd_write_ctrl(speicherstelle); } void lcd_text(char string[]){ laenge = strlen(string); for(i = 0; i < laenge; i++){ lcd_write_data(string[i]); } }[/c] Sebastian
-
Thread
Anfänger: Hilfer, Stack underflow Problem
0 ; Stringkonstante, durch eine 0 ; abgeschlossen lcd_flash_string: push temp lcd_flash_string_1: lpm temp, Z+ cpi temp,0 breq lcd_flash_string_2 out PORTB,temp rjmp lcd_flash_string
rjmp lcd_flash_string lcd_out_text2: ldi ZL, low(2*text2) ldi ZH, low(2*text2) rjmp lcd_flash_string lcd_out_text3: ldi ZL, low(2*text3) ldi ZH, low(2*text3) rjmp lcd_flash_string lcd_out_text4
-
Thread
Komisches Zeichen wird im LCD angezeigt. Durch zusammenfügen von 2 Strings?
[c] char hzString[] = ""; itoa(HzInNumber, hzString, 10); [/c] Wie groß ist hzString?
[pre]char *hz = malloc(strlen(hzString) + strlen(secondary)); [/pre] Das wird nicht reichen. Nimm dir mal ein C-Grundlagenbuch und guck dir an, wie in C die Länge eines Strings gespeichert wird.
-
Thread
MEGA8 ADC Interrupt beeinflusst TWI Interrupt
starten // Die Ausgabemarke in die 2te Zeile setzen lcd_setcursor( 0, 1 ); lcd_string(">Booting..."); lcd_setcursor( 0, 2 ); itoa (SLAVE_ADRESSE,text,16); lcd_string("I2C Adress=0x"); lcd_string(text); for (int Index=0; Index<85; ++Index) {
adc_value = ADCW; //Store ADC value itoa (adc_value,text,16); lcd_setcursor( 0,4 ); lcd_string(text); for (int Index=0; Index<85; ++Index) { txbuffer[Index] = rxbuffer[Index]; } uint16_t brightness_i2c=0; uint16_t contrast_i2c=0; brightness_i2c=(rxbuffer[81
-
Thread
Verständnisfrage zu "volatile"
die Funktion uart_putInt macht folgendes: int uart_putInt(uint8_t i, bool newLine) { char stringNumber[3]; itoa(i, stringNumber, 10 ); uart_putString (stringNumber, newLine); return 0; } Falls ich die 100+ entferne - dann kommen nur "1" Werte (wie erwartet) Danke!
: > Kann es sein, dass itoa im Inneren die Variable überschreibt statt > kopiert? Nein. Denn C kennt nur Call by Value. Aber es kann ub geben, wenn Strings zu klein bemessen sind.
-
Thread
Hex to ASCII
Hallo, habe mein *gutes* C-Buch grade nicht dabei. Ich suche eine Funktion die analog zu ultoa eine unsigned Long int in einen ASCII-String verwandelt. Also [c] unsigned long int Zahl = 1000; // 1000 dez = 0x03E8 char my_string[10]; hextoa(Zahl,my_string,10); [/c] soll dann als Ausgabe in my_string *0x000003E8* ergeben.
-
Thread
Atmega 128 reset bei Interrupt
// return the character from UDR to the caller } /** * This function sends a string to the UART */ void sendStringRS232(char *s){ while (*s){ // sends until s is 0 sendRS232(*s); s++; } } [/c] [c]/** * * Project:
tipp mal auf USART1_RX_vect :D Nicht schlecht für die Uhrzeit ;) Aber noch was ganz übles: [c] ISR (USART_RXC_vect) { //sendStringRS232("Interrupt"); sendStringRS232(UDR1); PORTC = 0xff; } [/c] Nimm das sendString...() da raus. Man ruft Funktionen nicht ungestraft in
-
Thread
Probleme mit String der HEX-Zahlen senden soll
Die Baudrate beträgt 38400. Ich habe es versucht mit putc(0x**), das dauert zu lange. printf("%c%c....",byte[0],byte[1]....); dauerte auch zu lange Gibt es einen Trick aus den einzelnen HEX-Zahlen einen String zu bilden um diesen dann zu senden? Über Tipps wäre ich sehr dankbar. Gruss Joachim
sende es - und wenn der Buffer wieder frei ist, sende ich das nächste. Da wird kein String gebastelt. OK - es soll in C sein - dann hat man evtl. ein Zeitproblem ! (Weil man ja nicht weiß, was der C-Compiler so alles reincompiliert.) Ich würde dem C-Compiler alle Zeit (in 20ms!) lassen
-
Thread
Frage/Problem Datentyp Arduino Nano
ist > lieber, wenn man direkt sehen kann, was da passiert. Das ist doch kein echtes Argument. [c] const char *kette = "Eierkuchen"; String feld[3]; feld[0] = (String)kette; feld[1] = String(kette); feld[2] = kette; for(auto &s:feld) Serial.println(s); [/c] Es bleibt
bekommen. Seit dem benutze ich die String Klasse dort nicht mehr. Mit den c Zeichenketten bin ich besser vertraut.
-
Thread
Integer in char array über UART senden
funktionieren. Meine Frage: Kann ich meine in char gewandelte Drehzahl einfacher in den großen String basteln? Hier ein Beispiel was ich vorhabe: String[10] // String der übermittelt wird aaaa[4] // String der meine Drehzahl enthält String[0] = 'V'; String[1] = ','; String[2] = aaaa[0]; String[3] = aaaa[1]; String[4] = aaaa[2]; String[5] = aaaa[3]; String[6] = ','; String[7] = bbbb[0] und so weiter... Das artet aber bei sehr großen Strings in eine rießige Schreibarbeit aus.
-
Thread
LCD zeigt nur die Hälfte an
WOW, DANKE LARS. Super Idee. Mein Code Schaut so aus: [c] /* String auf Display anzeigen */ lcd_puts("Willkomm"); /* String auf Display anzeigen */ lcd_puts("Willkommen"); lcd_puts("Willkommen"); lcd_puts("Willkommen"); lcd_puts("Wien"); [/c
// LC-Display löschen und Kursor auf Pos. 1 lcd_puts(cPuffer); // String am Display ausgeben[/c] So, Wrap hat funktioniert, danke. Mit den obigen Einstellung funktioniert alles so wie es soll :). spess53 schrieb: > Warum hast du die nachfolgenden
-
Thread
ARM-GCC: stderr
Namen > und stärkerer Bindung? Zumindest avr-gcc kann bei printf sehr aggresiv optimieren. Ein [c]printf("Hallo");[/c] führt bspw. dazu, dass kein dickes printf dazugelinkt wird sondern ein puts(), weil dieses auch einen konstanten String ausgeben kann. Wird wirklich ein printf benötigt stehen dem
konstantem String wird in fwrite und nicht in fprintf gesprungen. Und fwrite ist in printf.c gar nicht definiert. fwrite liegt in libg.a. Ob mir dieses Wissen irgendwie hilft?
-
Thread
string korrekt ansprechen
Zeichen bieten. Also: char sonstwas[9] = "00000000"; Das erste Element eines Arrays hat in C oder C++ immer den Index 0. Literaturhinweis: Kernighan & Ritchie, Programmieren in C, zweite Auflage, Hanser Verlag
Es ist durchaus ok, den String so zu initialisieren, wenn man das abschließende \0 nicht braucht. Das ist in C ausdrücklich so eralubt. Meistens braucht man das \0 aber. Am einfachsten ist es, die Größe einfach wegzulassen. Der
-
Thread
bitweise Daten auslesen und verarbeiten
16 Bits plus Nullterminator hieneinpassen. Jetzt musst Du nur noch die Funktion z.B. mit [c] char string1[17]; //.... itoa(data1, string1, 2); [/c] aufgerufen werden, und den Rest macht die Funktion für Dich.
Hallo, ich habe es jetzt einmal folgendermaßen probiert: [c] data11= ( RXData[0] << 8) | (RXData[1] & 0xE0) | ((RXData[1] & 0x07) << 2); data22= ( RXData[2] << 8) | (RXData[3] & 0xFE) >> 1; data1[14]='\0'; // String Terminator for(
-
Thread
zahl aus uart string ermitteln
> auch was, wo man die stelle mit angeben kann? Du kannst atoi doch auf jeden Startpunkt im String setzen. Einfach mit dem Plus Zeichen. Pointer sind doch Basiswissen in C. Nutze sie!
deutschesprache150.html Cyblord -. schrieb im Beitrag #6221322: > Du kannst atoi doch auf jeden Startpunkt im String setzen. Einfach mit > dem Plus Zeichen. Pointer sind doch Basiswissen in C. Nutze sie! dito +1 Felix schrieb im Beitrag #6221320: > strncmp(input, "aktor1", 6) wie wäre es mit strchr(
-
Thread
Volumenmessung mit ATmega8, einige wichtige Fragen
hat mit erklären nichts zu tun. Punkt 1 ******* Du brauchst Wissen, wie Stringverarbeitung in C funktioniert http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F Punkt 2 ******* Was ergibt 38 dividiert durch 10 38 / 10 -> 3 Und was ist
sollte, da es eben kein intuitiver Ausdruck ist. Intuitiv wäre (zumindest nach meiner Intuition): [c] while ((abfrage1 && abfrage2) == 0) ; [/c]
-
Thread
String links mit Zeichen auffüllen;
µC-Bastler schrieb im Beitrag #2674611: > Ein wohlformatierte Umwandlung in einen String hat in einer ISR nun > wirklich nichts zu suchen. Die Routine befindet sich auch nicht in einer ISR. Die ISR
void uitoa_self(uint32_t zahl, uint8_t str_length, char* string) { // uint32_t zahl : Von unsigned Integer in String umzuwandelnde Zahl // uint8_t str_length : gewünschte Stringlänge (incl. Füllzeichen links) // char* string :
-
Thread
Kritischen Pfad für den Datenspeicher herausfinden?
wollte das mitteilen. Bin nun aber durch weiteres ausprobieren darauf gekommen, dass es auf "lcd_string()" zurückzuführen ist, das aus der hier auf µC.net zu findenden lib verwendet wird: [code] void lcd_string( const char *data ) { while( *data != '\0' ) lcd_data( *data++ ); } [/code]
S. schrieb im Beitrag #3993802: > Der verwendete Speicher ist dabei proportional zur länge des Strings, Richtig. Die Zeile lcd_string("123456789"); braucht 10 Bytes RAM um der String zu speichern. Jede solche String im Code landet von Haus aus im RAM.
-
Thread
GSM SMS auslesen und auswerten
PC ja auch ohne funktioniert. Hier mal ausschnitte meines Codes Hier die UART funktionen [c] void WaitToCompleteReceive() { //clear Flag uart_rx_flag = false; //warte auf Taste oder auf Flag für String komplett empfangen while (uart_rx_flag == false); } // einen String
put_string("AT\r"); WaitToCompleteReceive(); } while(!strncmp(uart_rx_buffer,ATAntwort, 2) == 0); do { put_string("AT+CMGR=1\r"); WaitToCompleteReceive(); usw.... [/c] Ich hoffe die
-
Thread
TWI ACK/NACK Problem
#2495321: >> Es ist eigentlich wieder eine uhralte Glaubensfrage: Pascal arbeitet mit >> Längenbyte und C mit Stopzeichen. > > Der Unterschied ist nur, dass Pascal beliebige Zeichen übertragen kann, > C nicht. Bei jedem 0x00 geht C von einem Stringende aus. Also String sind in C keine beliebigen Daten
Tach : Also String sind in C keine beliebigen Daten, sondern Text. Und in einem Text kommen selten 0x00 Bytes vor. Wieso sollte man Nullbytes als Nutzdaten in einen String packen wollen? Das macht überhaupt keinen
-
Thread
Was bedeutet "%c" ?
Guck dir einfach mal die String-Formatierungsmakros in einem C-Buch an.
sollte man auszugebende Zeichen auch im Code als Zeichenkonstanten (oder eben als Zeichen in einem String) schreiben, und für Steuerzeichen wie Newlines die von C dafür vorgesehenen Escapesequenzen verwenden. Das sorgt für bessere Portabilität, und nebenbei erhöht es auch noch die Lesbarkeit. Andreas
-
Thread
Oled Display W202-XDLG via SPI an Arduino Uno
(12,11,13,10); rs.begin(16,2,1); } void loop(){ rs.clearBuf(); rs.drawString(10,0,"F",1,1,1); rs.drawString(15,0,"a",1,1,1); rs.drawString(20,0,"l",1,1,1); rs.drawString(25,0,"t",1,1,1); rs.drawString(30,0,"p",1,1,1); rs.drawString(35,0,"c",1,1,1); rs.displayBuf
int8_t x, int8_t y, int8_t w, int8_t h, uint8_t color); void drawChar(int x, int y, unsigned char c, uint8_t color, uint8_t bg, uint8_t size); void drawString(int x, int y, const char * cstring, uint8_t color, uint8_t bg, uint8_t text_size); void drawInteger(int x, int y, int data, uint8_t color
-
Thread
C Konstanten mit Inline Assembler verwenden
Hi da jedes C-File erstmal durch den Präprozessor geht sollte das kein Problem sein. Matthias
Nu ja, Vorsicht. Klar geht jedes C-File durch den Präprozessor, aber innerhalb von Strings finden natürlich keine Ersetzungen statt. Inline-asm-Anweisungen sind aber erstmal Strings. Aber als Operand zu einer inline-asm-Anweisung
-
Thread
Arduino: Arduino startet mitten im Code neu
Solange Du beim Senden nicht mehr als 128 Byte angibts, ist alles gut. Entweder definierst Du [c] char text[128]; [/c] und schreibst dazu passend [c] text[127]='\0'; [/c]
Exakt was DirkZ gesagt hat. Und gleiches für folgendes: [c] destination[4]='\0'; type[2]='\0' [/c] Du vereinbarst mit [c] char type[2]= {0}; [/c] eine Array aus 2 Chars. Auf das erste Element greifst du mit dem Index 0 zu auf das zweite
-
Thread
String-Variablen zusammensetzen
buffer); lcd_puts(buffer); [/code] Jetzt meine Frage: kann ich das auch erst zu nem kompletten String zusammenführen und dann komplett zum LCD übertragen? Weitere Frage: ich hab jetzt ein Zeitformat von z.B. " 1: 3:54" Gibt es einen Befehl in C, mit der ich 2 Stellen incl führender Null erzeugen
itoa() vielleicht? http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#ga4f6b3dd51c1f8519d5b8fce1dbf7a665
-
Thread
LCD Variableninhalt ausgeben, itoa()
Empfang1){ PORTC = ~a; Empfang1 = 0; } if(Empfang2){ lcd_string(az); Empfang2 = 0; } } } [/c] Danke über die Infos zur Formatierung.
1. würde ich mir mal ein C-Buch nehmen und den Unterschied zwischen einem Zeichen und einem String (in C üblicherweise nullterminiert) herausfinden 2. gibt es in deinen LCD-Routinen eine Funktion lcd_data(), die
-
Thread
I2C-LCD von sainsmart - keine Anzeige
[c] #include <stdbool.h> #include <stdint.h> #include <avr/pgmspace.h> #include "main.h" #include <util/delay.h> #include "i2clcd.h" #include "i2cmaster.h" char string_flash[] PROGMEM = "Hello Flash!"; int main(void) { char string1[] = "Hello World!"; i2c_init(); lcd_init(); lcd_light(true); lcd_print(string1); lcd_nextline(); lcd_print_P(PSTR("I2CLCD V0.11")); // always set all three parameters
-
Thread
warum werden bei uart immer char gesendet/empfangen?
> Und char ist in C ein Datentyp für Byte Eben. Bis vor kurzem war es so dass "char" der einzige 8bit-Datentyp in C war. Seit UTF-16 kann man sich nicht mehr darauf verlassen dass "char" 8 Bit breit ist. Und heutzutage
0'; // prevent crash if called with base == 1 if (base < 2) base = 10; do { char c = n % base; n /= base; *--str = c < 10 ? c + '0' : c + 'A' - 10; } while(n); return write(str); } size_t Print::print(long n, int base) { if (base == 0) { return write
-
Thread
Compiler Warnung 'ultoa' differ in signedness
ultoa' differ in signedness" Ich konvertierte dabei ein uint32_t für die Ausgabe auf einem LCD: [c] lcd_setcursor(0,3); lcd_string("Zeit: "); ultoa( ulZeit, buffer1, 10 ); lcd_string( buffer1 ); [/c] die beiden Variablen sind so definitert: [c] unsigned char buffer1 [12]; uint32_t
differ in signedness zeit.c:796: warning: pointer targets in passing argument 1 of 'lcd_string' differ in signedness Danke.
-
Thread
Tut gelesen und trotzdem Problem mit Strings im Flash
(buffer)-58)) && ((c = pgm_read_byte(&pointer[index])) != '\0')) { *http_buffer++ = c; index++; } send_tcp_data (index, seq_no); return index; } [/C]
array[0], 0); http_data_out(HtmlTest, 0); while(1); } #else // Original Code aus main.c #endif [/C] Add: Mit der Zeile http_data_out(array[0], 0); hatte ich Probleme. Da stimmt noch was nicht mit der Verknotung der Pointer auf die Strings.
-
Thread
C-Code für Zähler mit INT, Ausgabe per UART streikt
machen musst. Paul schrieb im Beitrag #3487812: > UDR = "n"; Bei "n" handelt es sich um einen String, nicht um ein Zeichen. Einzelne Zeichen werden in C von Single Quotes umschlossen, also in etwa so: [c]UDR = 'c';[/c] Dein Fehler sollte auch zu einer Compilerwarnung führen, die in etwa lautet
, machst du die eine Funktion, die die zu einem int gehörende String-Repräsentierung bestimmt und dann den String ausgibt [c] void uart_puti( int i ) { char buffer[7]; itoa( i, buffer, 10 ); uart_puts( buffer ); } [/c] damit kannst du dann schreiben
-
Thread
Atmega8 mit ESP8266 hängt sich auf
Form einer Zahl an eine php sendet (.../test/haa/write.php?wert=1234567890123456). In der Funktion [c] TCP_Laenge() [/c] aus der esp8226.c gibt es eine For-Schleife. Wenn ich diese aktiviere, funktioniert das Senden. Nehme ich diese raus, sendet er genau einmal und das wars, bis irgendwann der Server
nichts anderes als etwas zeit zu verplempern, deswegen hab ich testweise in der Funktion aus main.c [c] Protokoll_senden() [/c] in Case 1 eine Wartschleife eingebaut. Leider ohne Erfolg. In weiteren Tests hab ich gesehen, das nach dem senden von "AT+CIPSEND=79\r\n" nichts weiter passiert. In dem
-
Thread
String als Parameter übergeben
irgendwo habe ich mal gehört, daß in C der String als Zeiger auf char implementiert ist. [c] void LCD_Print (char* string) {volatile uint8_t debugvar; debugvar = *string; // debugvar sollte jetzt 0x31 enthalten string++; debugvar = *string; // sollte jetzt 0x32 enthalten } [/c] Nun gibt es das Problem, das beim Aufruf LCD_Print("123") weder eine Fehlermeldung noch ein Code abgesetzt wird. Wahrscheinlich habe ich mehr als einen
-
Thread
Atmega8 + Uart + MK3
("\n PB = PortB alle Bits ON"); uartPutString("\n pb = PortB alle Bits OFF"); uartPutString("\n PC = PortC alle Bits ON"); uartPutString("\n pc = PortC alle Bits OFF"); uartPutString("\n PD = PortD alle Bits ON"); uartPutString("\n
(b,c,d)"); uartPutString("\n GX = get Port(B,C,D)"); uartPutString("\n Gx = get DDR(b,c,d)"); uartPutString("\n Ox = config Port(B,C,D) = OUT"); uartPutChar('\n'); for (int i=0;i<42;i++) uartPutChar