-
Thread
Vorteile 32 Bit Controller
eben um diese > Attributvergabe kümmert. Tut er das? Wie sieht dein Aufruf printf("%s %s %s", string1, string2, string3) aus, wenn - der Formatstring im ROM liegt, - die Variable string1 im RAM liegt, - die Variable string2 im ROM liegt, - von der Variablen string3 nicht bekannt ist, ob sie in
Compiler erkennt das natürlich nicht automatisch. Aber er erkennt ja auch nicht bei printf("%s %d","string_var,int_var); die Variablentypen. Ist ein ähnlicher Fall. Da ist C halt beschränkt :-( Und auf der Ebene betrachtet finde ich, nimmt der Compiler einem auch Arbeit ab, wenn es um Speicherbereiche
-
Thread
DS1820 reagiert garnicht, C Programm fehlerhaft? Sensor defekt?
[c] ... schreibe('T'); schreibe(':'); schreibe(' '); ... [/c] ist doch grober Unfug. Einen String an ein LCD auszugeben braucht praktisch jedes Programm. Daher schreibt man sich eine Funktion, die das kann [c] void lcd_string( const char* str ) { while( *str ) schreibe( *str++ ); } [/c] und benutzt die dann: [c] ... lcd_string( "T: " ); ... [/c] aufbauend auf der String Funktion
-
Thread
Array/String Länge ermitteln ohne NULL am Ende
Hallo, wie kann ich in C (nicht C++) die Länge eines Arrays/Strings ermitteln wenn in den Nutzdaten alle Werte zw. 0-FF Verwendung finden? Hintergund es geht um das versenden von Daten im TP2.0/KWP CAN-Protokoll. Die Länge
zählst (ha!) und eine Zeichenkette der Länge dieser Summe anlegst, und die einzelnen hineinkopierst: [c]char string1 [] = "01 02 03"; char string2 [] = " 04 05 06"; char gesamt [sizeof (string1) + sizeof(string2) - 1]; memcpy (gesamt, string1, sizeof(string1)-1); memcpy (gesamt+sizeof(string1)-1, string2
-
Thread
String to long integer
Jetzt versehe ich nichts mehr... Ich habe folgendes: [c] char ausgabe[7]; // z.B. 9999999 unsigned long var; [/c] jetzt wandle ich den String in long interger um [c] var=atol(ausgabe); [/c] habe also in var den Wert 9999999 also long integer.
Weil ein String in C immer mit einem Nullbyte abgeschlossen wird. 7 Zeichen (z.B. die '9'-en) und die abschließende 0 macht 8 Feldelemente. -> elementare Grundlagen C
-
Thread
Pointer auf String im Flash
Hallo, ich habe ein Problem mit dem zeichenweise auslesen eines Strings aus dem Flashspeicher eines AVR. Den Text im Flash habe ich so angelegt: [c] const char h1[] PROGMEM= "Hallo, ich bin aus dem Flash"; [/c] Die Zeichen sollen über die serielle Schnittstelle ausgegeben
, was jedoch nicht funktioniert: [c] char *ptr_h1; ptr_h1 = h1; while (*ptr_h1) { zeichen = pgm_read_byte(ptr_h1); uputchar(zeichen); *ptr_h1++; } [/c] Dann werden bei mir teilweise Zeichen gesendet die im String
-
Thread
Gute Pufferlösung zwischen ISR und Mainloop
Wenn Du nicht mit jedem Byte sparen mußt, danmn würde ich z.B. ein Feld von 10 Strings zu je 64 Byte anlegen. Dieser Strings verwendest Du zylkisch, wie einen Ringbuffer. Ein Pointer zeigt jeweils auf den nächsten freien String in den die seriellen Kommandos abgelegt werden und auf den String, den der Mainloop als nächstes Abarbeiten soll. Klaus
-
Thread
Strings für LCD im Flash ablegen
/c] Nur weis ich nicht ob hier noch PROGMEM fehlt was in den Beispielen beim Arrayaufbau verwendet wird Die Strings sind wie folgt definiert [c] const char MT01_001[] PROGMEM ="123456"; const
im Flash ist, an der der String abgelegt wurde. Also kannst du mittels strcpy_P den tatsächlichen String von dort holen. [C] strcpy_P(M01_String, pstrflash01); [/C] M01_String muss als char Array natürlich groß genug
-
Thread
Hilfe bei Char[] und Verarbeitung
Servus, probier mal: char sendepuffer[20]; sprintf(sendepuffer,"\r\nEmpfang: >%c",uart_string); uart_puts(sendepuffer); Für den Fall eines C-Strings %s statt %c nehmen. Gruß, Jonas
%c ausgeben. Das geht nur mit uart_string[0]. Wenn schon, dann eher sowas: [c] #define PUFFER_GROESSE 20 size_t laenge; char sendepuffer[PUFFER_GROESSE]; strncpy(sendepuffer, "\r\nEmpfang:
-
Thread
falsche Zuweisung
} } [/c] Damit wartet man darauf, dass der Sendebuffer bereit ist, und schickt jeweils das nächste Zeichen eines Strings. Genaugenommen schreibt man sich eigentlich eine [c] void sendchar(char c); [/c] die dieses Low-Level-Handling übernimmt, und füttert die mit Daten (z.B. aus fputc, einer SendString, o.ä. VG, /th.
-
Thread
C++ statische Template-Variablen Spezialisierung
So müsste es gehen: foo.h: [c] #include <string> #include <typeinfo> template<class T> struct C { static std::string classname; }; template<class T> std::string C<T>::classname = typeid(T).name(); extern template std::string C<int>::classname; [/c] foo.cpp: [c] #include "foo.h" template<> std::string C<int>::classname = "int"; [/c] D.h., C<int>::classname wird in foo.h als explizite Template-Instantiierung deklariert
-
Thread
C: format+va_list für printf zwischenspeichern und (viel) später abarbeiten?
formatierten Text in outputbuffer schreiben. cnt = vsprintf(outputbuffer, format, args); // Formatierten String über RS232 ausgeben. RS232_Write(outpufbuffer, cnt); [/c] Gibt's da was? Vielen Dank im Vorraus
Ich seh keine Möglichkeit die deutlich schneller wäre als ein sprintf. allein schon ein [c] printf("String: %s\nPointer: 0x%x\n",charpointer, charpointer); [/c] ist ein Problem: du hast zweimal denselben wert im va_args, einmal musst du aber ein strcopy (Wohin?) laufen lassen, einmal nur
-
Thread
switch-case mit 4-Byte-Strings
[c] char string[5] = "abcd\0"; if(!strcmp(string, "ABCD")) { } else if(!strcmp(string, "BCDA")) { } else if(!strcmp(string, "DBCA")) { } ... ... [/c]
die Preprozessor ist es egal wo er etwas ersetzt, Fast. Die Frage ist, ob er auch innerhalb von Strings ersetzt: [c] #define f(a) a 'a' "a" f(x) [/c] ergibt beim GNU CPP [c] x 'a' "a" [/c]
-
Thread
Probleme mit pgmspace. ATMega1284P hangt sich durch strcpy_P auf
BadInt() füllen. Das können 0-Bytes vorkommen, oder meist eben auch nicht. Danach kommen dann (falls C++) Adressen der Initialisierungsroutinen für globale Objekte. Dann eventuell benutzte PROGMEN Strings. Letztere würden die Kopierwut von strcpy_P() bremsen, aber da ist es sicher schon zu spät.
Länge muß zusätzlich mitgegeben werden, andernfalls kommt die Länge aus der Quelle, und zwar nach der C-String-Konvention "endet mit '\0'".
-
Thread
Motordrehzahl eingeben Arduino
warum einfach machen, wenn es kompliziert geht: Nimm für die Umwandlung von... ... Integer in String: http://www.cplusplus.com/reference/cstdlib/itoa/ ... String in Integer: http://www.cplusplus.com/reference/cstdlib/atoi/ Ist alles schon in C/C++ vorhanden
Serial.available()) } // void serialEvent() void loop(void) { // was so zu tun ist if(stringComplete) { inSTR_Auswertung(); stringComplete = false; } // if(stringComplete) } // void loop(void) [/c]
-
Thread
Usart (Fleury) Übertragungsprobleme.
all: $(TARGET) uarttest.hex uarttest.eep uarttest.lss size ## Compile uarttest.o: ../uarttest.c $(CC) $(INCLUDES) $(CFLAGS) -c $< uart.o: ../uart.c $(CC) $(INCLUDES) $(CFLAGS) -c $< glcd-Display3000-211.o: ../glcd-Display3000-211.c $(CC) $(INCLUDES) $(CFLAGS) -c $< font_f-5x8
74 00 [c]/* Programmkopf mit Headerdateien*/ #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #include <util/delay.h> #include <string.h> #include <stdio.h>
-
Thread
strtol Problem (Ergebnis ist immer MAX_LONG)
Wimplicit-function-declaration]incompatible implicit declaration of > built-in function 'strcpy' main.c Dann solltes du #include <string.h> noch einbinden.
Also auch so [c] #include "stdlib.h" #include "string.h" int main(void) { char temp[10]; strcpy(temp, "0x000A"); long test = (long)strtol(temp, NULL, 16); if (test == 0) {
-
Thread
Probleme bei UART Auswertung
noch immer nicht. [c] void Befehl() { uint8_t bufferzaehler = 0; uint8_t string_complete=1; char c; do { c = uart_getc(); if( c != UART_NO_DATA ) { if(c==35)
] = '\0'; break; } Befehlsbuffer[bufferzaehler++] = c; } string_complete=0; } } }while(string_complete); } [/c] Vielen Dank Josef
-
Thread
strings confusion
heißen (wegen null-terminiert)... dann sollten alle dasselbe liefern, wenn mich meine minimalen c-kenntnisse nicht täuschen... wie "greiftst" du denn auf die strings zu?
value in R17 cpi R17, 0x00 ; if null character -> end of string breq end_of_string .... usw funktioniert einwandfrei - mit a c'ya Dom
-
Thread
Displayausgabe langsam trotz 16Mhz
Rush. schrieb: > Programm in C geschrieben Schau mal in Zeile 42. Da scheint etwas nicht zu stimmen. A.L.U.
); extern void lcd_clear(void); extern void set_cursor(uint8_t x, uint8_t y); extern void lcd_string(char *data); extern void lcd_led(uint8_t a); int main(void) { lcd_init(); lcd_string("alsdjadsf"); } [/c] und es ist immer noch so lahm. Einen anderen Port habe ich eben auch mal
-
Thread
Wann Compiler-Optimierung in Embedded ausschalten
folgende beiden Programmstücke: [c] fputs("abc", stdout); [/c] und [c] putchar('a'); putchar('b'); putchar('c'); [/c] Wie bewertest du die nun? Strenggenommen könnte der Compiler aus beiden Programmen denselben Maschinencode
0; } [/c] Ohne Optimierung -> 12 Mit Optimierung -> 1 Lässt man das 'K' im ersten String weg, gibt das Programm auch ohne Optimierung 0 aus, d.h. die beiden Pointer zeigen auf dasselbe Objekt.
-
Thread
Stack-Überlauf durch externe Variable?
/articles/AVR-GCC-Tutorial#Vereinfachung_f.C3.BCr_Zeichenketten_.28Strings.29_im_Flash > > Und es gibt noch ein großen String für die variablen Ausgaben. > char sendstring[40]; > Das ist aber schon die größte und die wird ja auch nicht beeinflusstr
Mit bisschen Geschick kannst du das einfacher schreiben als: [c] send_string_uart0_P(PSTR("Press any key to continue")); [/c] Der _P-Suffix ist dabei die übliche Kennzeichnung dafür, dass die Funktion einen progmem-String bekommt. Die Funktion ist dabei selbst
-
Thread
string und/oder array in c bearbeiten
0'; printf("%s\n",wort); strcpy(worter[c], wort); b=i+1; c++; } } return 0; }
oh gott Vielleicht erstmal ein C-Buch durchackern? Ansonsten: strtok() verwenden
-
Thread
Parser für Strings in C gesucht
Moin, ich suche einen Parser in C, mit dem ich einen String der Form: < get="L" dat="1" id="42" /> in die einzelnen enthalten Tokens zerlegen kann. Insgesamt gibt es 9 verschiedene Token, die unterschieden werden müssen. Hat
Kommandos werden, wobei die Syntax stark an XML angeleht sein soll. Und das ganze soll/muß auf einem µC laufen. Ein kompletter TopDown Parser braucht es auf jeden fall nicht werden. Ich habe nur die folgenden Schlüsselwerte, die im String vorkommen können: "get", "set", "dat", "id", "cmd", "val"
-
Thread
UART empfängt nur einmal.
; StringLen++; NextChar = ser_getc(); } // Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen *Buffer =
+ = NextChar; StringLen++; } while (StringLen < MaxLen-1); *Buffer = '\0'; } [/c]
-
Thread
Sonderzeichen in String für LCD-Display
Hallo, ich habe mir zwei Unterprogramme für die Ansteuerung eines LCD-Displays geschrieben. [c]string_senden(); //sendet einen String aufs Display zeichen_senden(); //sendet ein einzelnes Zeichen ans Display[/c] Die beiden Programme funktionieren einwandfrei. Wenn ich allerdings einen String
: [c]string_senden("Programm w" zeichen_senden(0xE1); string_senden("hlen")[/c] Allerdings ist das etwas umständlich. Gibt es eine Möglichkeit, den String in einem Aufruf zu senden. printf und solche
-
Thread
Firmwareinfo im Flash / hexfile
Ich schreibe mir ein _version.c: [c] #include <avr/pgmspace.h> prog_uint8_t Version[] __attribute__((used)); prog_uint8_t Version[] = PROJECT_STRING ", " "V:" REVISION_STRING ", "
Peter Dannegger schrieb im Beitrag #3912016: > Ich schreibe mir ein _version.c:#include <avr/pgmspace.h> > > prog_uint8_t Version[] __attribute__((used)); > prog_uint8_t Version[] = PROJECT_STRING ", " > "V:" REVISION_STRING ", " >
-
Thread
Mikrocontroller mit USB Interface
eindeutigen Befehl mit dem nur ein Sensor was anfangen kann und dieser Sensor antwortet dann mit einem String aus Buchstaben und Zahlen. 8 Bit uC reicht vollkommen aus, wenn es denn was gibt mit USB...... Vielen Dank :-)
(Soll dann heißen Sensor 1 Messung auslösen). Sensor 1 generiert Messwert und sendet dann einen String zurück (zB S1M2.08791). Jeder Sensor hat einen EIGENEN uC und ist damit auch komplett unabhängig von allen anderen!
-
Thread
Speichern von UART Daten
Daten in ein Scruct > speicher... Das geht dann zb mit einer Hilfsfunktion, die den nächsten String aus dem 'Input' rausholt und in die Stringvariable deiner Wahl umkopiert [C] typedef struct Data { char ch_data_name_one[12]; char ch_data_page_one[12]; char ch_data_name_secound[12];
ja am Ende des Zeichenkette ein 0x17 mit schichen, damit ich weiß, dass es hier zu Ende ist. In C kann ich das ja nicht einfach hinten anhängen zudem ist es ja ein Char 0x17 also 8 Bit. hw_rs232_send_string("bla (\)ETB" ); So habe ich es schon versucht, leider ohne Erfolg.
-
Thread
Bitte um Verständnishilfe bei Pointer in Funktion
: [c] void lass_string_blinken (*string) { ...wenn AN-ZEIT... { sende_string_zum_lcd (string); } ...wenn AUS-ZEIT... { loesche_Zeile (entsprechnende_Zeile); } } [/c] Und diese unktion gibt den String aus: [c] void sende_string_zum_lcd (char *string) { while (*string != 0) { lcd_send_alphanum (*string++); } } [/c] So...mein Frage ist nun, wie ist das mit den Pointern? So, wie
-
Thread
Laptimer Projekt mit Magnetschleife (Atmega8)
folgenden zuweisungen immer der Fehler "error: dereferencing pointer to incomplete type" kommt. [c] LCD_string(itoa(time->min, buffer, 10)); if(time->sec < 10) LCD_string(itoa(time->sec, buffer, 10)); ....... [/c]
folgenden zuweisungen immer der Fehler "error: dereferencing > pointer to incomplete type" kommt. > > [c] > LCD_string(itoa(time->min, buffer, 10)); > if(time->sec < 10) > LCD_string(itoa(time->sec, buffer, 10)); > ....... > [/c] Weil ich einen Tippfehler gemacht habe [C] void LCD_showTime(
-
Thread
Pointer auf Strings im FLASH?
Hi! Ich geb dir mal ne UART-Funktion: const char pgmStartString[] PROGMEM = "ATmega32 online!"; int main (void) { char cUseBuffer[30]; UART_TxStr(strcpy_P(cUseBuffer, pgmStartString)); } void UART_TxStr(unsigned char *p_pucString) { while(*p_pucString!=0) { outp(*p_pucString, UDR); loop_until_bit_is_set(UCSRA, UDRE); p_pucString++; } } Kannst du dann für's LCD adaptieren. Gruß Danyo
-
Thread
missing ; behind __flash -> Was übersehe ich?
an der aktuellen Cursorposition void lcd_string( const char *data ); [...] [/code] [code] //aus lcd-routines.c // Schreibt einen String auf das LCD void lcd_string( const char *data ) { while( *data != '\0' ) lcd_data( *data
Nope. > Du wirst 2 Funktionen brauchen. Nicht zwangsläufig. Er kann es auch einfach so machen: [c]void lcd_string ( const char __memx *data )[/c]
-
Thread
Strtok in C schreibt 0 in Teilstring?
Hallo zusammen, ich hab da eine Frage zu Strtok in AVR C. Ich schicke über Uart Strings zu einem Atmega 328P, die haben das Format Buchstabe:Zahl also z.B. g:55 und am Ende ist ein Newline Zeichen \n. Es wird immer nur ein Buchstabe geschickt, ein : und eine
split2); //Inhalt von split2 in Zahl umwandeln und in Variable kopieren uart_send_string("split1"); uart_send_string(":"); uart_send_number(var1, 10); uart_send_byte('\n'); input_str[0] = '\0'; split1[
-
Thread
Probleme mit neuer USART-Konfiguration
in meine erste eigene Schaltung Probleme. Ich bekomme beim Senden eines Zeichens mit USART_SEND_STRING("a") scheinbar nur 0-Terminierungen in meinem Terminal-Programm: <0><0><0><0><0><0> Dies ist mein Code: [c] /******************************************************************************
Transmitter, Receiver und RX Complete Interrupt UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0); //UCSR0C |= (1<<UMSEL01)|(1<<UMSEL00); // USART in MasterSPI Mode } /*******************************************************************************************************/ void USART_SEND_STRING(char *data
-
Thread
String aufsplitten in 40 Einzelwerte
vollständig string[f] = '\0'; // erst mal einen sauberen C-String daraus machen befehl = strtok(string, trennzeichen); // dann zerteilen wert[1] = strtok(NULL, trennzeichen); k=2; for(t=0;t<40
wird. der Debugger springt auch die "A" Bedingung an. aber die 4 "test" Variablen bleiben leer. [c] void remote( void ) //Fernsteuerung über RS-232 { // Ein Return ist eingetroffen. Damit ist der String vollständig string[f] = '\0'; // erst mal einen sauberen C-String daraus
-
Thread
String empfangen
Hallo, möchte gerne im ATMega einen String empfangen, der so aussieht "4.123". Diese Zahl ( float) möchte ich weiterverarbetien. Es gibt aber keine String to float Umwandlung, oder? Was mache ich nun?
Achso, ich vergass...C..sorry, das sieht nach basic aus
-
Thread
UART Zeichenkette ohne Endzeichen
} // Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen *Buffer = '\0'; } [/c]
Jakob schrieb im Beitrag #3974287: > [c] while( NextChar != '0x00' && StringLen < MaxLen - 1 ) { > *Buffer++ = NextChar; > StringLen++; > NextChar = uart_getchar();[/C] > > Dann schreibt er ja nur dann in den String wenn
-
Thread
int in ASCII Zeichen umwandeln
sorry, meinte natürlich [c] sprintf(string,"%c",int) [/c]
da [c]sprintf(string,"%c",65)[/c] zu speicherintensiv sein soll, wollt ich ne Fkt. welche das evtl. besser erledigt bei dem Beispiel sollte "A" in string stehen
-
Thread
Beenden eine while(1)-schleife in einer Interruptroutine
ich hab da mal was vorbereitet: [c] #define maxstrlen 10 ... volatile char string[maxstrlen+1]; volatile uint8_t str_complete; volatile uint8_t str_count; ... ISR(USART_RXC_vect) { unsigned char buffer; // Daten aus
[str_count]=buffer; str_count++; } else { if (buffer!='\n' && buffer!='\r'){ string[str_count]=buffer; str_count++; } string[str_count]='\0'; str_complete=1; } } [/c] Im Hauptprogramm fragst du einfach zyklisch ab ob str_complete=1 ist und holst dir die
-
Thread
Fröling Heizungssteuerung auslesen.
; unsigned int read; // PD0 und PD1 reserviert für TX und RX PORTC = 0xf8; // Pull UP bei C3 Taster weiter , C4 Taster hoch , C5 Taster runter PORTB = 0XFF; lcd_init(); lcd_on(); // Display an while (1) { {print ("0X4D"); } if (
auch direkt vom TTL des ESP8266 untersucht habe, und das ganze sowohl mit dem HardwareSerial des µC als auch mit der SoftwareSerial-Variante, das Ergebnis ist immer der gleiche abgeschnittene Ra-String auf dem COM-Port. Liegt das Problem vielleicht in der Nutzung der Arduino-ESP8266-Bibliotheken
-
Thread
Mein erstes Projekt
( CAT_IN ); else lcd_string( CAT_OUT ); sprintf( OutString, "%02u:%02u:02u", showstunde, showminute, showsekunde ); lcd_setcursor( 0, 2 ); lcd_string( OutString ); } [/C] (Dein { - } Klammerungsschema find ich
lcd_clear(); if (ShowState == CAT_IS_IN) lcd_string( CAT_IN ); else lcd_string( CAT_OUT ); lcd_setcursor( 0, 2 ); ShowZeit( &(aktion->Wann) ); } ... [/C] Das ist zwar hier am Anfang des Programms erst mal etwas mehr Aufwand, dafür
-
Thread
Mehrsprachig programmieren für AVR
" #endif /* ifndef _TEXTE_H_INCLUDED */ [/c] Kompiliert wird dann je nach gewünschter Sprache mit: [pre] avr-gcc ... -I de ... prg.c -o ... avr-gcc ... -I en ... prg.c -o ... [/pre] bzw. [pre] LANG=de avr-gcc ... -I $(LANG) ... prg.c
(TEXT_INTRO_HALLO) [/c]
-
Thread
AVR PSTR mit gegebenem String nutzen
Ich versteh die Frage nicht. Im Code gibt es überhaupt kein PSTR: > void lcd_writeProgString(const char *string) { > char c; > while ((c = (char)pgm_read_byte(string++))) { > lcd_writeChar(c); > } > }
sah so aus, als wolle er Daten aus dem > Flash ans LCD schicken. Mit avr-gcc dann einfach do: [c] void lcd_writeProgString (const __flash char *string) { char c; while ((c = *string++)) { lcd_writeChar (c); } }[/c] oder [c]void lcd_writeProgString (const __flash
-
Thread
Interrupt in ISR freigeben
ist *(s+len) = 0; //Abschließende 0 str = s; //Startpos des strings while(*str == '0') //Führende 0len löschen *str++ = ' '; if(*str == '.') //Vor komma eine null setzen (falls gelöscht) *(str-1) = '0'; } [/c] Wenn du
ist *(s+len) = 0; //Abschließende 0 str = s; //Startpos des strings while(*str == '0') //Führende 0len löschen *str++ = ' '; if(*str == '.') //Vor komma eine null setzen (falls gelöscht) *(str-1) = '0'; } [/c] *++str =
-
Thread
PIC-C: Aus float mach string, wie?
Ich wiederhole mal den Betreff: PIC-C: Aus float mach string, wie? Hab ich da eine Lösung übersehen?
atof wandelt string in double(float) ich will aber float -> string. Beim mega16 geht das mit sprintf. Der C18-Compiler für PIC kennt aber den f-Spezifiziere bei sprintf nicht. Ich hoffe nur, dass ich mit dem
-
Thread
Wie nach 10. Semikolon String einlesen
Hi, wie kann man in C am schnellsten nach 10. Semikolon einen String einlesen. Man könnte z.B. 10-leere while Schleifen nehmen, ist nur redundant :-)
[c] #include <iostream.h> /* g++ -Wno-deprecated -I/usr/include/c++/4.1.3/backward dlm.cpp -o dlm ; dlm ; rm dlm */ void cut ( char const src [/*1 +cpc*/], /* source string */
-
Thread
printf format strings prüfen?
-Wformat und besonders -Wformat-security sind ja nicht verkehrt. Ein nicht-konstanter format string wird dann angemeckert. Seht gut, aber es gibt eine Grauzone, zum Beispiel finde ich, dass diese format strings durchaus konstant sind. Kann ich dem gcc außer "const" noch einen Tipp geben? [c]int
fsopts, uid, uid, timezone / 60L); err = mount (source, default_mnt, fstype, flags, options);[/c] Im nächsten Beispiel ist im Endeffekt auch alles konstant, aber da ist die Warnung wohl unvermeidlich. Gibt es vielleicht "eine lib", mit der ich den format string prüfen könnte? Und wie sage ich
-
Thread
uint32 * uint32 = neg. Zahl ?
Übergabeparameter. Dann kommt bei 900*52 genau der Wert raus. Die Ausgabe am LCD mache ich wie folgt: [c] char string[10]; lcd_gotoxy(0,3); itoa (voltage_electrodes , string , 10); lcd_puts(string); [/c] Für die Ausgabe am Display (4*20 Zeichen mit Standard HD44780 Controller) benutze
Karl Heinz Buchegger schrieb im Beitrag #2266261: [c] sprintf( string, "%4d,%03d V", (int)(voltage_electrodes/1000),(int)(voltage_electrodes % 1000) ); lcd_puts( string );[/c] Soweit ich mich jetzt schlau gemacht habe bedeutet: %4d: d steht
-
Thread
uart Lib - Peter Fleury - kompiliert nicht
can not write the whole string to the circular * buffer */ uart_puts("String stored in SRAM\n"); /* * Transmit string from program memory to UART */ uart_puts_P("String stored in FLASH
Veit D. schrieb im Beitrag #4921821: > Wie fügt man die .c dem Projekt hinzu? Rechte Maustaste auf das 'Source Files' deines Projektes->Add File->uart.c suchen und einfügen. Es ist sinnvoll, uart.h und uart.c in den Projekt Ordner zu kopieren. > na ich
-
Thread
uC für 0,20€ CH552 / CH554 von WCH Billig Micro mit USB Funktion, Chip vorstellung
I also tried splitting debug.c/h into config.c/h delay.c/h uart0.c/h uart1.c/h wdtm.c/h but in the end I wasn't happy with this.
Ray R. schrieb im Beitrag #6790216: > I also tried splitting debug.c/h into config.c/h delay.c/h uart0.c/h > uart1.c/h wdtm.c/h but in the end I wasn't happy with this. yes and that tons of ifdefs are not the best way to handle this problem. This is where a real lib