-
Thread
Uart Interrupt Problem
... ach so, und das [c] uart_str_complete=1; [/c] in der ISR ist trotzdem Mist. Es sorgt dafür, das in uart_string generell nur ein Leerstring steht.
auf: Du schneidest beim Empfang \r und auch \n ab, d.h. sie stehen nicht im Empfangspuffer uart_string. Beim Zurücksenden von uart_string vergisst du aber, diese Zeichen wieder zurückzusenden. Am einfachsten machst Du das in main durch: [c] uart_puts((char*)uart_string); uart_puts("\r
-
Thread
internen RC Osci syncronisieren
sends the data } void UART1_sendString (const char *string) { // Vergleich auf ASCII Zeichen '\0' (NUL) while (*string != 0x00) { // "String-Endezeichen" (Null-Terminator) UART1_sendChar(*string); // vorderstes Zeichen senden string++; } } void UART1_send_uint32(uint32_t zahl) { // convert eine long Zahl zu einem String char string[11]; ultoa(zahl, string, 10); // convert unsigned long to string, radix
-
Thread
Pointer, die 17324ste
[c] char *p_string = "ABCDE"; //printf ("%s\r\n",p_string); ergibt ABCDE *p_string++; //printf ("%s\r\n",p_string); ergibt BCDE p_string++; //printf ("%s\r\n
Ganz einfach: [c] *p_string++; [/c] ist die Kurzform für: [c] *p_string; p_string = p_string + sizeof(*p_string); [/c] und von [c] p_string = p_string + sizeof(*p_string); [/c] Das *p_string mit oder
-
Thread
String ausschliesslich im flash...
"Test2", "Test3", "Test4" }; bekomme aber dann jede menge warnings: lcdtest.c:15: warning: missing braces around initializer lcdtest.c:15: warning: (near initialization for `menu[0]') lcdtest.c:13: warning: unused variable `menu' <-- der ist klar die frage ist jetzt wäre
PGM_P menu[4] PROGMEM = { text1, text2, text3, text4 }; der compiler meckert weiter: lcdtest.c: In function `main': lcdtest.c:13: warning: `__progmem__' attribute ignored lcdtest.c:14: warning: `__progmem__' attribute ignored lcdtest.c:15: warning: `__progmem__' attribute ignored lcdtest.c
-
Thread
Namenskonventionen C++
oben genannten Processing Seite auf dem PC > kompatibel bekommst. Du willst also sagen, dass in C nicht die Funktionalität von C++ möglich ist. Einmalige Theorie!
Oliver S. schrieb im Beitrag #6495892: > Jetzt darfst du über noch einmal raten... [c]void TwoWire::begin(int sda, int scl)[/c]
-
Thread
Warum funktioniert 1 String unbekannter Länge so nicht?
eine Anzahl der Feldelemente *oder* eine explizite Definition. Also [C] unsigned char string1[] = "CRC-Test"; [/C] funktioniert immer...
In C etwa so: [C] char str[5]; strncpy(str, "ABCDEF12345"+2, 4) str[4] = '\0'; [/C] In C++: [C] std::string str; str = std::string("ABCDEF12345").substr(2, 4); [/C]
-
Thread
Rotary-Encoder mit Arduino als Konzentrator
to write their own strings and hash tables with little knowledge of the standard library beyond printf and memcpy. There are people who stick to a restricted subset of C++ for perfectly good reasons, but they (as far as I have
> aber was ich z.b. gewohnt bin, ist das ein > sprintf(x,"%10.3f",val) > in x einen druckbaren string liefert. > der arduino-compiler liefert aber einen scheiss. In deinem Fall ist der Fehler, dass du %f benutzt hast, obwohl es (in der von Dir verwendeten Version der C Library) nicht implementiert
-
Thread
Informationen aus String in Daten umwandeln
anschliessen! Wenn nicht, dann hat sich da ein nicht sichtbares Zeichen eingeschmuggelt. Das hier [C] rprintfStr(string); [/C] ist ein netter Versuch. Aber dich interessieren eben auch die nicht sichtbaren Zeichen [C] rprintfStr( "&" ); rprintfStr( string );
// einfach nur gesammelt string[f] = puffer; f++; return; } // Ein Return ist eingetroffen. Damit ist der String vollständig string[f] = '\0'; // erst mal einen sauberen C-String daraus machen rprintfStr
-
Thread
C String Literals aneinander hängen
Daher meine Idee: [c] const char[] text = "Base\0Settings\0Basis\0Einstellungen"; const char* txt[LANG_COUNT][TXT_COUNT] = ... // Pointer auf den Anfang der Strings [/c] Da ich für diesen Ansatz jedoch zur Compiletime
/ geraten, nicht gezählt int n = 1; // finde den n-ten String printf("%s",returnText(text,n,textLen)); [/c] Die Funktion returnText findet den n-ten String, die musst du halt schreiben.
-
Thread
ASCII String von Barcodemodul über UART an µC
Kann mir jmd helfen? warum nicht einfach mal eine LED einschalten wenn etwas empfangen wurde. [c] string[i]=UDR0; i++; porta = i; [/c] Vermutlich schickt der Leser am ende ein \n, damit kannst du prüfen ob etwas empfangen wurden.
=string[0]; // Hier den Breakpoint setzen } [/c] Anstatt jetzt die Pause-Taste zu drücken wird ein Breakpoint gesetzt. Auf magische Weise wandelt sich die das "unknow identifier" in den Wert. Warum
-
Thread
String in global char Array schreiben!?
angezeigt? Du kannst ja mal probieren, ganz einfach a) dir die Länge des Strings ausgeben lassen. Alles kleiner als 16 ist ok. b) einen mit Sicherheit "sauberen" String zuzuweisen [c] ... strcpy( devName, "juhu" ); [/c]
Das Ausgeben des Strings funktioniert nicht. Sobald ich versuche, den String auszugeben, sieht es so aus, als ob der Controller nicht einmal los läuft. Habe die Zeile [c]dbg_printf("%s\r", devName);[/c] direkt am Anfang
-
Thread
Int-Wert-Ausgabe auf Display ??
s zurückgegeben (bei dir keine Rückgabe) Mit der Bibliotheksfunktion könnte man schreiben: [C] void main() { char s[] = "hier soll genug Platz für eine zahl reserviert werden"; sendeString( itoa(12345, s, 10); } [/C]
Alle C Funktionen, die mit Strings arbeiten, befolgen eine Konvention: jeder String wird mit einem 0-Byte (in C-speak: ein '\0'-character) abgeschlossen. D.h. anstatt einer fixen Laufweite, gibst du einfach
-
Thread
(Speicher?-) Problem mit STM32 + VCP
rumgemacht. Jetzt hänge ich an folgendem Problem und komm einfach nicht weiter. Hier mal mein Code: [c] int main(void) { char SendString[]= "hallo wie gehts dir?"; unsigned char SendStringLength; // char ReceiveString[0x100]; // unsigned char ReceiveStringLength; Set_System
PC den String senden kann ( das ist ja eigentlich garkein problem :-D ). Sobald ich jetzt aber die beiden zeilen: [c] // char ReceiveString[0x100]; // unsigned char ReceiveStringLength; [/c] wieder
-
Thread
Array von Zeigern und Doppelzeiger
geschrieben, jedoch keine Idee wie ich das Char Array als eigne Adresse in den Speicher verschiebe. [c] int main(){ char string_eingabe[20]; char **string_array = calloc(2, sizeof(char*)); string_array[0] = "ErsterString"; /*Genau gleichwertig mit: */ /* *string_array = "Erster String; */ printf("String hinzufuegen>"); scanf("%s", string_eingabe); return 0; } [/c]
-
Thread
UART String empfangen
Hallo zusammen ich habe ein Problem um einen String zu empfangen und brauche Hilfe. Habe meinen µC AVR MT128 mit Hyperterminal verbunden, ich kann Zeichen senden und string senden. Ein einzelnes Zeichen kann ich auch empfangen aber ich muss ein String
zum anderen muss dieser String ausgewertet werden String empfangen kann man im Grunde genauso machen, wie das in dem Tutoriallink weiter oben angegeben ist. In C++ würde man als Speicherfläche nicht unbedingt ein char Array nehmen
-
Thread
Arduino - String-Eingabe in num. Wert verwandeln
Peter B. schrieb im Beitrag #6419371: > String str = Serial.readString (); > int wert = str.toInt(); um String dein str in c-str() zu wandeln gibt es doch str.c_str() das in wert = atoi(str.c_str()); sollte doch klappen https://www.arduino.cc
Joachim B. schrieb im Beitrag #6419520: > um String dein str in c-str() zu wandeln gibt es doch str.c_str() String::c_str() liefert eine Zeiger auf den internen Buffer von String. Es wandelt nicht. Eigentlich ist die Methode recht kritisch, da
-
Thread
C# und ECMD Befehl über IP Stack an Ethersex absetzen
System.Net.Dns.InternalGetHostByAddress(IPAddress address, Boolean includeIPv6) at System.Net.Dns.GetHostEntry(String hostNameOrAddress) at HTTP_GET_Console.HTTPGet.ConnectSocket(String server, Int32 port) in C:\Documents and Settings\AU3589\My Documents\Visual Studio 2010\Projects\Test\HTTP_GET_Console\HTTP_GET_Console\Program.cs:line 45 at HTTP_GET_Console.HTTPGet.SocketSendReceive(String server, Int32 port) in C:\Documents and Settings\AU3589\My Documents\Visual Studio 2010\Projects\Test\HTTP_GET_Console\HTTP_GET_Console\Program.cs:line 86 at HTTP_GET_Console.HTTPGet.Main(String
-
Thread
Sprechende Lampe
WL_CONNECTED) { delay(1); } // Show the own IP address display.draw_string(0,8,"IP="); display.draw_string(18,8,WiFi.localIP().toString().c_str()); display.display(); } void loop() { delay(1000); display.scroll_up(8,20); display.draw_string_P
3ffef0f4 00000000 40202455 3ffffe70: ffffffff 00000000 00000000 40106a4c 3ffffe80: e0030024 00000000 00000000 4000050c 3ffffe90: 00000000 00000000 0000001f 00000022 3ffffea0: 3fffc200 401069b8 3fffc258 4000050c 3ffffeb0: 40000f68 00000030 00000010 ffffffff
-
Thread
Speicherbereich in String abspeichern
Da hast du natürlich Recht, dass ist schlampig! Aber [c]char temp_string[512];[/c] bringt keine Besserung!
Mmh, an meiner Ausgabe ist jedenfalls kein Fehler. Hiermit: [c]char temp_string[512] = "0,225 0,475 0,000";[/c] bekomme ich den String "0,225 0,475 0,000" korrekt ausgegeben.
-
Thread
strtok Problem
Zeichenketten und Zahlen? Falls ich Dich damit unterfordere, einfach ignrorieren. ein [c] char a; [/c] stellt ein ASCII Zeichen dar und kann den numerischen Wert von -127 bis +127 annehmen. Im Speicher ist das ein Byte üblicherweise. [c] char string[128]; strcpy (
[40],*buffer; strcpy(all,Tree.MD.all); //hier mache ich eine kopie um den string zu schützen [/c] dann fange ich an: [c] buffer = strtok((char*)all, ","); strcpy(Tree.MD.Name1,buffer); //in meine variable speichern [/c] und dann gehts weiter mit den nächsten teilen
-
Thread
Kann mir wer diese FOR-IF Schleife erklären bitte ?
der main.c um die es geht! [c] for(k=0;k<strlen(stringReceived);k++) { if(stringReceived[k] == 0x0A) { k--; stringReceived[k] = '\0'; k=0; }
= atoi (stringReceived); [/c]
-
Thread
Sind Sie sicher Abfrage, Usart, Atmega32
Z.B. so: [c] while( uart_string[1] != '\0') { _delay_ms(200) PORTA ^= (1<<PA0) } [/c]
uart_string[0] = '\0'; uart_schreibe_string("Hauptmenue"); }*/ }[/c] Siehe Bild Das ist der nächste Versuch: [c] if (strcmp (uart_string, "2" ) == 0) {
-
Thread
Kann nicht Interrupt auslosen mit Timer4 und Timer5
//PORTCbits.RC7 = 0; if(f<2){ c = UARTGetDataByte(UART2);//ReadUART2(); // Skip the <CR><LF> characters at the beginning of the string if(!(c== 0x0d || c== 0x0a)){buffer[f] = c; f++
//PORTCbits.RC7 = 0; if(f<2){ c = UARTGetDataByte(UART2);//ReadUART2(); // Skip the <CR><LF> characters at the beginning of the string if(!(c== 0x0d || c== 0x0a)){buffer[f] = c; f++
-
Thread
Probleme mit STRINGS!!
der strcmp funktioniert nicht mehr! danke im voraus mfg mathias for(;;){ c = uart_getc(); if ( c & UART_NO_DATA ){ }else{ if(c != '\r'){ rxBuffer[i]=c; i++; }else{ rxBuffer[i] = '\0'; i = 0; lcd_gotoxy
also auf jeden fall funktioniert es jetzt danke ich habe es jetzt einfach so gemacht !! if(c != '\n' && c!='\r') danke nochmal!! mfg mathias
-
Thread
AtMega128: Längenbegrenzung bei "strcat"?
Stringende suchen muss, wieder abfangen. Aber probehalber kannst du ja mal folgendes machen [C] unsigned char* ucsHTML_string = (unsigned char*)XRAMSTART; [/C] Das meiste in deinem Programm sollte eigentlich weiterhin genauso kompilieren wie vorher. Und deine maximal mögliche Stringlänge
an 2 Stellen herum basteln. Das war bisher ein ziemliches > Gefiesel.... :-) Das kann man in C auch so machen, dass man nur an einer Stelle verändern muss. Zugegeben: ist ein bischen trickreich, aber machbar. :-) > Den String vom Flash mit "strcpy_P" zuvor in einen temporären String ins
-
Thread
STM32 C was passiert da?
Nein hat er nicht. Allerdings funktioniert die String Funktion auch nicht: void display_putstring(char *string,uint8_t color, uint8_t x, uint8_t y) { uint8_t i=0; char c = string[0]; while(c != 0) { if(c == '\n'){} //New Line no Support else display_write_char(c,color,xpos,ypos); c = string[++i]; } } display_putstring("Hallo Welt",xpos,ypos,0x04); Das müsste doch funktionieren?
-
Thread
uart mit atmega88
; Frame-Format: 8 Bit ldi temp, (1<<USBS0) | (3<<UCSZ00) sts UCSR0C, temp ldi temp, 1<<TXEN0 sts UCSR0B,temp ldi temp, 1<<TXEN0 ; TX aktivieren sts UCSR0B, temp loop: ldi zl,low(my_string*2);
; Frame-Format: 8 Bit ldi temp, (1<<USBS0) | (3<<UCSZ00) sts UCSR0C, temp ldi temp, 1<<TXEN0 ; TX aktivieren sts UCSR0B, temp loop: ldi zl,low(my_string*2); ; Z Pointer laden ldi zh,
-
Thread
Strings mit AVR - aber richtig
Serial.println(FlashStr(roman)); Serial.println((FlashStr)roman); Serial.println((__FlashStringHelper *)roman); } void loop() { }[/c]
Wenn der String [c] const __flash char BUILDTIME[] = {__DATE__ " " __TIME__}; [/c] und die Ausgabefunktion [c] void send_byte_usart0(u8 c) { while(!(UCSR2A&_BV(UDRE2))); //Uart not ready UDR2 = c; /
-
Thread
string an Funktion übergeben - Problem Speicherverbrauch RAM
strings werden in c automatisch vom kompilateur mit null terminiert.
Ein Beispiel für AVR: [c] puts("Hallo"); [/c] Belegt für den String doppelt Speicher, nämlich einmal im Programmspeicher (Flash) und dann nochmal im RAM. Anders kann es auch nicht gehen, denn puts erwartet einen Pointer auf
-
Thread
µC startet immer wieder neu
*format, ...); Dort kannst Du noch die Länge des Strings mit übergeben, in den Du sprinten willst. Wird der String zu lang, wird abgeschnitten. Damit kommst Du nicht in Gefahr, dass irgend etwas überschrieben wird. Aus dem gleichen Grund sind strcpy,
Alles klar Frank, werde ich so machen. Nochmal zum C-Buch, kannst du mir ein gutes Nachschlagewerk empfehlen? Viele Grüße Paul
-
Thread
#defines in jeder Datei nutzen??
diesem Sinne: [c] size_t len = strlen(irgendein_string); char string_kopie[len + 1]; memcpy(string_kopie, irgendein_string, len + 1); [/c]
in diesem Sinne: > [c] > size_t len = strlen(irgendein_string); > char string_kopie[len + 1]; > memcpy(string_kopie, irgendein_string, len + 1); > [/c] Den Code hast du aber garantiert noch nichtmal compiliert... Wir
-
Thread
Zeichenkette über UART empfangen
Westallgäuer E. schrieb im Beitrag #6641216: [c] > if (c == '\n' || i == (20-1)) [/c] [c] if (c == '\n' ) [/c] reicht, um die Aktion am Ende eines Strings durch zu führen. Wie wäre es, einfach mal Kommentare einzufügen, wie du das Programm
); i = 0; // zurücksetzen für nächsten String test[i] = '\0'; // leerer String } } } [/c] Das ist alles was aktuell vorhanden ist.
-
Thread
Kompatibilität bei C Programmierung
Hi, was muss man eigentlich beachten, wenn man µC in C programmieren will und z.B bei einem späteren Wechsel der MCU z.B. PIC18 <=> ATmega nicht allzuviel änder will. Gibt es ungeschriebene Regeln, die man beachten kann, damit der Quellcode möglichst
Ich dachte auch an so Dinge wie String-Literals im FLASH ablegen. Hier hat der C18 von Microchip dann einen Satz spezieller Funktionen um die Standard C Bibliothek sowohl auf RAM als auch auf Flash ROM Strings anzuwenden. Nur sind
-
Thread
ADC to UART Problem C/C++
Transmitter UCSR0B = (1<<TXEN0); //Einstellen des Frame-Formates auf 8data-, 1stop-bits UCSR0C = (0<<USBS0) | (1<<UCSZ00) | (1<<UCSZ01); } //Übergeben einzelner Zeichen des Strings void usart_sput(char *string) { while(*string) { usart_send(*string); string++; } }
average; ++i ) result += ADC_Read( channel ); return (uint16_t)( result / average ); } [/c] Danke für eure Zeit. MfG Max
-
Thread
Hex in Binär umwandeln "C"
Hallo an alle, ich habe folgendes Problem: Und zwar müsste ich in C ein Programm schreiben. Ich empfange über TCP/IP einen String (zb. 0x000F). Diesen String möchte ich in einen "Binär"-String umwandeln: "0x000F" = "0000000000001111" Wie kann ich es hin bekommen
mit den Funktionen [c]atoi[/c] oder mit [c]strtol[/c] Letzere funktion (sollte) bevorzugt werden.
-
Thread
Datenpakete senden
vorangestellten Nullen ausgeben. http://www.nongnu.org/avr-libc/user-manual/group__avr__stdio.html#gaa3b98c0d17b35642c0f3e4649092b9f1 Z.B. unsigned int a=5,b=10,c=115; char string[13]; sprintf(string, "%04d%04d%04d", a, b, c); Der Output in string sollte so aussehen: 000500100115 Alternativ
Rücklesen am PC funktioniert über scanf mit der gleichen Formatanweisung wie das Senden. char string[13]; unsigned int a,b,c; Angenommen, die empfangenen Daten stehen in string sscanf(string, "%04d%04d%04d", &a, &b, &c); Dann stehen jetzt die Zahlen wieder in a, b und c. Grüße, Peter
-
Thread
AVR - Mal wieder ein Wecker
( hour ); lcdWriteString( " : " ); lcdWriteBcd( min ); } } [/c] Das funktioniert. Warum funktioniert das jetzt mit dem "uint8"? Gruß
lcdWriteString( ":" ); lcdWriteBcd( min ); } } } [/c]
-
Thread
while( ) >>> mit Bedingungen
Es gibt da durchaus zwei Ansätze: [c]char * SearchChar(char * String, char Char){ while((*String != '\0) && (*String != Char)){ String++; } return (*String == Char) ? String : NULL; }[/c] [c]char * SearchChar(char * String, char Char){ while(*String != '\0'){ if(*String == Char){ return String; } String++; } return NULL; }[/c] Ich bevorzuge die zweite Variante, obwohl das return innerhalb der Schleife ist (und somit
-
Thread
Formatierung von Strings
[c]sprintf(buffer, "A%04dB%04d\n", ad1, ad2);[/c]
Auf jeden Fall brauchst du aber ein C-Buch printf (mit all seinen Varianten) und was man damit im Format-String alles anstellen kann, sind Stoff der ersten paar Kapitel eines jeden C-Buchs. Die Ausrede "Bin Anfänger" ist keine Entschuldigung
-
Thread
[C] Probleme beim auslesen von Strings
Schnittstelle an den PC senden. Die Kommunikation funktioniert auch im großen und ganzen, nur kommt von den Strings die ich im Programm angegeben habe nur Müll an. Ich habe verschiedene Möglichkeiten ausprobiert (Im flash speichern und auslesen, String einem globalen/lokalen pointer zuweisen, ...) aber das einzige
auf dem Terminal sieht etwa so aus: 4????'mnopqr Es werden also nur die Zeichenketten c5 und c6 korrekt gesendet 2. Gebaut wurde unter Linux mit gcc-4.1.2: avr-gcc -mmcu=atmega8 main.c -mmcu=atmega8 -c -o main.o avr-gcc main.o -L/usr/lib/binutils/avr/2.19.1/ -Wl,-Map=main.elf.map
-
Thread
Programmierbare Relaiskarte - Konfigurationsdaten Lesen/Speichern/Übertragen
man arbeitet gleich mit sizeof. Dann sucht sich der Compiler selbst die Größe des Arrays raus. [c] #define ARRAY_LEN(x) (sizeof(x) / sizeof(*x)) [/C] [C] if (temp == ';' || StringLen > ARRAY_LEN - 2 ) { ... [/C]
gemacht habe kann ich gerade nicht erklären. Werde das natürlich auch abändern. [c]if (strcmp(Line, "SYS_SYNC") == 0)[/c] Hier ist es egal an wo in dem String der Sub-String steht, es soll auf jeden Fall dieser Bereich ausgeführt werden. Frank M. schrieb im Beitrag #3289808: >
-
Thread
PC-Applikation C# mit ST-Link und CLI-Interface
erfolgreich/nicht erfolgreich umgesetzt. void Programmer_Programmieren() { String args = ""; //command= " -c SWD -P HEXFILE.hex -V"; // Anm. Verify funktioniert nicht!! //command= " -c SWD -r8 0x00 0x200"; // Test: speicherausgabe ... command = " -c SWD -P HEXFILE.hex";
) ? "(none)" : output)); String sResultErr = ("error>>" + (String.IsNullOrEmpty(error) ? "(none)" : error)); String sResultExit = ("ExitCode: " + ExitCode.ToString()); Console.WriteLine(sResultOut); Console.WriteLine
-
Thread
Problem beim senden mit printf
oh man, schaffs es mittlerweile nicht mehr bei jedem Anruf einen Pin zu toggln! [c] if ( strstr((char*)uart_string,p_sms_telnr_tmp) ){ UCSRB &= ~(1 << RXCIE); // uart RX ISR deaktivieren uart_clear(); uart_sends("AT+CHUP\r\n"); //Auflegen anz_klingeln
über den Funktionspointer aufgerufen. Du brauchst also nur, wie im Artikel beschrieben, in der sms.c das Konstrukt [c] const SMS_CMD_LIST_T sms_cmd_list[] = { {"set",sms_cmdset}, {"test",sms_cmdtest} }; [/c] anpassen. Also der erste Parameter ist der String auf den reagiert werden soll. Dabei
-
Thread
mit eingänge rechnen
). Nun, ein String ist halt ein Array aus char. Sonst nutzt C nirgends char für Text. Für einzelne Zeichen wird in der Regel int benutzt. Schau dir mal die ganzen Standard-Funktionen an, die mit einzelnen Zeichen arbeiten
wurde). > > Nun, ein String ist halt ein Array aus char. Sonst nutzt C nirgends char > für Text. Falsch. Ein einzelnes Zeichen wird als char deklariert. Nicht nur ein Array von chars. Der Programmierer triftt die Entscheidung
-
Thread
Progmem zuweisungen
]void PrintString (uint8_t __memx *String);[/c] Dann kann der Benutzer mit der selben Funktion sowohl Strings aus dem Flash, als auch welche aus dem RAM ausgeben.
erneuert bekommen und alles funktioniert jetzt. Hier die Zusammenfassung meiner Erkenntnisse: 1. String wird im RAM abgelegt [c] Func("Hallo"); void Func (uint8_t *pstring) {} [/c] 2. String wird im FLASH abgelegt [c] Func_P(PSTR("Hallo")); void Func_P () {} [/c] 3. String wird im FLASH
-
Thread
itoa in Großbuchstaben ausgeben
if(x<10){ dummy[4]=(x+48); }else{ dummy[4]=(x+55); } std_lcd_print_string_to_cursor_position(dummy); } [/c]
davon das sie nach acht Zeichen aufhören soll. oder z.B.: [c]i=0; do { if (array[i]) printf (" %d", array[i]); else break; ++i; }while(1); [/c] Sowie eine andere (String-)Funktion aufgerufen wird weiß diese nichts mehr davon das dass Array
-
Thread
USART Kommunikation zwischen ATMega32 und ATMega328p
Schon mal versucht mit dem E-Kommando den gesendeten String wieder zu lesen? Ich hatte mal den Fehler das Kommandos mit hyperterm an einen µC funktionierten aber aus einem C-Programm ging es nicht. Der Fehler war: der µC hat die UART gepollt und war bei
= Frequenzwert, \r = Carriage Return // Den String über USART senden //usart_sendString(message);*/ while (1) { usart_sendString(message);// Endlosschleife, keine weiteren Aktionen erforderlich } } [/c] so?
-
Thread
AVR Project – Relay Timer with ATmega8 AVR MCU
bekommen. Konzentrier dich erst mal nur auf das LCD und lass den Timer-Code weg. Ein einfaches [c] int main() { InitLCD(0); LCDWriteString(" Welcome "); while( 1 ) ; } [/C] reicht, um das LCD in Betrieb zu nehmen und den Funktionsnachweis zu erbringen. Alles andere sind
LCDGotoXY( 0, 0 ); LCDWriteString("Unten"); } } } [/C] Dann gehts eben weiter. Nicht etwas tun solange eine Taste gedrückt ist, sondern eine gedrückte Taste nur einmal auswerten. Um beim Original zu beliben, zb so [
-
Thread
Kommandoshell für µC: selber schreiben oder Parsergenerator (Flex/Bison bzw. GOLD)?
TCL/TK sogar portabel für gängige OS) * bei der Übertragungsschicht bist du flexibel (s.o) * auf µC Seite sparst du dir das rumgefrickel mit Strings, parsen etc. Wenn du keine "Programme" zum interpretieren an den µC senden musst, ist diese Lösung besonders für große Projekte aus meiner Sicht wesentlich
> In Boost.Spirit geht das sogar noch schneller - man passt die > Grammatikdefinition direkt im C++ Code an, und ruft den C++ Compiler neu > auf. Wieso sollte das jemand interessieren? Auf Mikrocontrollern wird zu 99% C verwendet und flex liefert reinen C-Code der ohne Aenderung direkt fuer
-
Thread
Intelhex-File mit C einlesen
schreibe. Bleib bei der Strategie erst mal eine Zeile komplett einzulesen. Hast du sie erst mal als String im Speicher, kannst du sie in aller Ruhe zerlegen und analysieren. Vor allen Dingen in Fehlerfällen ist das einfacher, als wenn man gleich beim Einlesen die Zeile zerlegen lassen will [C]
:100010000C94D6000C94D6000C94D6000C94D60008 :100020000C94D6000C94D6000C94D6000C94D600F8 ... :101668006E76616C6964005769647468546F6F536F :081678006D616C6C003F000085 :00000001FF [/pre] Die Ausgabe: [pre]