-
Thread
Funktion, welches je nach Datentype der Eingangsvariablen anders reagiert - geht sowas ?
normaler Funktionsüberladung. Aber man hat den syntaktischen Overhead von Templates. Wenn man eine C++ Lösung haben will, würde man eher das Streams Interface benutzen. Und ganz besonders würde man nicht mit char* Buffern herumhantieren. C-Strings und nackte Pointer haben in einem C++ Programm nichts
Axel S. schrieb im Beitrag #6269562: > Wenn man eine C++ Lösung haben will, würde man eher das Streams > Interface benutzen. Und ganz besonders würde man nicht mit char* Buffern > herumhantieren. C-Strings und nackte Pointer haben in einem C++ Programm
-
Thread
Arduino UNO USART Daten fehlen
kann nicht gehen, denn dein Programm auf dem µC ist nur für Half-Duplex Kommunikation ausgelegt. Half-Duplex bedeutet: Nach dem Empfang eines Strings wird er verarbeitet, das dauert. Während dieser Zeit ist dein µC nicht empfangsbereit. Erst wenn der µC die Verarbeitung beendet hat und die Antwort los geworden ist, kann wird er für den nächsten String bereit. Darauf hat Axel R. bereits hingewiesen. Eine Full-Duplex Kommunikation erfordert einen
-
Thread
Timer genaue Zeit und entprellen
Hi Christoph, >... eine "12". Wenn der String am uC ankomt dann soll die > Sekunde auf 12 gestellt werden und weiterlaufen. Wie ich einen String > mit dem uC empfange weiß ich, aber wie setze ich dann die Zeit? [c] int8_t sekunde; sekunde=atoi(string_mit_Sekundenwert); [/c] Gruß Fred
-
Thread
Int in string
Hi, Wie wnadle ich ein iteger in einen string um?? lg, Stefan
Ziffer in einen char umwandeln willst, kannst du auch einfach '0' hinzuaddieren. int i = ???; char c = i + '0'; Björn
-
Thread
DCF77 weiteres Vorgehen
der int Variable in eine Char Variable lcd_string(buffer1); // Char Variable auf dem LCD ausgeben high = 0; // high Variable zurücksetzen } } } return 0; } [/c] Dieser Code funktioniert einwandfrei
der int Variable in eine Char Variable lcd_string(buffer1); // Char Variable auf dem LCD ausgeben high = 0; // high Variable zurücksetzen low = 0; } } } return 0; } [/c]
-
Thread
8bit Pointer bei großen AVR's
der GCC (WINAVR-2010) störrisch reagiert mit einer unklaren Fehlermeldung: ../Main_Flash_Test.c:12: warning: '__progmem__' attribute ignored Das passiert dann wenn man einen Flash String in einer Funktion anlegt: [c] int main (void) { const char __ATTR_PROGMEM__ MyString[] = "Das ist ein String im Flash"; ........ } [/c] .... nicht ganz einleuchtend .... da ja eigentlich const. Das bekommt man ja sonst auch. Legt man dagegen den String im globalen Scope an ist es ok .....
-
Thread
int8_t mittels uart schicken Gesperrt
[c] uint8_t c = 'a'; HAL_USART_Transmit(husart, &c, 1, timeout); [/c]
Bei char* würde ich einen C-String erwarten. Warum nicht void*
-
Thread
Frage zum Verständnis in C
} void funktion(para1, para2) { Wert = para1+para2; } [/c] ? Bei all den pointern und zuweisungen und all dem Lesen über Strings bin ich da grade echt verwirrt...
; } } [/c]
-
Thread
Wlan2Serial Modul für 5 euro
die WI07c bzw. ESP-01 Module.
sich anpassen, "EXTRA_INCDIR" verweist auf "/usr/include", da manche Quellen z.b. ein "#include <string.h>" haben, welche dann von dort kommt. Nun muss man noch die "CC", "AR" und "LD" im Makefile anpassen, fertig. Beim compilieren meckert er irgendwo das "uint32_t" redefiniert wurde in "c_types.h
-
Thread
Allgemine Frage an die Freunde von Atmel
. Ein generelles String oder Char lesen gibt es nicht. Dein Problem ist also nicht das I2C oder der MC, sondern das Protokoll, was Deine Funktionen auf dem I2C übertragen. Oder einfach nur ein C-Problem beim Aufruf dieser
Sebastian schrieb im Beitrag #4054303: > Übrigens, ist ein String der Länge 1 nicht ein char? Ein String der Länge 1 besteht aus zwei Zeichen - zumindest in C oder Pascal. Wie soll der in ein char passen?
-
Thread
Atmega16 Speicher bald voll Program / Data Unterschied ?
Dinge in mehrere Anweisungen und Hilfsvariablen auf (der Compiler schmeisst die eh wieder raus) [C] const char* adrOfStringInFlash = pgm_read_word( &MainMenuStrArray[actualMenuPoint] ); lcd_puts_p( adrOfStringInFlash ); [/C] > > Erkennt jemand den Fehler im Quelltext vom Posting oben ?
const char* adrOfStringInFlash = MainMenu[actualMenuPoint].Text; lcd_puts_p( adrOfStringInFlash ); [/C] Da MainMenu nicht als im Flash liegend markiert ist, kann ganz normal auf das Array zugegriffen und daraus gelesen
-
Thread
LCD an T6963C und ATMega323
Na klar hab ich die Aufrufe... void statusCheck1_T6963C(void) { while((statusRead_T6963C()&0x03)!=0x03); } Du willst eine ASCII 2 schreiben? Schau mal in meinem Code unter writeString_T6963C da siehst du was du tun musst um einen ASCII string zu
; //lower bits f.l.: C~D ~Ce ~Rd ~Wr asm volatile ("nop"::); asm volatile ("nop"::); PORTD = 0b11110010; //lower bits f.l.: C~D ~Ce ~Rd ~Wr } Du setzt CE auf L, dann WR auf L und dann??? Ein
-
Thread
sprintf mit dynamischen Format
der Funktion sprintf zu übergeben. z.B. [c] char buffer[1024]; // buffer in dem der formatierte String hineingeschrieben werden soll sprintf(buffer, format, sdram); //format: Pointer auf den Format String; sdram: Pointer auf den SDRAM bzw
Tja, beim AVR-GCC http://www.nongnu.org/avr-libc/user-manual/group__avr__stdio.html#ga4c04da4953607fa5fa4d3908fecde449 will der snprintf einen Zeiger auf einen konstanten String. Mehrere konstante Strings hinterlegen ist kein Problem.
-
Thread
Wie mit Zahlen, die in char- Variable stehen, rechnen?
\0') { if(*zeiger!='.') { z+=((*zeiger)-48)*m; m/=10; } } [/c] in z steht dann der zahlenwert des strings. LG, Björn
Ich hab jetzt mal folgendes gemacht: [c] char kmh_string[4]; double kmh; ... kmh = 15.2569; sprintf(kmh_string,"%f",kmh); lcd_string(kmh_string); [/c] Es wird fehlerfrei erstellt, aber auf dem LCD erscheint nur ein ? Was ist nun
-
Thread
Progrmmierung in C
* die C Sprachelemente if, while, do - while, for, switch - case * Funktionen, Argumentpassing, Prototypen * Arrays * Strings * Strukturen * die wichtigsten Dinge mit dem Präprozessor: #include, #define
Operationen, logische Operationen für den Umstieg nicht so wichtig (wenn dann natürlich auch in der C-Weiterbildung notwendig), die schwierigeren Themen * dynamische Allokierungen * komplexere dynamische Datenstrukturen wie Listen, Bäume, Maps, ... * dynamische Strings * Files Wenn der erste
-
Thread
Honeywell Rondostat HR20E per AVR steuern und konfigurieren
Soll Temperatur ändert oder die Regelung den Motor nachstellt, liefert das Modul z.B. folgenden String zurück: D: 27.1.2008 U: 10:36 V: 0 I: 1985 S: 1550 Dabei ist D: Datum DD.MM.YYYY U: Uhrzeit HH:MM V: Ventilposition I: Ist Temperatur in °C x100 S: Soll Temperatur °C x100 Man sieht
Du einen Parser schreiben, der reinkommende Befehle analysiert. void Parser_ReceiverChar( char c) { static string cmd_str; ...... ...... if (bCMDComplete) { // Befehl vollständig eingelesen ParseCmd( string cmd_str); cmd_str=""; }
-
Thread
Extrahieren eines Teil-Strings aus einer Konstanten
[c] #include <stdio.h> #include <string.h> #define SVNVERSION "$Revision: 214 $" int main(int agrc, char**argv) { // Definition ins RAM kopieren char svnversion[] = SVNVERSION;
[c] #define SVNVERSION_NO "214" #define SVNVERSION "$Revision: " SVNVERSION_NO " $" [/c]
-
Thread
Zeiger Strings ausgeben?!
Moin Moin. Wieso hängt sich der µC auf, wenn ich die Strings ausgeben will? [C] typedef struct { const char *ProjectName; const char *HardwareVersion; const char *SoftwareVersion; const char *HardwareDate; const
/* enable UDRE interrupt */ UART0_CONTROL |= _BV(UART0_UDRIE); }/* uart_putc */ [/c] [c] /************************************************************************* Function: uart_puts() Purpose: transmit string to UART Input: string to be transmitted Returns: none
-
Thread
folgender code nicht compilierbar
argv =**%s** argc(int)=%d",argv,argc); printf("\r\n\n\n\nhier einzelne ZeicheN:"); printf("\n%c\r",argv[0]); printf("\n%c\r",argv[1]); printf("\n%c\r",argv[2]); printf("\n%c\r",argv[3]); printf("\n%c\r",argv[4]); getchar(); return 0; } ausgabe ist als string was anderes als
Name des EXE inklusive Pfadangabe, von wo aus das EXE gestartet wurde. > printf("\n%c\r",argv[1]); argv[1] ist ein Pointer auf dein erstes Argument. In deinem Fall ein Pointer auf den String "-abc" > printf("\n%c\r",argv[2]); so wie du das EXE aufgerufen hast, ist argv[2] ein
-
Thread
ASCII Verarbeitung optimieren
(100, 2); .... // nächstes Kommando } [/C] Dazu musst du aber C-Strings beim Empfang bilden, also welche die mit einem '\0' Character abgeschlossen sind. http://www.mikrocontroller.net//articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C
[C] uint8_t IsZahl( const char* String ) { // gibt es ein Vorzeichen? if( *String == '+' || *String == '-' ) String++; // ein leerer String wird nicht als Zahl akzeptiert
-
Thread
Projekt: SerialComMeasurement
Schnittstelle 250000 Baud. Beispiel: #CL Clear und Reset des Befehlspuffer #AI2_C10 Analog Input 2 auf Channel 10 mappen #AI3_C11 Analog Input 3 auf Channel 11 mappen #M*C12_C10_C11 Multiplikation Chan.10 und Chan.C11 nach Chan.C12 #SO_C10 SerialOut Channel 10
Werte, solange die Leistung höher als 500 ist PortB.5 setzen. Serielle Ausgabe aller Kanäle: #CL #C11=AI1M9 #C12=AI2M9 #C15=C11*C12 #C17=V500 #PB5=C15>C17 #SO=C11(Spannung) #SO=C12(Strom) #SO=C15(Leistung) #Start Hex-File für ATMega 328P, incl Uploader sind beigefügt.
-
Thread
Problem mit der sprintf - Funktion
; x = (adcVal[0] * 5) / 1024; sprintf(StringBuf, "%f", x); GLCD_DrawString (0, 2*24, (char*)StringBuf); ... [/c] Wenn ich den berechneten Wert einer float-Variable zuweise und anschließend ausgeben möchte, hört der Timer auf neue Werte
" "); GLCD_DrawString (0, 7*24, " "); GLCD_DrawString (0, 8*24, " "); GLCD_DrawString (0, 9*24, " "); } [/c]
-
Thread
lcd_putint falsche Ausgabe
Einfacher wäre es, tmp mal global zu machen bzw. einen anderen globalen Puffer mitzubenutzen. [C] char tmp[10]; void lcd_putint(int value) { itoa(value, tmp, 10); lcd_string(tmp); } [/C]
arbeiten speziell benennt also hier lcd_string_P(...). Das ist eigentlich die Art wie ich bisher in 80c51 programmiert habe nur wie schreibe ich hier mit C die Daten in das ROM (bin immer noch am Anfang mit C) By Wolfgang
-
Thread
Initialisiertes Char Feld mit Länge 1 und Inhalt '\0'?
$4445 $0041 $4410 $0940 $0444 [/code] ...es gibt da eine Funktion getcount() in general.c: [c] getcount(str,size,strt,err) char *str; /* string with <range> on it */ int size; /* 1,2 or 4; the number of bytes from <size> */ int strt; /* starting address */ char err
Da gibt's übrigens noch ein kleines, aber feines Detail: [c] char string[] = "Stringliteral"; [/c] ist tatsächlich keins. Der Compiler muß das Feld im RAM anlegen, weil es eine Initialisierung eines nichtkonstanten Feldes ist. [c] char *string = "Stringliteral
-
Thread
strings in schleife
. Was mache ich falsch bzw. wie kann ich das ändern? Das C code befindet sich im Anhang Danke im Vorraus! Michael
Außerden setzt Du i nie zurück. In uart_put veränderst Du es zwar, aber nach dem Senden des Strings bleibt es auf dem Stringendindex. Das nächste empfangene Zeichen wird im Interruphandler also an den String angehängt ... Außerdem solltest Du Deinen Quelltext zur besseren Verständlichkeit sinnvoll
-
Thread
Atmel Studio 7 keine Strings??
das Programm einfach nicht kompilieren. String, string, std::string sind alle keine gültigen Datentypen, obwohl ich [c]#include <string.h>[/c] nutze. Ich sitze schon etwas länger an dem Fehler und habe in der Zwischenzeit recht viel aus anderen Foren und Threads probiert. Auch [c]#include <string>[/c] funktioniert nicht. Die Library wird nicht gefunden, was ich erst einmal komisch finde, da string.h ja eigentlich eine c Library ist. Ich habe die alte toolchain auch schon durch
-
Thread
Integer -> Char -> USART -> Char -> Integer (Übertragungsprotokoll)
Einsteiger schrieb im Beitrag #2693182: > z.B. Integer 123 -> Char "0" "1" "2" "3" > > Auf dem uC interpretiere ich die "Zahl" als: > > atoi(0)* 1000 + atoi(1) * 100 + atoi(2) * 10 + 1* atoi(3) = 123 "1" ist ein String. Das Zeichen wäre '1'. Eine String ist ein Nullterminiertes char-Array.
übertragungsprotkolle sind auf den unteren schichten sind meist keine Text Protokolle. > Uc: Sprintf(string,"%d",Zahl); send-uart-s(string); > Pc: get_String(String); atoi(String); schon die verwendung von Sprintf macht es noch schlimmer, es gibt auch itoa! Hast du mal auf einen µC die anzahl der Take
-
Thread
RS232 nach HTTP/HTML Konverter
Ich bin nicht ein grosser Fan von Basic, daher nehme ich lieber C. ;o)
Was meinst du mit Zusammenhang? Flash zugriffe sind in C auch einfach, man muss halt erst wissen wie. ;o)
-
Thread
UART Studienarbeit dringend :D
} else{ PORTA &= ~(1<<PA5); } } if(uart_string[0] == 'b'){ memmove(uart_string, uart_string+1, strlen(uart_string)); Blau = atoi(uart_string); OCR1B = Blau; if(Blau > 50){ PORTA |= (1<<PA6); } else{ PORTA &= ~(1<<PA6); } } if(uart_string[0] == 'c'){ if(uart_string[1] == '1'){ PORTA |= (1<<PA7); } else{ PORTA &= ~ (1<<PA7); } } if(uart_string[0
-
Thread
structs incrementieren?
einzelnen Strings in dieser Struktur via. increment zu kommen? [c] for (uint8_t i = 0 ; i < 3 ; i++) { uart_puts((char*)(uartMsg++)); uart_puts("\r\n"); } [/c]
dann klappts auch mit >> der pointer-arithmetic :-) > > Wie würde das denn dann aussehen? > [c] > union test > { > DevBoard_t Message; > char uartMsg[]; > }; > [/c] > So ungefähr? Wenn die einzelnen C-Strings in DevBoard_t 0-terminated sind (wie es bei C-Strings angenommen wird),
-
Thread
C++ Funktions Template für __flash
behilft man sich mit einem Trick, indem man eine neue Klasse (und damit einen neuen Typ) namens __FlashStringHelper deklariert und dann ein Makro _F definiert, das einen gewöhnlichen C-String (Zeiger auf Zeichenkette) im Flash in einen Zeiger auf diese neue Klasse "umformt": https://github.com/arduino/ArduinoCore-avr
Da fehlt ein [c]#include <string.h>[/c] Ist wohl beim Arduino standardmäßig dabei [code]reinterpret_cast' is not a constant expression[/code] Ahh, der alte GCC vom Arduino ist da nachlässiger. Müsste man umbauen
-
Thread
Zweite Zeile LCD Display
void) { // LCD Initialisieren lcd_initialisieren(); // LCD Ausgabe lcd_set_string(2,1,"blub"); // Programmende return 0; } [/c] Auschnitt aus der Library: [c] // String zur aktuellen Cursor Position senden void lcd_string(const char *string) { // String
zur Position senden lcd_string(string); } [/c]
-
Thread
String auf Zahlen reduzieren
Hallo, wie kann ich in C# einen String auf seine Zahlen reduzieren? Beispiel: "C1:VDIV 700E-3 V" hätte gerne die 700*10hoch-3. Natürlich wird bei einem Algorithmus, der die Zahlen im String erkennen soll, auch die eins sehen
Dimha B. schrieb im Beitrag #6376943: > "C1:VDIV 700E-3 V" Hallo, wenn das Format für jede Zeile stimmt, dann: string test = "C1:VDIV 700E-3 V"; string[] input = test.Split(' '); double zahl = Convert.ToDouble
-
Thread
float aus UART berechnen
(Convert.ToInt16(BitConverter.ToSingle(OutBytes, 132)).ToString()); [/c] Da überträgt er es ja dann direkt als String aber, das heißt ich müsste im Tiny den String erst wieder in eine Integer wandeln - und genau da ist mein Problem! Das kostet mit atoi wahnsinnig
byteArray[0]; ListTemp[2] = byteArray[1]; ListTemp[3] = newline[0]; ComPort.Write(ListTemp, 0, 3); [/c] Einmal dann zum µC geschickt kann ich da einfach die Bytes shiften und hab mein uint10_t: [c] dataUART = uart_string[1] + (uart_string[2]<<8); [/c] Somit ist zwar der Rechner etwas belastet
-
Thread
BASCOM: Zeichenumwandlung nach Vorgaben aus einer Tabelle
anderen Wert, aber seis drum. Dein Problem besteht darin, dass BASCOM anscheinend, ähnlich wie C, seine Strings mit 0 abschliesst. Und da dein Gerät bei einem 'A' den Code 0 sehen will, ist damit das ganze Konzept des 'einen String in einen anders codierten String zu verwandeln' schon mal den Bach
Hallo! Habe es noch nicht ausprobiert aber würde es in etwa so funktionierten: [c] dim text as string*10 dim char(10) as byte dim i as byte dim index(10) as byte text = "ABCDEFGHIJ" i = 1 Do 'Einzelne Chars aus String ziehen char(i) = mid(text , i , 1) 'Char
-
Thread
Verwendung von Stringkostanten mit dem AVR?
Stefan... ganz so daemlich bin ich dann auch nicht ;) OK dann mal ein konkretes Beispiel: [c] display_string("some string..."); [/c] Wobei display_string wie folgt definiert ist: [c] void display_string(char* string) { while (*string != '\0') { display_send((uint8_t)
sein? Er: [c] void display_string(char* string) ... display_send((uint8_t)*string++, TXT); [/c] [c] char buffer[3]; ... display_send(buffer); [/c] Ich: > In den beiden Beispielen wird "display_send"
-
Thread
char string mit sonderzeichen
hallo habe probleme beim definieren eines strings. anscheinend mag er die sonderzeichen nicht denk mal an die ". wie kann ich das richtig schreiben?! [c] const char text[] = " <?xml version="1.0" encoding="UTF-8"?>/n ";[/c] mit folgender fehlermeldung
danke hab ein c buch vor mir liegen, nur leider im string teil wird das nicht besprochen. aber wo du es jetzt schreibst kann ich mich wieder erinnern sowas gesehn zu haben, so ca 200seiten weiter vorne. jedenfalls
-
Thread
PCF 8574P + LCD
Boah... :-) Also wenn ich das richtig überblicke, enthält $data2 den kompletten String data, und zwar jeweils 8 "Bit" als String aus 0 und/oder 1... For $i = 1 To (($laenge * 2) - 1) +1 $zw1 = StringLeft($data2, (4*$i)) $zw1 = StringRight($zw1, 4) $zw2 = "1001" &
im String $asciicode=asc(StringMid($data,$t,1)) ;in asciicode umwandeln $data2 &= Hex($asciicode, 2) ;und dann in hex (2stellig) next For $i = 1 To ($laenge * 2) $zw1 = StringMid
-
Thread
Frequenzausgabe formatieren
Also, in Haskell würde ich das so schreiben: format :: String -> String format = reverse . format' . reverse where format' (a:b:c:d:xs) = [a,b,c,'.'] ++ format' (d:xs) format' xs = xs Das könnt ihr euch ja nach Basic oder C oder sonstwas
Voraussetzung, dass F die Frequenz in oben genannter Form enthaelt und niemals leer wird: Dim F As String * 15 Dim T1 As String * 4 Dim Resultx As String * 20 Dim A As Byte , B As Byte Dim C As Byte F = "50" Resultx = "" B = Len(f) C = B / 3 C = C * 3 A =
-
Thread
Variablen setzen sich auf 0 Gesperrt
sind. Variablendeklaration global Eine ISR empfängt Zeichen und speichert die in einem String [c] int main () { while (true) { if( Neue Zeichenkette wurde empfangen) { if (r=1) Schalte die LED ein; if (erstes Zeichen der Zeichenkette = !) r=1; } else
gesetzt wird. Auch die Variablen get, set, und status werden nach jedem Durchlauf auf 0 gesetzt. [c] while (1) { if (complete && start == 1 ) //Überprüfen ob kompletter String erhalten wurde { str_len=0; //Länge des Strings zählen while(rx_str[str_len
-
Thread
Embedded Linux erkennt USB Stick aber /dev/sdd wird nicht angelegt? /dev/ttyUSB bei UMTS-Stick auch!
high-speed USB device number 6 using musb-hdrc [ 44.866363] usb 1-1.3: New USB device found, idVendor=1c9e, idProduct=f000 [ 44.873596] usb 1-1.3: New USB device strings: Mfr=3, Product=2, SerialNumber=4 [ 44.881317] usb 1-1.3: Product: USB Modem [ 44.885559] usb 1-1.3: Manufacturer: USB Modem
high-speed USB device number 4 using musb-hdrc [ 6.988281] usb 1-1.4: New USB device found, idVendor=1c9e, idProduct=f000 [ 6.995513] usb 1-1.4: New USB device strings: Mfr=3, Product=2, SerialNumber=4 [ 7.003234] usb 1-1.4: Product: USB Modem [ 7.007476] usb 1-1.4: Manufacturer: USB Modem
-
Thread
AVR-UART Interruptgesteuert oder nicht?
den Empfang mit IRQ-Handler. Der IRQ-Handler schreibt die empfangenen Bytes in ein char Array (=String). Der String wird jeweils vom Handler mit ASCII 0 C-konform abgeschlossen. In dem String sucht die Hauptschleife mittels strstr dann ELM327. Wenn ELM327 gefunden wurde, wird der String wieder gelöscht
// Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen *Buffer = '\0'; }[/c]
-
Thread
Interrupt löst nicht aus?
Welcher µC wird benutzt?
; uart_puts(" mm"); uart_putc('\0'); lcd_setcursor(4,1); lcd_string("Weg : "); lcd_string(" "); lcd_setcursor(4,7); lcd_string(s); lcd_string("."); lcd_string(t); lcd_string(" mm"); uart_putc('\0');
-
Thread
Daten über usart empfangen/ wann Datenende erreicht?
ende = wert; StringLen++; NextChar = usart_getc(); } // Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen
und deswegen weis ich das kein weiteres Endzeichen geschrieben wird. Sieht hier jemand in dem String irgend ne Prüfsumme versteckt? 4D 41 0C 49 00 1C 07 2B 5A 75 73 74 61 6E 64 04 1A Bei den ersten 2 Zeichenketten die es schickt sah es so aus als ob das letzte zeichen eine Prüfsumme wär aber bei
-
Thread
implicit declaration lo8
x", crc ); usart_puts( buffer, strlen( buffer ) ); Für strlen musst du noch #include <string.h> ganz am Anfang inkludieren. sprintf() ist glaub ich auch mit diesem Include abgedeckt. Wenn nicht, dann #include <stdio.h> Und dann empfehle ich dir noch ein C-Buch zu kaufen und durchzuarbeiten
eine Punkt. Der nächste ist: > und dann den buffer mit der puts ausgeben. puts hält sich an die C-String Konventionen. Die besagen, dass die Character-Sequenz im Array mit einem '\0'-Zeichen abgeschlossen wird um anzuzeigen, dass der String hier aufhört (Das Array kann ja wesentlich größer sein
-
Thread
Matlab - Mikrocontroller - serielle Schnittstelle
rate here */ #define UART_BAUD_RATE 9600 uint8_t uart_getc_wait() { unsigned int c; do { c=uart_getc(); }while (c == UART_NO_DATA); return (uint8_t)c; } void uart_gets( char* Buffer, uint8_t MaxLen ) { uint8_t NextChar; uint8_t StringLen = 0; NextChar
); } // Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen *Buffer = '\0'; } int main(void) { char Line[40]; uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); sei(); while(1) { uart_gets
-
Thread
wie bekomme ich folgende warnings weg?
In der for-Schleife. kann ich diese irgendwie umschreiben? zb [c] string[10]='\0'; // String Terminator for(i=10; i>=1; i--) { i--; string[i]=(zahl % 10) +'0'; // Modulo rechnen, dann den .. zahl /= 10; } [/c]
findet, sondern man wird gleich in die richtige Zeile gelotzt. Ähnlich dem ist auch sowas wie: [c] if ("".equals(str)) {} [/c] In Java, um eine NPE für null-Strings zu verhindern. Daran musste ich mich aber auch erst gewöhnen.
-
Thread
Interner Pullup Widerstand, Buttonansteuerung klappt nicht
[C] if(!(PINB & 0x01)) { _delay_ms(50); while(!(PINB & 0x01)); _delay_ms(50); lcd_init(); //lcd_clear(); set_cursor(0,2); lcd_string("YEAH");
Ja, das ist immer ganz wichtig [C] void lcd_start(void) { lcd_string("Status:"); set_cursor(0,2); lcd_string("online"); } [/C] Auch wenn nichts im Programm funktioniert. Eine 'System hochgefahren' - "Copyright by Anfänger
-
Thread
UART: Hex-Bytes versenden
dein uC das als ASCII-Zeichen ’A’ oder 0x41. In deinem Programm kannst du daher auch die Bytes vgl. Es ist total Wurst, ob du jetzt, bspw. zur Prüfung bestimmter Zeichen in einem String, 0x41 oder ’A’ hernimmst
|=(1 << U2X0); UCSR0B |=(1 << TXEN0) | (1 << RXEN0); // USART Receive/Transmit Complete UCSR0C |=(1<< UCSZ01) | (1 << UCSZ00); // Charactersize 8-bit, 1 Stop Bit, Parity Mode disabled } void SEND_CHAR (unsigned char c){ while (!(UCSR0A & (1 << UDRE0))); UDR0 = c; } // void SEND_STRING
-
Thread
arduino display geht aus
Programmier es besser in echtem C!
etwas falsch dargestellt. Zum EINschalten ersetzt Du in Deinem Code und mit Deinem Keypad-Shield: [c] analogWrite(BACKLIGHT,70); [/c] durch [c] pinMode(BACKLIGHT,INPUT); // LCD Backlight EIN [/c] Und zum AUSschalten ersetzt Du [c] analogWrite(BACKLIGHT,0); [/c] durch [c] pinMode