-
Thread
Interessante g++ Erweiterung für user-defined literals
char data[] PROGMEM = {CC..., '\0'}; }; template<typename C, C... CC> constexpr const char PgmString<C, CC...>::data[] PROGMEM; template<typename C, C... CC> constexpr PgmString<C, CC...> operator"" _pgm(){ return PgmString<C, CC...>(); } [/c]
{ "abc"_pgm, "def"_pgm, }; [/c] und in PgmString den Typwandlungs-Op [c] constexpr operator PgmStringView() const { return {&data[0]}; } [/c] Möchtest Du sie im RAM haben, würde ich einen StringBuffer
-
Thread
Von Arrays zu einem String
ist (der Abstand zum nächsten Zeichen). Jetzt brauchst Du nur eine Funktion schreiben, die einen String oder ein Einzelzeichen nimmt und entsprechend die Codierung herausfindet. Beispiel: Du willst ein 'c' ausgeben: Deine Funktion macht jetzt folgendes: Ein 'c' hat den Code 63h. Du holst die 16Bit
oder http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F für die absolut notwendige Kurzfassung #include <string.h> > bleibt jedoch mein fehler mit der zeichenbegrenzung meines strings... Ganz ehrlich. Der Code ist mir viel
-
Thread
warnung:"[variable]may be used uninizialized"
C uasrt_puts( "#\r" ); // <- String S switch(Line[1]){ [/C]
ok es liegt anscheinend auf jeden fall an der uart_gets() genauer gesagt an der bedingung [c]while( NextChar != '\n' && StringLen < MaxLen - 1 ) {[/c] sobald ich das array Line[] auf 3 felder länge setze läuft alles wies soll... - beötigt man für StringLen zufällig ne bibliothek die ich
-
Thread
Display Arduino
ganz einfach nach jeder *vollständigen* Ausgabe ein Delay mit 500 - 1000 ms setzen, also z.B. [c] ... lcd.setCursor(0,0); lcd.print(myStrings[i]); i++; lcd.setCursor(0,1); lcd.print(myStrings[i]); i++; delay(500); ... [/c] Dann hat derjenige, der auf
für die UP-Taste: [c] ... else if ((x >= 50) && (x < 148)) { lcd.print ("UP "); lcd.setCursor(0,1); lcd.print(myStrings[i]); i--; lcd.setCursor(0,0); lcd.print(myStrings[i]);
-
Thread
C-File Notlösung. Wer könnte kurz helfen?
dann via einer Variablen im main.c das Minuszeichen vor die Temperatur setzt. ... if (x > 0) { lcd_string_format("Temp:- %i.%i C %i \nHumi: %i.%i %% %i " , temp/10, temp%10, x, humidity/10, humidity%10
= temp/10.0; fhumidity = humidity/10.0; lcd_string_format("Temp: %.1f C %i \nHumi: %.1f %% %i " , ftemp, x, fhumidity, i);[/code] x könnte jetzt auch weg.
-
Thread
attiny2313, LCD, 4-Bit, C, Einzelne Zeichen falsch
Das hier ist mein Hauptprogramm int main(void) { // Initialisierung des LCD int z=1,s=0,c=0; lcd_init(); // Teil 1 lcd_data(0x30); lcd_data('0'); lcd_string("0@P0@P0@P0@P"); _delay_ms(1000); lcd_clear(); // Teil 2 while(1) { if (s==16) { s=0;
In deinem Code taucht nämlich auch noch SetCursor etc auf. Ausserdem ist ein Aufruf von lcd_string nicht unbedingt mit einem mehrfach hintereinander erfolgtem Aufruf von lcd_data zu vergleichen. c ist bei dir int, etc. Da gibt es schon ein paar Unterschiede, die sich zb auswirken wenn du lcd_routines.h
-
Thread
16x2 LCD Langsamer Displayaufbau
kann, gerne lasse ich meine Programme von dir schreiben so das sie dir gefallen, einverstanden ? [c] char *trimm_string(char vorlauf, char *s_string, UBYTE num) { static char _tmp[MAX_STRING]={0}; memset( _tmp, (int)vorlauf, num); _tmp[num]=0; strcat(_tmp, s_string); return &_tmp[strlen(_tmp)-num]; } // char *trimm_string(char vorlauf, char *s_string, UBYTE num) [/c] noch ne Lösung von mir die auch andere Zeichen als Null im "Vorlauf" erlaubt, z.B. SPACE, nützlich bei LCD Ausgaben immer an der selben Stelle mit Zeichen
-
Thread
µC von 0 auf lernen. ASM oder C?
Mich würde die Meinung der Experten dazu interessieren: Was denkt ihr ist für einen Anfänger der µC von 0 auf lernt einfacher? Direkt mit ASM starten oder erst C lernen und dann den µC in C proggen?
C fertig entwickelt ist und man es optimieren will Teile davon in ASM neu machen. Ich verwende mittlerweile C für alle Projekte, welche Berechnungen, Strings, LCDs oder komplexeres wie SD-Karten ...
-
Thread
36khz für ir- kollisionssystem
OCR2 = 0xFF; // Enable timer interrupts: TIMSK = (1 << OCIE0)|(1<<OCIE1A); sei(); [/c] und hier mein programm: [c] #include "RP6ControlLib.h" uint8_t a; ISR(TIMER1_COMPA_vect) { PORTD ^= (1<<PD5); writeString_P("\Interrupt Timer1 Compare"); } void infrarotempfang
<41) {writeString_P("Interrupt Pause\n");} if(interruptcounter == 41) {interruptcounter =0;} } [/c] ich habe es doch so programmiert, dass von 0-20 interrupts PD5 gepulst wird. danach folgt eine
-
Thread
for Schleife in C
[c] #include <stdio.h> #include <stdlib.h> #include <string.h> #include <inttypes.h> int main() { printf("\r\nstart\r\n"); for(uint8_t lpctr = 0;lpctr != 0;lpctr++)
Diese verwendet man noch fiel eher falsch, als strcat und strcpy, weil die Leute /denken/ es würde die c string länge korrekt begrenzen, wofür diese aber garnicht gemacht sind. Ein null byte setzt strcpy aber nicht am Schluss: https://linux.die.net/man/3/strncpy Und strncat ist auch super, das limitiert
-
Thread
I2C / UART / LCD
diesem {} lokal itoa( variable, Buffer, 10 ); // ... ausgeben lcd_string( Buffer ); } [/c]
DDRB = 0xFF; PORTB = 0x00; i2c_init(); temp = i2c_findSlave(0x00); lcd_init(); lcd_clear(); lcd_home(); lcd_string("Bereit..."); set_cursor(0,2); lcd_string("I2C-Slave: 0x"); lcd_string(itoa(temp,buffer,16
-
Thread
String in Int umwandeln, damit rechnen und wieder zurückkonvertieren
0]*10) + '0'; ausgabearry[3] = mh/1000 - (ausgabearry[0]*100) - (ausgabearry[2]*10) + '0'; lcd_string("Geschwindigkeit:"); set_cursor(1,2); lcd_string(ausgabearry); //Auf dem LCD ausgeben } [/c] Ich hoffe ihr könnt mir helfen. Gruß, Steffen
ich ja schon davor weiß, wie viel Zeichen _vor_ und wie viele _nach_ dem Dezimalpunkt sind. > [c] > > double wandle_String_in_Double ( string theString ){ > > double theReturn; > int len; > boolean nachkomma; > int nPow; // Exponent zu 10 > > theReturn
-
Thread
In Konstruktor dynamisch instanz einer Klasse generieren, vererbung, C++
); } } void RGB_STRING::write_RGB_STRING() { for (int i=0; i < RGB_STRING::number_of_LEDs;i++) { RGB_STRING::string[i*sizeof(RGB_LED)]->set_LED(); } } [/c] Es funktioniert bis auf einen kleinen BUG, wenn
LEDs aus. --> Folglich wird der Konstruktor nicht aufgerufen. Wenn ich in den Konstruktor von RGB_String nach dem Anlegen der neuen LED: [c] RGB_STRING::string[i*sizeof(RGB_LED)]->RGB_LED(); [/c] kommt die Meldung: Error invalid use of 'RGB_LED::RGB_LED' Ver3_1_Atmega8 Bei [c] RGB_STRING:
-
Thread
"Hilfe beim Programmieren" !
continue; } for (int c = 0; c < 4; c++){ if (Morsecode[sx * 5 + c] == 2)continue; delay(Morsecode[sx * 5 + c] * 100); delay(100); } delay(300); } } incomingString="";
(times); } delay(3 * times); } } incomingString = ""; delay(1000); } } [/c]
-
Thread
C - Speicherplatzfrage
[/c]
selbst wenn man vor Jahren mit C++11 angefangen hat sind die neuen Features un C++14 und gerade C++17 genial. Man muss halt dauernd auf dem Laufenden bleiben. Bei µC ist das natürlich etwas schwerer da hier teils maximal C++11 möglich
-
Thread
Retro Fieber: Z80 oder 68000 ?
Zu den IN/OUT-String Befehlen und dem Carry Flag steht rein zufällig was auf einer Spectrum Seite. Wor sich auch zeigt, dass es nicht sonderlich geschickt ist, sowohl ein Register C als auch ein Flag C zu haben. ;-) http
add string #define mvaddstr_P(y,x,s) move((y),(x)), addstr_P((s)) // move cursor, then add string (PROGMEM) #define mvinsch(y,x,c) move((y),(x)), insch((c))
-
Thread
abweichung beim zeitmessungsprogramm
warum ich einen Bit-Terminator benötige. Was ist ein Bit-Terminator? > Wenn ich > schreibe string[10] wieviele "Ziffern" kann ich dann in diesem string > speichern? (du schreibst string[11]="000000000" also nur 9 ziffern) klassische C-String Verarbeitung. In einem Array der Länge 10 gibt
mindestens eine Länge von 11 haben. http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F
-
Thread
Bascom ist gut
2x Variablen vom Typ Config_t anzulegen. In Bascom??? [c] typedef struct Config { uint8_t var1; uint16_t var2; char[10] string; uint16_t[15] varArray; } Config_t; Config_t config1; Config_t config2; [/c] > Die andere Sache, das musst
at ausgabearray(1)+3 dim stringausgabe as string*5 at ausgabearray(1)+7 dim wordvariable as word at ausgabearray(1)+12 etc. [/c] ich verwende sowas bei nem Modbusbrotokoll
-
Thread
Atmega324 UART: Senden vom PC zum µC klappt nicht
UBRR_VAL & 0xFF; UCSR0B = (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0); //8data 2stop bit UCSR0C = (1<<USBS0)|(3<<UCSZ00); } [/c] Interrupt [c] volatile uint8_t uart_string_complete = 0; volatile uint8_t uart_string_count = 0; volatile char uart_string[UART_MAX_STRING_LENGTH + 1] = "";
= 1; } if(finishString == 1) { uart_string[uart_string_count] = '\0'; uart_string_count = 0; uart_string_complete = 1; } } } [/c] Selbst wenn ich bei jedem Interrupt uart_string_complete
-
Thread
-
Thread
C-Struktur, unklares Verständniss - ben. Hilfe!
C. L. schrieb im Beitrag #3929177: > Diese wird dann aufgerufen in der MAIN mit: > [c] > LCDWriteStringROM(0,0,*menu[1].text,0); > [/c] > Der Stern muss weg. Der hat da nichts zu suchen. menu
ist [c] void foo( const char* str ) { size_z i = strlen( str ); } [/c] absolut korrekt. Ein Stern wäre hier völlig falsch. > da string übergeben werden muss. Einen string kannst du prinzipiell
-
Thread
Zeichen einem String hinzufügen
Claudio H. wrote: > Aber dieses "schreiben" meinst du ja von hand.... Hä? Hat der µC eine Hand? > aber ich will das die Software das Empfangene zeichen (über uart) dem > string hinzufügt.... Das musst Du dem µC aber auch sagen. Und deshalb musst Du ein Programm schreiben, dass ein
den unpraktischen C- strings ist hinten eine Null. Die muss man dann auch neu schreiben. Bei den bequemeren Pascal strings ist das nullte byte die Laenge. Dann passt man die an.
-
Thread
String leeren
Ich leere den String jetzt nach dem ; so: [c] while(*posteingang) { *posteingang='\0'; posteingang++; } [/c] Geht das besser ? pirat
( string, sizeof( string ), 'c' ); } [/C]
-
Thread
UART String einlesen
ab. } } [/c] Wie gesagt will ich einen String einlesen, sobald ich was auf der seriellen Schnittstelle empfang, sonst soll das Programm andere Tätigkeiten ablaufen lassen.
aus. > gets(neu); //Speichert den String auf neu ab. > } > } > [/c] > > Wie gesagt will ich einen String einlesen, sobald ich was auf der > seriellen Schnittstelle empfang, sonst soll das Programm andere > Tätigkeiten ablaufen lassen
-
Thread
[Pic] C18 Probleme mit Strings
0'; i++); for (j=0; j<i; j++) { T6963_writeData(text[j]-0x20); T6963_writeCommand(0xC0); } } [/c] Folgende Codebeispiele [c] unsigned char text[5] = {'T', 'e', 's', 't', '\0'}; unsigned char string[] = "Noch ein Test"; T6963_writeString(0,5, string); //Auf dem Display wird
schrieb im Beitrag #1926428: > Welcher Compiler? > Besitzt dieser Compiler auch die entsprechende String library oder heißt > sie da vll. anderst. ? Als Compiler verwende ich den MPLAB C18 C v3.36. Welche String Libraries sollte ich den includen? > Du machst dir das Leben schwer...//.... > (Kann
-
Thread
Suche Methode zur Konvertierung von Double in String (in C)
darzustellen. Demnach suche ich nach einer Methode (in C) der ich eine Double Zahl uebergebe um dann einen Char String zurueckzukriegen. DANKE und GRUESSE !!
Stefan Meier schrieb: > Folgendes passiert bei der Benutzung von sprintf: > > > [c] > long int rein; > char raus[15]; > sprintf(raus, "%d", rein); > [/c] > > Bis 12345 funktioniert das ganze, dann habe ich einen String mit > "12345". Nein. Es funktioniert nicht. Das du
-
Thread
ATtiny85 - bei 3.5kB ist Schluss
MWS schrieb im Beitrag #4021276: > Ein: > [c]lcd.print(" ready, press ");[/c] > > dürfte auch in Arduinisch keine extra Variable mit Inhalt " ready, press > " dauerhaft im SRam anlegen. Da wird nur temporär SRam verwendet, um den > String
dass es da am Arduino noch keine andere Lösung gibt. > Immerhin muss der COmpiler ja auch bei > [c] > lcd.print(F("PCF8574 @: ")); > [/c] > damit klar kommen, dass er einen Pointer auf einen String im Flash > kriegt und die entsprechende print Methode raussuchen. Ergo muss es eine >
-
Thread
Könnte mir jemand diesen C++ Code in eine class Bibliothek umschreiben
*page, uint8_t *buffer, int32_t length); int32_t pngSeek(PNGFILE *page, int32_t position); String readFile(fs::FS &fs, const char * path); void pngDraw(PNGDRAW *pDraw); }; #endif mein C++ File #include "MyPngLib.h" void PngClass::InitPngLib(TFT_eSPI tft ) { _tft = tft; //SPIClass
->y, pDraw->iWidth, 1, lineBuffer, dmaBuffer); } void PngClass::DrawPng(int x, int y,const String PngName) { xpos = x; ypos = y; int16_t rc = _png.open(PngName.c_str(), pngOpen, pngClose, pngRead, pngSeek, pngDraw); if (rc == PNG_SUCCESS) { _tft->startWrite
-
Thread
C Methoden mit Variablen
... } [/c] ich möchte dieselbe methode mehrmals verwenden, nun stellt sich mir die frage wie kann ich die Variablen merkertimeOn und merkertimeOff speichern/übergeben? was gibt es in C für Möglichkeiten?
WimmerM schrieb im Beitrag #6190712: > C Methoden ??? In C gibt es keine Methoden. C entstammt den Jahren vor unserer Zeit. Tiefstes Mittelalter und wird nur noch von den Möchtegernprofis gehyped. Hast du ein BS am Laufen? Dann nimm
-
Thread
strlen(.) oder sizeof(.)-1
Hallo! Was ist denn besser? [c]#define MY_STRING "Das ist ein Test" ... { uint8 len; /* Option 1 */ len = strlen(MY_STRING); /* Option 2 */ len = sizeof(MY_STRING)-1; }[/c] Danke & Gruß Jochen
und jetzt die Preisfrage: was passiert bei [c] #define MY_STRING "Das ist ein Test\0und nochwas" [/c] ???
-
Thread
LCD Routine (C) bringt fehler
verschieben oder -> in der #include-Anweisung den Pfad angeben (beachte den Unterschied <string-avr.h> und "string-avr.h") - die Datei steht nirgens Suche den Rechner nach der Datei ab (mit WindowsTaste-F). Ein gutes Programm würde sagen: Laden der Datei string-avr.h von Verzeichnis c
UBRRL = (unsigned char) USART_BAUD_SELECT; } void usart_writeChar(unsigned char c) { while (!(UCSRA & (1<<UDRE))) {} UDR = c; while(!(UCSRA & (1<<TXC))) {} } void usart_writeString(unsigned char *string) { while (!(UCSRA & (1<<UDRE))) {} while (
-
Thread
Vorteile bei Umstellung von C auf C++
C wohl fühlt und ihr die Strings im Griff habt, dann würde ich dabei bleiben.
erst mal den gleichen Code nehmen, und mit dem g++ übersetzen. Und bei Erweiterungen dann Teile auf C++ umstellen. Ob man für alles Vererbung braucht.. meistens nicht. Aber auf std::string und vector-Klassen möchte ich nicht mehr verzichten. Auch die Konstruktoren mit der Kapselung und sauberer Initialisierung
-
Thread
In C einen String aus Zahlen und Text zusammenbasteln
eigentlich hätte ich erwartet, dass sowas in C geht: [c]uint8_t x[] = { 0xC3,"Blafasel" };[/c] Sieht auf den ersten Blick richtig aus, funktioniert aber leider nicht. Ich wollte in dem Fall einen String erzeugen, der ein "unaussprechliches"
Die erste 0 ist zuviel. So wird der String wie [c] "\030" "3Blafasel" [/c] interpretiert.
-
Thread
C vs. C++ zur Mikrocontrollerprogrammierung - oder: Auf welche C++ Features lieber verzichten?
dafür lieber was angepasstes kleines. Ich habe auch bei der PC-Programmierung nie verstanden was die C++ Std Lib für Vorteile bringen soll. Solche elementaren Sachen wie Strings, Container und Listen hat man irgendwann einmal für seine Bedürfnisse implementiert und kann sie immer wieder verwenden. Ich weiß gar nicht wie oft ich in den 21 Jahren, seit dem ich mit C++ auf dem PC unterwegs bin, den Compiler wechseln musste. Die Std C++ Lib habe ich noch nie gebraucht oder vermisst. Und mir damit viel Ärger erspart. Die eigenen String- und Containerklassen haben diese
-
Thread
char an String anhängen
newChar; myString[myString_i] = '\0'; } else { myString_i = 0; // oder Flag setzen. } } [/c]
Zeiger auf einen gültigen Speicherbereich hinterlegt wurde. Z.B durch ein message_ptr[i] = myString; // (Definition von myString siehe bei dir) Dann steht in myString das 'c'
-
Thread
String Konvertierung
taucht aber beim Anzeigen nirgendwo auf...) heisst die Funktion die du suchst in der Tat "sprintf". [c] char buf[20]; int x=531; sprintf(buf, "%d", x); LCD_PutString(buf); LCD_Update(); [/c]
// Output ADC sprintf(buf, "%d", adcval); LCD_PutString(buf); LCD_Update(); } } [/c]
-
Thread
String empfangen und auswerten
solange sender besetzt #endif UDR=x; //echo senden return x; //zeichen zurückgeben } [/c]
{ ; //beide aus } break; } return(0); } [/c]
-
Thread
Variable zu ASCII umwandeln in C
)zahl2, (int)erg ); lcd_string( output ); [/C] sprintf verwendet einen String, in den Formatieranweisungen (nach dem %) eingebettet sind. sprintf setzt dann an diesen Stellen die restlichen Argumente ein, wobei man umfangreiche
Standard Ausgabe aus fprintf schreibt das ganze in eine Datei sprintf schreibt das ganze als String in ein char-Array Auf einem AVR-µC macht nur sprintf Sinn, weil es ja so etwas wie eine Standard-Ausgabe in dem Sinne nicht gibt.
-
Thread
RST bei Buffernutzung
"" entspricht doch '\0' was einem C-String-Ende entspricht. warum kann ich das nicht auch an alle stellen schreiben?
insofern gültigen C-String, als das er nach dem zuletzt empfangenen Zeichen 0-terminiert ist.
-
Thread
Benötige Nachhilfe in C - Call by Referenz
//zum Test einfach was zuweisen *String2="egal"; } in main.c: #include meine.c char[5] Ausgabe1; //String anlegen mit platz für 'i s t \ 0' char[6] Ausgabe2; void main(void) { Funktion(&Ausgabe1,&Ausgabe2); putLCD(Ausgabe1
*String2) > { > ... > *String1="ist"; //zum Test einfach was zuweisen > *String2="egal"; > } > > in main.c: > > #include meine.c > > char[5] Ausgabe1; //String anlegen mit platz für 'i s
-
Thread
C String in uint32 und zurück?
spi_flash_write definiert sind - hast du ein link auf die Doku? vermutlich kannst du auch einfach so den String übergeben [c] spi_flash_write(0x8c000, (uint32_t*)buf, 4)); [/c]
Peter II schrieb im Beitrag #4684173: > vermutlich kannst du auch einfach so den String übergeben > spi_flash_write(0x8c000, (uint32_t*)buf, 4)); Nein, das geht nicht besonders gut, weil buf als array of char zwar genauso 4 Bytes belegt wie ein uint32_t, aber buf ist ohne Alignment
-
Thread
String loeschen
Schöner ist es so: [c]Buffer[60]='/0'[/c] Somit ist offensichtlich, dass hier ein Ende des Strings markiert wird.
andere moeglichkeit geben. Was willst du denn außer überschreiben noch machen? Den SRAM aus dem µC rausbauen? Woran erkennt deine Software wie viele Zeichen im String sind?
-
Thread
Strings wollen nicht verbunden werden
; //strcat(packet, crc_str); strcat(packet, crc16(packet)); uart_puts(packet); } [/c] Die auskommentierten Sachen sind optional, falls RS_485ADDRESS ne Zahl und kein string und crc16 ne Zahl und keinen string zurück liefert. P.S.: und alles ohne Gewähr, nur schnell alles mal zusammen
Und wozu überhaupt alle Teilstrings in einen langen String verpacken, nur um sie dann zu verschicken? Da könnte man doch gleich die Teilstrings verschicken... (So eine uneffektive Vorgehensweise gewöhnt man sich in Sprachen wie Java oder C# an :-)
-
Thread
LED G4 2,5W Leuchtmittel gehen ständig kaputt
wäre das aber ok. Ich habe vor ein paar Monaten mal dran rumgemessen und ich bildete mir ein der C2 könnte durchlegiert sein. Bin mir da aber nicht sicher. Der große Elko C1 ist es jedenfalls nicht, denn mit einem 12V DC Treiber müsste ja die Birne nach Entfernen von C1 dann funktionieren (sollte
eine Unterbrechung und kein Kurzschluss. Dann verteilt sich der Strom auf zwei Strings à 105mA, was dann schon grenzwertig sein dürfte, wodurch eine weitere LED in einem der beiden restlichen LED-Strings stirbt, macht 210mA im übrig gebliebenen LED-String, bei dem prompt eine weitere
-
Thread
Standart LCD per i2c expander betreiben
main(void){ i2c_ini(); lcd_ini(); lcd_string_xy(5,1,"text1"); lcd_string_xy(5,2,"text2"); lcd_string_xy(5,3,"text3"); lcd_string_xy(5,4,"text4"); i2c_stop(); return 0; } [/c]
die Ausgabe genau aus? Mach mal ein Foto. Habe die Ausgabe einfach mal wie folgt abgeändert: [c] lcd_string_xy(1,1,"1"); lcd_string_xy(1,2,"2"); lcd_string_xy(1,3,"3"); lcd_string_xy(1,4,"4"); [/c] Ausgabe ist an der Stelle schonmal eindeutig. 1.Zeile: 4 2.Zeile: 3.Zeile
-
Thread
C array über serielle schnittstelle emfangen
// Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen *Buffer = '\0'; } int main () { char Line[40]; // String mit maximal 39 zeichen uart_gets( Line, sizeof( Line ) ); example[1][2] = Line; //empfangener String in das Array einsetzen } [/c]
-
Thread
Wort über das Terminal an dem uC senden
} // Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen *Buffer = '\0'; } [/c]
> [/c] [c] uart_putchar( '*' ); uart_putchar( NextChar ); uart_putchar( '*' ); [/c] > [c] > // Sammle solange Zeichen, bis: > // * entweder das String Ende Zeichen kam > // * oder
-
Thread
XMEGA Hardware-Bug (Kritisch) Gesperrt
fd cf rjmp .-6 ; 0x2828 <main+0xd0> USARTD0RomString(DoneMsg); 282e: 8c ef ldi r24, 0xFC ; 252 2830: 91 e0 ldi r25, 0x01 ; 1 2832: 0e 94 e2 0b call 0x17c4 ; 0x17c4 <USARTD0RomString
2836: d5 cf rjmp .-86 ; 0x27e2 <main+0x8a> case 'y': USARTD0RomString(TstMsg); 2838: 84 e0 ldi r24, 0x04 ; 4 283a: 92 e0 ldi r25, 0x02 ; 2 283c: 0e 94 e2 0b call 0x17c4 ; 0x17c4 <USARTD0RomString
-
Thread
DMX empfang in C funktioniert nicht richtig.
Strings. DMX Daten sind einfach nur Werte. Die werden nicht als String behandelt.
[c] ... int main() { ... while(arraycomplete==1){ .... } } [/C] nein, nicht weil arraycomplete == 1. Die Hauptschleife läuft IMMER. Aus der kommt der µC regulär nicht mehr
-
Thread
Programmablauf des Drehzahlmesser in C stockt.
Warum machst du das dann? Warum trennst du die beiden Funktionalitäten nicht einfach erst mal: [C] void Messwerte_ausgeben(void) { //Drehzahl auf dem Display ausgeben itoa( drehzahl, lcdDrehzahlString, 10 ); // Das Ergebnis fuer die Anzeige aufbereiten // Messergebnisse auf
Displayausgeben lcd_clear(); set_cursor( 0,1 ); // Gehe zu Pos. XY lcd_string(lcdDrehzahlString); // Datenwert lcd_string("U/min"); // Ausgabe Maske } void Notaus_ausgeben(void) { //Notaus Status auf dem Display ausgeben itoa( NotStatus, lcdNotausString