-
Thread
Funktion erwartet flash unsigned char*
eine Varianten, die Daten aus dem Ram akzeptiert. Aber bevor du das machst, besorgts du dir ein C-Buch, und versuchst zumindest mal die allereinfachsten basics der Sprache (wie z.B. Chars und Strings, und wie groß char-Arrays für Strings sein sollten) zu verstehen (und das, was passiert, wenn man
[/C] lcd_putc ist eine Funktion, die ein einzelnes Zeichen ausgeben kann, einen einzelnen char. Wenn du die hast, dann kannst du sie benutzen um damit eine Funktion zu bauen, die einen String ausgeben
-
Thread
asserts() in C++
Funktionsnamen, damit im Fall, dass zu Laufzeit ein assert failed, der Funktionsname bekannt ist. Wenn Du `strings` auf das binary machst, sieht das dann in etwa so aus: http://robitzki.de/images/pretty_function.png Das ist natürlich bei template meta C++ extremer. Aber ich denke auch bei einer "normalen" Desktop
, damit im Fall, dass zu Laufzeit ein assert failed, der > Funktionsname bekannt ist. Wenn Du `strings` auf das binary machst, > sieht das dann in etwa so aus: > http://robitzki.de/images/pretty_function.png > > Das ist natürlich bei template meta C++ extremer. Aber ich denke auch > bei einer
-
Thread
String an ein Unterprogramm übergeben
"string.h" #include <avr/io.h> #include <stdint.h> #include <i2cmaster/twimaster.c> #define DC1 0x17 #define DC2 0x12 #define ESC 0x1B #define ACK 0x06 #define NAK 0x15 #define NUL 0x00 void
Moin, die for-Schleife wird durchlaufen solange die Bedingung [c]i == len[/c]erfüllt ist. Also genau ein mal wenn der String die Länge 0 hat.
-
Thread
Emfehlung für Config File-Format
#5253589: > Fabian F. schrieb im Beitrag #5253586: >> Außerdem sollte der Zugriff auf die elemente im C-Code möglichst einfach >> von statten gehen (Und nicht jedes mal nach Strings suchen). > > XML ist Text, wie soll das ohne Stringsuche gehen? ICH will nicht nach Strings suchen müssen :-). Wenn
Fabian F. schrieb im Beitrag #5253586: > Außerdem sollte der Zugriff auf die elemente im C-Code möglichst einfach > von statten gehen (Und nicht jedes mal nach Strings suchen). Ich kenne leider auch Leute, die Strings in einer unübersichtlichen riesen sscanf-Monsterkette parsen. Ich mag
-
Thread
avr-gcc 6.3 für Windows
Johann L. schrieb im Beitrag #4980083: > nämlich? Kompiliere mal das [c]const __flash char string1[] = "same string"; const __flash char string2[] = "same string"; char foo(unsigned char i) { return string1[i] + string2[i]; }[/c] mit den Parametern -fmerge-all-constants
#4980159: > Johann L. schrieb im Beitrag #4980083: >> nämlich? > > Kompiliere mal das > > [c]const __flash char string1[] = "same string"; > const __flash char string2[] = "same string"; > > char foo(unsigned char i) { > return string1[i] + string2[i]; > }[/c] > > mit den Parametern
-
Thread
Probleme bei abhängigen Arrays Code
Rolf M. schrieb im Beitrag #7001734: > Das geht allerdings nur in C, nicht in C++. Häää? Warum soll das in C++ nicht gehen? Das sind triviale Arrays mit Strings.
Falk B. schrieb im Beitrag #7001753: > Rolf M. schrieb: >> Das geht allerdings nur in C, nicht in C++. > > Häää? Warum soll das in C++ nicht gehen? Das sind triviale Arrays mit > Strings. Weil die Stringliterale jeweils 6 Bytes groß sind, da sie das abschließende \0 enthalten. In
-
Thread
stm32 HAL UART Receive_IT(.) sendet nur 1 Byte
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
mir bescheid!!! bescheidgesagt wird hier über diese funktion ... wenn du also deine : [c] volatile uint8_t IstWasPassiert = 0; char rxString[100]; uint8_t rxCount; int main(){ uint8_t byte ; HAL_UART_Receive_IT(&huart3, &byte , 1 ); while(1) { if(
-
Thread
Anfängerprobleme
Martin Schmid wrote: > int string; Dem Compiler ist der Name egal, einen String kann die Variable "string" nicht speichern, sondern nur einen int. itoa verlangt ein Array von mindestens 7 Byte ("-32768\0"), also [c] char string[7]; [/c] Und dann schau Dir genau die Argumentenfolge von itoa an. Peter
-
Thread
DOGM - 163 Initialisierung +5V SPI
Zeilen Display, das im 5V mode Betrieben wird ? Und noch eine allgemeine Frage zu deiner lcd_string Funktion, deine while schleife Endet indem sie das Zeichen "\0" bekommt ? Dann muss der Befehl also so lauten ? [c] lcd_string("Hello World!\0");[/c] Vielleicht hat ja noch jemand anders
Display ist? DogM163 S-A [c] int main(void) { lcd_init(); char* string = "Hallo Welt :-)"; lcd_string(string); while (1) { asm volatile ("nop"); } return 0; } [/c] MfG
-
Thread
AVR warum braucht String RAM?
ernst gemeint da ich mich selten mit Attinys beschäftigt habe, welche sehr begrenzten RAM haben. [c]void uart_string(const char *s)[/c] Rufe ich obige Funktion mit einem String auf, wird dieser im Flash abgelegt und nutzt laut AtmelStudio7 ebenfalls die gleiche Anzahl an Bytes. Bei einem Aufruf
Thadeus Kobisky schrieb im Beitrag #6837594: > [c]void uart_string(const char *s)[/c] > [/code] > Warum wird hier der RAM ebenfalls genutzt obwohl das Schlüsselwort const > benutzt wurde? Bin hier gerade etwas überfragt, warum in einer solchen
-
Thread
zeichen im String umwandeln
...und schon wieder ich hab ne Zeichenkette z.B. String "500040C90...." Bei den Zeichen 0C handelt es sich um eine Hex Zahl (d12). Jetzt möchte ich die Hex 0C nach "kette" kopieren. Beispiel: int k;i; char kette[3]; i=5; //sollte die 0 von 0C sein kette[k]=string[i]; k++;i++; kette[k]=string[i]; Jetzt hoffe ich,daß in dem String "Kette" 0C steht. Nun steht ja i auf C vom string und ich möchte i jetzt um 12 stellen erhöhen. Wie stell ich es am besten
-
Thread
Hex in Char casten und ab aufs Display
Geht ein [c]lcd_string(uart_string);[/c] nicht? Gibt es kein lcd_char ? Und wenn das gar nicht geht, dann kann man zumindest auf das sprintf verzichten [c]char temp[2] = {0}; for (i=0; i < size; i++) { temp[0] = uart_string[i]; lcd_setcursor(i, 2); lcd_string(temp); }[/c]Das wird nicht das Leerstellenproblem beheben.
-
Thread
Binäre Konstanten in C
C++ kann das schon lange....
0b00001111 direkt in den Variablen ablegen könnnen oder kommt noch mehr dazu? (z.B. %b für Format-String bei printf-Funktion - wie %x für die Hex-Zahlen oder %o für die Octal-Zahlen usw.) Sonst macht es ja wenig Sinn PS: Seit wann können die C-Programmierer keine 16 Hex-Zahlen merken? ;-)
-
Thread
Framebegrenzer mit Atmega8
Daniel Kehr wrote: > Hmm, wo ist da der Unterschied? Ich programmier den Controller nunmal in > C und da weis ich nicht wie das geht. Timer gehören nicht zum C-Sprachumfang und daher gibt es auch keine Timerfunktionen in C. Du hast auf dem AVR auch kein OS, welches Dir Systemcalls zur Verfügung
mov [bx],al jmp rd_str rd_str_ende: inc bx mov cx, 0 mov [bx], cx pop cx jmp int21h_e ;###String einlesen ende iret rd_string_lenght: mov cx, 0 rd_string_lenght_start: ; Einen String ausgeben: lodsb ; Byte laden or al,al jz short rd_string_lenght_ende ; 0-Byte? ->
-
Thread
char in ein string
unsigned char uhrzeit[3]; //jetzt irgendwie die uhrzeit in die variablen //mit sprintf in einen String schreiben sprintf(text,"%d:%d:%d",stunden,minuten,sekunden); oder sprintf(text,"%d:%d:%d",uhrzeit[0],uhrzeit[1],uhrzeit[2]); //Im Dispaly anzeigen z.B. display_put_string(char *text) display_put_string
Stunden / 10 + '0'; Text[1] = Stunden % 10 + '0'; .... Im Endeffekt entsteht in Text ein String, der dann ganz normal als String ausgegeben werden kann. Genauso wie auch sprintf den String befuellt.
-
Thread
ELM327 mit Arduino steuern
Mir geht es speziell um meine String readOBDId(String id, int numBytes){ Methode. Kann man das beim uC so machen? Kann es erst morgen mit dem Teil http://www.amazon.de/dp/B00FLL8OZG/ref=pe_386171_38075861_TE_item testen
the OBD-II-UART > readOBDId("ATZ\r", 0); > delay(5000); ausgeben, also [c] String result; result = readOBDId("ATZ\r",12); softwareSerial.print(result); [/c] Frag mich nicht, ob die Syntax stimmt, ich bin Arduino Ignorant. Aber dann weisst du zumindest, ob die
-
Thread
uint16_t 2 byte in LCD anzeigen
lcd_data(LCDZahl); long_delay(300); //rdbyte = exEEPROMRead(adbyte); lcd_clear(); lcd_string("ADD: "); lcd_string(LCDZahl); lcd_setcursor(0, 2); lcd_string("Wert: "); lcd_data(rdbyte); wait_ofkey(); } [/c]
Also wenn ich die Funktion enter() so lasse und einen String zurückgeben könnte ich mit dem Code http://home.htw-berlin.de/~junghans/cref/EXAMPLES/exponent.c#atoi den String in eine Zahl umwandeln. Ich verstehe nur nicht wie der Code funzt. Hilfe ich dreh durch
-
Thread
EEPROM bei Atmega 8
Wie sieht denn die Funktion aus? So: [C] char eeRead(uint8_t * adresse) [/C] Welches Argument will sie haben? Speziell: welchen Datentyp? Wie rufst du sie auf? [C] eeRead(1) [/C] Nun: eeRead will einen uint8_t * haben
putChar(eeRead((uint8_t*) 1)); } } [/c]
-
Thread
Probleme bei Programmausführung
return (0); } [/c]
Ich hab mittlerweile herausgefunden das er mit dem ADC_interrupt so seine Schwierigkeiten hat. [c] int main() [...] sei(); while(1) { //1. Zeile löschen lcd_setcursor( 0, 1 ); lcd_string(" "); lcd_setcursor( 0, 1 ); //Ausgabe der gewählten
-
Thread
UART Auswertung
Zeichen hinten drann und du hast einen String. Abgesehen davon macht strlen sowieso nicht das, was du denkst was es macht. Denn um strlen anwenden zu können, müsstest du schon einen String haben. [[String-Verarbeitung_in_C]]
else { UARTString[s] = c; s++; // s erhöhen if (c == ETX){ // Endzeichen des Strings empfangen? u8UARTEmpfangAuswerten = TRUE; // Flag setzen, dass String vollständig empfangen und zur Auswertung
-
Thread
Arduino: String Objekt aus Funktion zurückgeben
sowas schnell macht. das sag doch mal bitte wie er das macht? Meines wissen ist es mit neue C++ standard definiert das er keine Kopie von string machen braucht. Oder hoft du darauf der String selber eine referenzcounting macht?
irgendwie geht in Form von Initialisierungen durchführen anstatt Variablen ständig rumlungern zu haben. In C++ ist es völlig normal for( i = 0; i < 10; ++i ) { String s( i ); mach was mit s } zu haben, und so scheinbar innerhalb der SChleife laufend Objekte zu erzeugen und
-
Thread
seriell FTDI TTL UART SUART ich blicke nicht mehr Durch!
die nicht in die gleiche Richtung zählen bzw. schieben für den Vergleich auf gleicher Bitposition? [c] / /Könnte man nicht für char c = opt_s[optlen]; // lieber den Index i verwenden? char c = opt_s[i]; [/c] [c] unsigned option_s (unsigned ist) { // decode -s string // format: 01xx10
break; default: fprintf (stderr, "ERROR: unknown character in -s option: %c\n", c); } maske <<= 1; } if (optlen > 0) fprintf (stderr, "WARNING: -s option string too long\n"); return toggleData; } [/c]
-
Thread
Parameterübergabe an eine Funktion
string nicht korrekt übergeben. Mein Programm sieht so aus: [c] int Funktion (char* string1, char* string2) { char str1[30], str2[30]; strcpy(str1, string1); strcpy(str2, string2); //hier
Also, bei mir mit dem GCC geht das so ohne Probleme... [c] void sendString (char * string1, char * string2, char * string3) { // blablabla } sendString ("Hallo", "Welt", "!"); [/c]
-
Thread
uart ausgabe: Speicherverständnis
Millionen Zeichen ein!"); [/c] ... dann ist ruckzuck Dein RAM verbraucht. Wenn Du aber das Macro PSTR(s) verwendest, dann verbleibt der String als Konstante im Flash. Dann musst Du aber schreiben: [c] uart_puts_P (PSTR("Bitte geben Sie einen String in Kleinbuchstaben, mindestens aber siebenhundertvierundachtzig Millionen Zeichen ein!")); [/c] ... da der Übergabeparameter hier ein anderer ist. uart_puts_P() erwartet einen String mit der Adresse
-
Thread
[c] sizeof(enum) bestimmen?
Also ich habe mal probiert: [c] enum E {eX, eY, eZ, eAnzahl}; uint8_t A[eAnzahl]; [/c] das nimmt der Compiler ohne zu murren.
Klaus Wachtler schrieb im Beitrag #2266863: >> Ne, ne, das ist ein eigener Datentyp. > > Nicht in C, aber in C++. Doch, auch in C. Klaus Wachtler schrieb im Beitrag #2266863: > als C kompiliere (ANSI-C), läuft es klaglos durch. Das ist doch kein Argument. Dass man jeden beliebigen Integer
-
Thread
PIC C18 String direkt als Parameter übergeben
Abend, folgendes Problem: ich möchte einer Funktion einen String direkt übergeben, ohne diesen vorher deklariert zu haben. also so: [c] WriteStringXLCD("test"); //so geht's nicht [/c] die Funktion: [c] void WriteStringXLCD(char *buffer){ char
funktioniert der Funktionsaufruf: [c] char testString []="test"; //so funktionierts WriteStringXLCD(testString); [/c] Hat einer Idee, wie ichs die Funktion verändern muss, dass es geht, oder ob das überhaupt mit dem C18 Compiler
-
Thread
attiny2313 Timer0 - Digitale Uhrzeit
unsigned char temp; lcd_clear(); lcd_setcursor(2,4); itoa(hours/10,temp,10); lcd_string(temp); itoa(hours%10,temp,10); lcd_string(temp); lcd_string(":"); itoa(minutes/10,temp,10); lcd_string(temp); itoa((minutes%10),temp,10); lcd_string(temp); lcd_string(":
unsigned char temp; lcd_clear(); lcd_setcursor(2,4); itoa(hours/10,temp,10); lcd_string(temp); itoa(hours%10,temp,10); lcd_string(temp); lcd_string(":"); itoa(minutes/10,temp,10); lcd_string(temp); itoa((minutes%10),temp,10); lcd_string(temp); lcd_string(":
-
Thread
werbserver uip easyweb datenaustausch ethernet arm
berechnet werden. Zum Beispiel Variable i enthält eine Integer zahl, die soll als Menschen-Lesbarer String gesendet senden. Also ist der String zur Laufzeit berechnet. Da hast du zwei Möglichkeiten: 1) Wandle die Zahl mit sprintf in einen String um, speichere den String in ein Array und sende ihn mit
+udp - funktioniert jetzt. Wesentlicher Fehler war die fehlende Definition der UDP-Verbindung [c] uip_ipaddr_t addr; struct uip_udp_conn *c; uip_ipaddr(&addr, 192,168,0,124); c = uip_udp_new(&addr, HTONS(67)); if(c != NULL) { uip_udp_bind(c, HTONS(67)); } [/c] Frage
-
Thread
welche Signale liefert ein Handy an TX
Laufendem Programm '################################################# ' http://www.comwebnet.de (c)2005 '############################################### $regfile = "m16def.dat" $crystal = 16000000 $baud = 19200 Declare Sub Getline(s As String) Declare Sub Flushbuf() Declare Sub
String * 2 ' Scharf on/off Config Pinb.0 = Input Portb.0 = 1 ' Spg-Überwachung Config Pinb.1 = Input Portb.1 = 1 ' Alarm Meldelinien 1-4 mit pullup R im µC Config Pinc.0 = Input Portc.0
-
Thread
Umwandlung von ASCII-Zeichen, die Hexzahlen darstellen
Hallo zusammen, ich möchte gerne ASCII-Zeichen eines Strings, die Hexzahlen dastellen, in Dezimalzahl umwandeln. Also: Buffer[4]== '2' Buffer[5]== '7' Buffer[6]== '1' Buffer[7]== '0' 2710(hex) = 10000(dec)! wie kann ich das am besten in C bewerkstelligen
10=58, da bei gerader Stellenzahl wert hier negativ ist } [/c] Statt putch kann ein neuer String aufgebaut werden: s=s+c;
-
Thread
Zeitmessung mit TIMER Atmega8
125 OCR1A = 125-1; TIMSK |= (1<<OCIE1A); } void Anzeige(int sekunden) { char string[20]; itoa( sekunden, string, 10 ); lcd_clear(); lcd_setcursor( 0, 1 ); lcd_string(string); } int main(void){ DDRB = 0x00; PORTB = 0x00; TIMER1_interrupt_init();
OCR2 = 70; //Vergleichswert für Interupt } void Anzeige(int sek, int msek) { char string_sek[4]; char string_msek[4]; itoa( sek, string_sek, 10 ); itoa( msek, string_msek, 10 ); lcd_setcursor( 0, 2 ); lcd_string(string_sek); lcd_setcursor( 2, 2 ); lcd_string(",
-
Thread
! Vorsicht NEWB 7-Segmentanzeigen via PC ansteuern
Wenn ich as bauen würde, würde ich pro Zeile einen µC nehmen um ein paar segmentanzeigen zu Multiplexen. Der Master µC sendet die Anzuzeigenen Werte jeweils per Software UART an den jeweiligen Anzeige µC. So habe ich es bei meinem Digitaltacho gemacht
selbe Adresse, legen wir ein Feld, das genauso lang wie der String ist. Das ist alles. Der Trick ist nur, daß wir beim Füllen des Strings in unserem Anwendungsfall am effizientesten mit einem Feld arbeiten können, während in anderen Fällen die Arbeit mit einem String
-
Thread
AVR Tutorial Frage: Lesen vom Flash
GCC-Attribut progmem, mit dem eine Variablendeklaration im static storage[5] markiert werden kann: [c]const int value __attribute__((progmem)) = 1;[/c] Effekt ist, dass die so markierte Variable nicht im RAM sondern im Flash angelegt wird. Wird durch "normalen" C-Code auf solch eine Variable zugegriffen
von mir/dir engefügten Kommentare auch raus Die nachfolgende Funktion liefert 0 zurück, wenn string_im_ram gleich "Hallo Welt" ist. Mit strcmp (String Compare) können wir zwei Strings vergleichen. Der Rückgabewert kann hierbei folgende Werte haben: 0 die Strings sind gleich >0 das erste
-
Thread
Array Zuweisung
>Es müßte also so: >char zeichen[5] ={'A','B','C','D','\0'}; >lcd_print(0,0,"%s",zeichen[2]); >gehen???? Nein. Eben nicht. %s erwartet einen Zeiger auf einen String und kein Zeichen. Mit "zeichen[2]" übergibst Du aber ein Zeichen.
Also bleibt auch die Möglichkeit, das das Array nur ein Beispiel ist, aber wofür? Für einen String oder für Einzelzeichen? Demnach ist es fraglich ob die Nullterminierung und der fehlende &-Operator das Problem ist, damit der String richtig ausgegeben wird oder der Ersatz von %s durch %c, damit
-
Thread
neues WinAVR macht Probleme
/* e */ lcdtxt(0x6E); /* n */ lcdtxt(0xA0); /* */ lcdtxt(0xA0); /* */ } [/C] ist nicht wirklich wartungsfreundlich :-) [C] void lcdtxt_string( const char* string ) { while( *string++ ) lcdtxt( *string ); } void aussen() { lcdtxt_string( "3 aussen " )
Karl heinz Buchegger wrote: > [c] > void aussen() > { > lcdtxt_string( "3 aussen " ); > } > [/C] Nicht ganz. [c] #define NBSP "\xa0" ... void aussen(void) { lcdtxt_string("3" NBSP NBSP NBSP "aussen" NBSP NBSP
-
Thread
Pointer Gymnastik Ist mein Code zulässig?
Hallo zusammen Ich habe folgenden Code: [c] char *copy_from_until(unsigned char from, char until_sign, char *SearchIn) { char TempString[20]; char *pTempString; pTempString = TempString; SearchIn += from; //Offset definieren
der Startoffset vom übergebenen String und ein EndZeichen! Meine Frage bezieht sich nun auf den return Befehl. [c] return pTempString; [/c] Ist es zulässig, dass ich einen Pointer auf eine Funktions-lokale Variable zurückgebe
-
Thread
String innerhalb und ausserhaln von Funktionen
: Vorname: %s\n", innen->vor); strcat(innen->vor,"Gabi"); printf("expandString2: Vorname: %s\n", innen->vor); strcat(innen->nach,"Blaubeere"); printf("expandString2: Vorname: %s\n", innen->vor); printf("expandString2: Nachname: %s\n", innen->nach); } expandString2
vor); // strcat(innen->nach,"Blaubeere"); innen->p_nach = "Blaubeere"; printf("expandString2: Vorname: %s\n", innen->vor); printf("expandString2: Nachname: %s\n", innen->nach); } Ergebnis: expandString2: Vorname: ‰ðg expandString2: Vorname: ‰ðg expandString2: Vorname: ‰ðg expandString2
-
Thread
stdint.h, string.h Datentyp "Char"?
Datentypen sollte auch mit Typecasts gearbeitet werden. Das Problem entsteht dadurch, dass ich die string.h (auch C99 oder?) verwende. Hier möchte ich die Funktion strnlen() verwenden. Diese ist definiert durch "size_t (strnlen,(const char *, size_t));". So jetzt arbeite ich aber nur mit den Typen aus
schonmal mit 16Bit unicode chars zu tun hatte. Wobei mir persönlich diese nur aus Java und nicht aus C bekannt sind. Bei dem int8 kann ich auf jeden Fall von 8 Bit ausgehen... Ich habe Speicherbereiche in denen "irgendwelche Werte" oder aber auch ein String liegen kann. Wird durch eine Struct verwaltet
-
Thread
C++ Pendant zu #define
Hallo zusammen, gibt es ein C++-Pendant zu der #define Direktive? Ich wollte letztens ein einfaches C-Programm in C++ umschreiben. Das Probem ist, dass #define ohne Datentyp arbeitet. In C++ würde ich das Konstrukt "const datatype name" verwenden, aber wie mache ich das z.B. mit folgender Zeile: [c]#define LED_PORT PORTB[/c] In C++ könnte das so aussehen: [c]const string LED_PORT = "PORTB";[/c] Aber C kennt doch gar keine Strings.
-
Thread
Fehler beim Schreiben einer LCD Library auf ATmega16
Ist ja interessant. Da gibt es eine Funktion namens 'send_string' [C] void send_string(char input) { uint8_t output; output=(uint8_t)input; write_data(output); } [/C] die einen einzelnen Character am LCD anzeigt aber sicher keinen String. Klarer
deinen Benutzer mit nicht passenden Funktionsnamen'. Dafür gibt es eine Funktion namens 'split_string', die dem Namen nach einen String in Einzelteile zerlegt (splittet), aber dem Code nach den String auf dem LCD ausgibt [C] void split_string(char *input) { while(*input!='\0') { send_string
-
Thread
C unsigned char |->const unsigned char *
hi wie wärs mit: [c] uc=&wert; [/c] anstatt: [c] uc=&str1; [/c]
> const unsigned char* uc; > long int zahl; > int Base=16; > uc=&str1; warum str1 ? Dein string steht doch in wert! [C] unsigned char wert[]="FF" long int zahl; zahl = strtol( wert, NULL, 16 ); xputi(zahl); [/C] oder, wenn manns ganz sauber machen will: [C] unsigned
-
Thread
JSON Objekt Feld erzeugen und auswerten
WSpeed; /* Windgeschwindigkeit */ int CloudsAll; /* Bewölkung in % */ String DateStamp; /* Zeitstempel als String */ String WetterText; /* Wetter als Satz */ } wetter_t; wetter_t wetter[10] = {0,}; [/c]
speed"]; wetter[i].WSpeed *= 3.6; wetter[i].CloudsAll = list[i]["clouds"]["all"]; String foo1 = list[i]["dt_txt"]; wetter[i].DateStamp = foo1; String foo2 = list[0]["weather"][0]["description"]; wetter[i].WetterText = foo2; } [/c]
-
Thread
Code Block Marker in C
Ich finde, sie machen das Gegenteil von dem was gut geschriebener Code sein sollte: gut lesbar! [c] int main(void) { system_init(); //! [setup_init] configure_usart(); //! [setup_init] //! [main] //! [main_send_string] uint8_t string[] = "Hello World!\r\n"; usart_write_buffer_wait(&usart_instance, string, sizeof(string)); //! [main_send_string] //! [main_rec_var] uint16_t temp; //! [main_rec_var] [/c]
-
Thread
Wie Strings aus dem PROGMEM holen
YEAH it works!!!! [c] char string_0[] PROGMEM = "Dies ist im"; char string_1[] PROGMEM = "Programmspeicher"; char string_2[] PROGMEM = "gespeichert"; char string_3[] PROGMEM = " Hallo Welt! "; char string_4[] PROGMEM
zu verschieben. Aber zu Dokuzwecken. Wie hast du denn hier [C] PGM_P string_table[] PROGMEM = { string_0, string_1, string_2, string_3, string_4, string_5, string_6, string_7 }; [/C] ausgedrückt, dass string_table ein
-
Thread
Zahlen als Zahl und String als ASCII in ein Array
in dem Array > drinsteht: > > string: [7,2, ,a,b,c,d]; Moment. Soll das erste Byte den Wert 7 oder den Wert 72 haben? Der erste zitierte Satz scheint genau letzteres anzudeuten char string[7] = { 72, ' ', 'a', 'b', 'c', 'd'
Plätzen mein String beretis > ASCII-codiert? > char string[] = {7,2,' ','a','b','c','d','\0'}; Verdammt zu langsam Karl Heinz Buchegger schrieb im Beitrag #2865514: > char string[] = { "H abcd" }; > >
-
Thread
Frage zu delay (wie bekomme ich genau 1 Sekunde)
(1,10, "setze Ausgaenge......"); // _delay_ms(1500); g_draw_string(1,10, "setze Ausgaenge......ok"); _delay_ms(1500); g_draw_string(1,20, "hole Sensoren.."); // _delay_ms(1500); g_draw_string(1,20, "hole Sensoren...."); // _delay_ms(1500); g_draw_string(1,20, "hole Sensoren....ok"); _delay_ms(1500); g_draw_string(1,30, "starte Menue.."); // _delay_ms(1500); g_draw_string(1,30, "starte Menue...."); // _delay_ms(1500); g_draw_string(1,30, "starte Menue......"); // _delay_ms(1500); g_draw_string
-
Thread
lcd string "ü" darstellen.
braucht man an der verwendenden Stelle überhaupt nichts tun, der 'LCD-String-Treiber' erledigt die Anpassung [C] void lcd_string( const char* text ) { char c; while( ( c = *text++ ) ) { if( c == 'ü' ) lcd_data( 0x5F ); else lcd_data( c )
"); lcd_string( Out ); lcd_string( "Belüftung ist ein" ); [/C]
-
Thread
GSM Modem AT-Befehl
" vom Modem quittiert. "\x0d" ist eine Schreibweise, um das Steuerzeichen 0x0d gleich in den String mit einzupacken. Wenn ich also schreibe unsigned char string[]="ATZ\x0d"; dann enthält "string" insgesamt 5 Zeichen: A,T,Z,das Steuerzeichen 0x0d, und die 0-Terminierung. > ISR(USART_UDRE_vect
eigentlich nciht liegen, ich stecke ab und zu mal wieder den Hyperterminal an im zu sehen was der µC macht, und der schickt fein den String und wenn ich dann Antworte (über Hyperterminal) sehe ich das auch im Programm "glob_USART_gesendet" ist nur ne vari damit der während ich auf die ISR warte kein
-
Thread
Projekt: Pascal-Compiler für AVR Gesperrt
Hi >1) Pascal-to-C converter > Also Pascal-source nach C/C++ konvertieren und dann mit gcc-avr >fertigstellen (lassen). Ich halte Pascal als durchweg gleichwertige Sprache zu C. Also wozu? MfG Spess
Rudolf Grobe schrieb: > 1) Pascal-to-C converter p2c
-
Thread
lcd_write Fehlersuche
habe jetzt auf [c] u8 tst[]="wzb vl rl t0 t1 thm elt az "; lcd_goto(25,1);lcd_write(tst); [/c] geändert. Der im Ram abgelegte String wird korrekt geschrieben. Es ist also kein Problem mit der Funktion
0 ); Das Problem mit dem Leerstring lässt sich leicht lösen, indem man stattdessen schreibt: [c] while ( *str != '\0' ) { .... } [/c] Man sollte beim "Durchwandern" eines C-Strings *immer* eine while- und keine do-while-Schleife nehmen.