-
Thread
Bluetoothmodul BTM-222
[C] UBRRH = (unsigned char)(baud>>8); UBRRL = (unsigned char)baud; [/C] Ne, das ist jetzt wirklich nicht dein Ernst? Und das hier erst: [C] USART_Transmit('0x0D'); [/C]
verbinden - ganz ohne Discovery etc. Einfach ein Streamconnection-Objekt holen, so ähnlich: [c] StreamConnection con = null; OutputStream out = null; InputStream in = null; String url = "btspp://0123456789AF:1;master=false;encrypt=false;authenticate=false" try { con =
-
Thread
LM 35 misst nur Nullen
So, habs nochmal alles ueberarbeitet und versucht strings zu senden mit der uart (halt ertmal die adc daten zum string zusammenbauen und dann mit puts senden). Hab wieder nur Mist erhalten und die Werte haben sich nicht veraendert wenn ich den Sensor erwaermt
puts( buffer ); } } [/C]
-
Thread
LCD Hängt immer Datenmüll an
konstanten Text aus dem Flash Speicher ; ausgeben. Der Text wird mit einer 0 beendet lcd_flash_string: push temp1 lcd_flash_string_1: lpm temp1, Z+ cpi temp1, 0 breq lcd_flash_string_2 rcall lcd_data rjmp
Die Null beendet nur den String: lcd_flash_string_1: lpm temp1, Z+ cpi temp1, 0 breq lcd_flash_string_2 ; ende Also kein Zeilenvorschub dadurch.
-
Thread
AVR Studio C++ vs. Arduino Processing
template Meta-Algorithmen schreiben, man kann mit den einfachen Dingen anfangen. Und z.B. am PC ist C++ für Anfänger noch viel mehr geeignet, da Dinge wie std::vector und std::string dort das leben drastisch vereinfachen. > > Vielen Anfängern ist C schon zu schwierig, und hier wird C++ empfohlen.
und std::string dort das leben drastisch > vereinfachen. Da würde ich lieber eine ordentliche High-Level-Sprache wie z.B. Python oder Java/C# empfehlen. Wie auch immer, C ist auf jeden Fall eine gute Wahl.
-
Thread
memcpy Zweidimensionales Array -> Eindimensionales Array
Alle String- und mem*-Funktionen sind im C-Standard m.W. in string.h. Daß das je nach Implementation in einer memory.h stehen kann und die von string.h #includet wird, kann sein. Aber string.h ist die korrekte
Klaus Wachtler schrieb im Beitrag #2684242: > Alle String- und mem*-Funktionen sind im C-Standard m.W. in string.h. > Daß das je nach Implementation in einer memory.h stehen kann Tatsächlich. Im C-Standard gibt es keine memory.h Wieder was gelernt
-
Thread
atoi macht char 2-fach?
ist: "X53Z", bei Z wird die Routine aufgerufen... [c] channels = 0; int chan1= atoi(&uart_string[1]); int chan2= atoi(&uart_string[2]); channels= chan1*10;//umrechnen der 2 Strings auf eine 2-stellig channels= channels + chan2; [/c] --> ich habe nun das Problem, dass für chan2 immer der String 2 mal kommt, es steht dann also 33 drin somit wird als Wert für Channel 533 berechnet, es sollte aber 53 sein Gruß Dirk
-
Thread
iPod-Interface am Anschluss des CD-Wechsler für Audi Werksradio (1. Generation)
/Empfangsdaten einsortieren SendMessage_st.Header_u16 = (word)((SendMessage_st.EmpfangString_au8[0]<<8) + SendMessage_st.EmpfangString_au8[1]); SendMessage_st.Lenght_u8 = SendMessage_st.EmpfangString_au8[2]; SendMessage_st.Mode_u8 = SendMessage_st.EmpfangString_au8[3]
; bool Fertig_bool; word EmpfangAnzahlZeichen_u16; unsigned char EmpfangString_au8[64]; AS1_TError LetzterSeriellerFehler_st; byte Error_u8; word SendeCommand_u16; unsigned int PauseVorEmpfang_u16; } SendMessage_sts; [/c] Hoffe ich konnte ein wenig
-
Thread
ATOI nur bis 4 Stellen
Dann würde ich vorschlagen, du fügst hier mal ein [c] if (NewValue==1) { NewValue=0; Uart_puts( uart_buffer ); // <----- uint16_t PCValue = atoi(uart_buffer); .... [/c] ein und siehst dir an, welchen String der AVR tatsächlich
sehen. Aber zumindest kann man mal sehen, ob die Anzahl der Zeichen stimmt. Dann bleibt noch Plan C: Innerhalb der ISR einen vollständigen String zur Seite kopieren, so dass der Buffer schon wieder zur Verfügung steht, damit weitere Zeichen empfangen werden können, während der erste abgearbeitet wird
-
Thread
ESP 8266 ESP-NOW Webserver
] = incomingReadings.temp4; board["voltage"] = incomingReadings.volt; board["readingId"] = String(incomingReadings.readingId); String jsonString = JSON.stringify(board); events.send(jsonString.c_str(), "new_readings", millis()); Serial.printf("Board ID %u: %u bytes\n", incomingReadings.id
11; String jsonString = JSON.stringify(board[id]); // send current dataset String jsonString = JSON.stringify(board); // send all datasets events.send(jsonString.c_str(), "new_readings", millis
-
Thread
Folientastatur permanente ausgabe
Am Einfachsten stellst du das sicher, indem du einen NOP Befehl einfügst. Also vier mal so: [c] PORTC &= ~(1 << DDC0); // row 1 low asm volatile ("nop"); if ( !(PINC & (1<<PINC4)) ) usart_transmit_string("1 "); if ( !(PINC & (1<<PINC5)) ) usart_transmit_string("2 "); if ( !(PIND & (1<<PIND4)) ) usart_transmit_string("3 "); [/c]
-
Thread
Riesiges Array im Flash
string_2[] PROGMEM = "String 2"; char string_3[] PROGMEM = "String 3"; char string_4[] PROGMEM = "String 4"; char string_5[] PROGMEM = "String 5"; [/c] Then use the new symbols in your table, like so: [c] PGM_P string_table[] PROGMEM = { string_1, string_2, string_3, string_4, string_5 }; [/c] Auslesen wollte ich dann per:[c] myChar=pgm_read_byte_far((PGM_P)pgm_read_word
-
Thread
Arduino Serielle Schnittstelle String
eigne dir erst mal ein paar Grundlagen von C bzw. C++ an, sonst ist das bodenlos
:-) Vielleicht kommst Du damit weiter ... aber Du stocherst dann auch weiterhin im Nebel. [c] if(Serial.available() > 0) { incoming = Serial.readStringUntil('\n'); } [/c] Also nimm Dir ein vernünftiges Buch oder suche Dir gute Videos (Lesen ist ja wohl nicht mehr "in
-
Thread
Speichern von mehreren strings und integern
auch verändern, wenn man Zeiger verwendet. So wie mit: [c] char Name[10] ... FLASH_Status FLASH_ProgramByte(& Name, 'A'); // Erstes Zeichen in Name ... [/c] der Name änderbar ist, geht das auch mit Zeigern. [c] char *Name; ... FLASH_Status FLASH_ProgramByte(Name, 'A'); // Erstes Zeichen in Name ... [/c] oder sogar, um den Zeiger auf einen String zu ändern, den es im Flash schon gibt: [c] char *Name; ... FLASH_Status FLASH_ProgramWord((uint32_t) Name, & NeuerName); ... [/c] Beim Schreiben
-
Thread
AVR-GCC: Variable wird im Interrupt gekillt / Math.h-Frage
LCD-Routinen habe ich mal nicht mitgeliefert, sind 1:1 aus dem AVR-GCC-Tutorial abkopiert. [c] // Testdatei // CPU = ATMega16 #include <avr/io.h> #include "lcd-routines.h" #include <avr/pgmspace.h> #include <stdio.h> #include <avr/interrupt.h> char StringImFlash[] PROGMEM = "FRG7
(Numout, "%02d", Minuten2); lcd_string(Numout); lcd_data(':'); sprintf(Numout, "%02d", Sekunde); lcd_string(Numout); } [/c] Gruß Jadeclaw.
-
Thread
Senden von "Zahlen" über UART
Buffer[20]; int i = 5436; sprintf( Buffer, "%d", i ); // Buffer enthält jetzt den String "5436" Du solltest dir Literatur zum Thema 'C' besorgen. Ohne sie wirst du nicht weit kommen.
(char *s) { while (*s) { /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */ uart_putc(*s); s++; } } [/C] und mit diesen Hilfsfunktionen macht man dann: [C] char Buffer[20]; int i = 5436; sprintf( Buffer, "%d", i ); uart_puts
-
Thread
Leerzeilen im Code verändern Programmverhalten?!
ist es ein Compi- ler-Bug. Nebenbei: Deine Include-Hierarchie ist ziemlich krumm: [pre] funk.c | +——16f688.h | +——defines.h | +——globals.h | +——int.c | | | +——globals.h | | | +——defines.h | +——string.h [/pre] Von int.c werden defines.h und globals.h in der
egal. Folgende Hierarchie wäre also besser: funk.c: [c] #include <string.h> #include <16f688.h> #include "defines.h" #include "globals.h" #include "int.c" [/c] int.c: [c] #include <16f688.h> #include "defines.h" #include "globals.h" [/
-
Thread
Programmiergrundlagen: array=array?
Wäre gut, wenn ihr mir nochmal helfen könntet. Wie überprüfe ich, ob in einem String eine Newline (\n) vorhanden ist? [c] strchr(array, '\n'); [/c] So geht das nicht, da \n kein char ist
> > So geht das nicht, da \n kein char ist Warum soll das nicht gehen: Einfacher Test: [c] #include <stdio.h> #include <string.h> int main(void) { char buf[10] = "Hallo\n"; char *ptr_base; char *ptr_find; ptr_base = buf; ptr_find = strchr(ptr_base, '\n');
-
Thread
Display Position bestimmen
sizeof nehme ich doch den Inhalt von data. Es zeigt aber immer nur 2 an. Wie kann ich die Größe vom string herauslesen. [c]lcd string ("juhuuuuuuuu"); void lcd_string( const char *data ) { int zeichen; zeichen = sizeof(*data); while( *data != '\0' ) lcd_data( *data++ );
nehme ich doch den Inhalt von data. Es zeigt aber immer nur 2 > an. Wie kann ich die Größe vom string herauslesen. Ähm. Du brauchst ein C-Buch http://www.mikrocontroller.net/articles/String-Verarbeitung_in_C Ausserdem kommt hierbei .... > zeichen = sizeof(*data); ... 1 raus.
-
Thread
"Gradzeichen" und "C" auf LCD Display ausgeben 16*2
[c] char buf[2] = {0xa0, '\0}; lcd_puts(buf); [/c]
Hi >wäre das eine möglichkeit?? >lcd_puts("Temperatur:-----°C") >--- als leerzeichen ersetzen Nein. Das '°' in deinem String hat den ASCII-Wert 0xB0. Aber evtl. funktioniert das lcd_puts("Temperatur:-----",0xDF,"C"); MfG Spess
-
Thread
befehle aus lcd-routines.c
Guten Tag, Seit ein Paar Tagen beschäftige ich mich mit den Sources: "lcd-routines.c & lcd-routines.h". Ein Befehl kann ich nicht entschlüsseln ("Fast Neuling"), weswegen ich um Hilfe bitte ^^. Grundtutorials wie z.B. Bitmanipulation sind gelesen und verstanden. Der Befehl, befindet sich im Makro "lcd_string();". Er lautet "while( *data != '\0' )", was geschieht hier? :D Dass einzige was ich mir vorstellen könnte, dass der Befehl an den String "data" abschließend dass \0 setzt..
-
Thread
Zeiger auf String-Array wird falsch
);[/c] Die Semantik von pgm_read_xxx ist einfach: [c]#define pgm_read_xxx(addr) (*(addr))[/c] vorausgesetzt die Zeiger haben die richtigen Typen. Dementsprechend ist [c]pgm_read_xxx (& var) // entspricht var[/c] [c]const char *temp1 = & g_LCDML_DISP_lang_lcdml_table[id];[/c] Ebenso wird strcpy_P nicht gebraucht: Einfach strcpy verwenden: [c]strcpy (var, & g_LCDML_DISP_lang_lcdml_table[id]);[/c]
-
Thread
Stringauswertung
Hallo, ich versuche einen String auszuwerten, welchen ich über den UART empfange. Der String hat das Format x;xxxx [c] unsigned int c, c_temp, num_temp; char *abschnitt; char delimiter[]=";"; uart_gets(Line,sizeof Line);
[[String-Verarbeitung in C]]
-
Thread
menu.h dynamisch menu-Objekte hinzufügen
aus C++ und C, aber der Threadersteller hat die Sprache ja nicht genannt - von daher ;-)
was schief gelaufen return; newMenu.name = "fdfdfd"; Item11.addChild( newMenu ); } [/C] Aber Achtung: Die Sache mit dem String ist deswegen noch lange nicht aus der Welt! Das geht hier nur deshalb, weil "fdfdfd" ein String-Literal ist.
-
Thread
c167 L40M, ISR, Auslösen
Sende doch deinen String von einem PC an den µC. Dann siehst du ob es richtig läuft. Und um den Interrupt zu testen kannst du da ja eine LED toggeln -> die müsste blinken wenn du Daten empfängst.
den ich an der zweiten sitzt will das aus irgend einem Grund nicht akzeptieren, wollte deshalb den string den ich schicken will 256mal den Empfänger schicken, um zu gucken ob er irgend wann, den String akzeptiert, bzw. was er mir antwortet.
-
Thread
UART sendet nicht das was er soll (kein offset problem)
} void uart3_puts (char *s) { do{ /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */ USART_Transmit(*s); s++; }while (*s); } while(1){[/c] Ein einzelnens Zeichen ausgeben funktioneirt [c]USART_Transmit('e');//Ausgabe: e[/c]
Die Funktion uart3_puts änderst du mal so um [C] void uart3_puts (char *s) { while( *s ) { /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */ USART_Transmit(*s); s++; } } [/C] damit ist schon mal der Fehler,
-
Thread
Arduino, Oled_SH1106, Erweiterung im Menü wird nicht angezeigt.
, FONT_STRETCHED, 0, 1); oledWriteString(&ssoled, 0,70,6,(char*)"Grad", FONT_NORMAL, 0, 1); break; [/c] Case 8: also der Nachfolgende, wird mit fast identischem Text nicht angezeigt.
Problem zu finden. Der Entwickler schreibt da: >If you need to print formatted output of numbers, strings, etc, you can do it >like this: > > [c] char szTemp[32]; [/c] und wer jetzt etwas hoch scrollt findet bei meinem Code-Schnipsel: [c] char buffer[32] = {0}; [/c] und wie ja bereits sagte,
-
Thread
ADC in String umwandeln
[[Festkommaarithmetik]]! Gleitkomma-Berechnungen sind auf einem µC nicht nur Ressourcenfresser, sondern in diesem Fall auch völlig unsinnig. Und die Funktion heißt nicht umsonst /itoa/ (*integer* to ascii), weil sie integer-Werte (/ganzzahlige/ Werte) in einen ASCII-String
Funktion /itoa/ in der libc-Doku anschauen! Das mit Deinem adcbuffer kann so nicht funktionieren. Ein String wird in C als /Array of char/ abgelegt und ist außerdem noch nullterminiert, braucht also ein Zeichen mehr als der eigentliche String hat. Wenn Du etwas Sinnvolles rausbekommen willst, dann so [c]
-
Thread
Mehrere FTDI´s (FT232) an einem Rechner identifizieren?
Hi, ich programmiere den ID-String des FT232 wie im folgenden c# Code gezeigt, um und kann dann mit [c] if (ftdi.OpenByDescription (Description) == FTDI.FT_STATUS.FT_OK) { ... ftdi.Close (); } [/c] auf den passenden
CONNECTED // Connected to xxyyzz board }; ... // Different ID-strings of unprogrammed and programmed FT232 chips. public const string IDStringXYZ = "XYZ "; public const string IDStringOrg = "FT232R USB UART"; public string IDStringLast = ""; ...
-
Thread
char - Array to String
es heist auch string.h ABER in C sind strings arrays aus chars, also is da nix mit umwandeln.
arbeitest. > > Verwende einen AVR, wie muss ich das nun anschreiben? Gar nicht * das ist nicht C sondern C++ * mit der C++ Implementierung hast du keine String Klasse verfügbar. Deine einzige Chance ist: C lernen und wie in C Strings gehandhabt werden.
-
Thread
Messn wieoft ein Schalter prellt
signal.h> //AVRStudio4.12 //#include <sig-avr.h> //AVRStudio3.56 #include <stdlib.h> #include <string.h> #include "LCD_4.h" #include "LCD_4.c" char Text1[]= "***Jueeergen**\0"; //Text1 in Flash-Ram char Text2[]= "**Run \0"; //Text1 in Flash-Ram char Leer[] = " \0";
signal.h> //AVRStudio4.12 //#include <sig-avr.h> //AVRStudio3.56 #include <stdlib.h> #include <string.h> #include "LCD_4.h" #include "LCD_4.c" char Text1[]= "**Prellzaehler**\0"; //Text1 in Flash-Ram char Text2[]= "**Run \0"; //Text1 in Flash-Ram char Leer[] = " \0";
-
Thread
Attiny1616 USART Verständnissproblem
_init(void); void USART0_sendChar (char c); void USART0_sendString(const char *str); void USART0_sendChar(char c) { while (!(USART0.STATUS & USART_DREIF_bm)) { ; } USART0.TXDATAL=c; } void USART0_init (void) {
while (1) { USART0_sendString("Hello World!\r\n"); _delay_ms(500); } } [/c]
-
Thread
Eingabe über Terminal + Ausgabe dieser Eingabe!
]] - Link zu Artikel Also [ c] ---Hier steht Code---- [ /c] (natürlich OHNE LEERZEICHEN bei [ c] und [ /c])
(){ char str_buffer[64]; sci0_init(); sci0_puts("Bitte String eingeben:"); sci0_gets(str_buffer); sci0_puts("\nDie Eingabe lautet: "); sci0_puts(str_buffer); while(1); } [/c] *freu* THX an alle!!!
-
Thread
Problem mit UART Library von Peter Fleury
unten den aktuellen Stand meines Experimental-Codes an. Startpunkt für das Hauptprogramm war test_uart.c aus dem Archiv direkt von Peter Fleury's Webpage. Strings vom Atmega zum Terminal hat von Anfang an gut geklappt. Hab zunächst mal die PROGMEM Sachen rausgetan um eine mögliche Ursache zu eliminieren
if it can not write the whole string to the circular * buffer */ uart_puts("COMMODORE BASIC V2\r\n"); /* * Transmit string from program memory to UART */ uart_puts("39387
-
Thread
SD Karte Initialisieren
die Hilfe Gruss Hier der Ausschnitt aus dem Code: ------------------------------------- [c]USART_Sende_String("Initialisiere SD Karte in SPI-Mode\n\r"); uint8_t b; for (b = 0;b<0x0f;b++) //Sendet min 74+ Clocks an die MMC/SD-Karte { mmc_write_byte(0xff); } USART_Sende_String
); // PortB Pin 0 (SPI CS) -> Ausgang USART_Sende_String("Aktiviere SPI\n\r"); // Aktiviere SPI als Master mit OSC/128 SPCR = (1<<SPE) | (1<<MSTR) | (1<<SPR1) | (1<<SPR0); // Aktiviere doppelte Geschwindigkeit SPSR = (1<<SPI2X); [/c]
-
Thread
Stringspielerei
Eine abschließende 0 sollte man an den String vielleicht auch anhängen. (Hast du in den zwei Tagen mal in ein C-Buch reingesehen?)
man streiten, über Stil sowieso. Trotzdem mal ein Vorschlag, den ich deutlich lesbarer finde: [c] #include <stdio.h> #include <stdlib.h> #include <string.h> // kopiert String auf sich selbst, und fügt dabei je (nSperrung) // Leerzeichen ein: char *sperrungEinfuegen( char s[], int nSperrung
-
Thread
Atmega8: 16x2 LCD keine Zeichen nach LCD Init
wenn man die Ausführzeiten der Kommandos wie im Datenblatt einhält wird auch ein Charakter bzw. ein String am LCD ausgegeben. Vielen dank nochmals für die Unterstützung. Ich werde wahrscheinlich noch weiter berichten wenn das LCD am I2C hängt. Grüße Luki
:) Ich habe leider wieder Probleme mit meinem LCD Display. Dieses mal habe ich das LCD über I2C angeschlossen und natürlich dazwischen den Portexpander und die nötige Elektronik dazu. Das LCD Init funktioniert einwandfrei, ich kann auch Strings am LCD ausgeben usw.. ABER ich kann meinen
-
Thread
Umwandlung der CS_UID zur Ausgabe über UART
würde mir helfen es in ascii umzuwandeln.. ----------------------------------------------------- [c] #include <stdio.h> #include <string.h> int hex_to_int(char c){ int first = c / 16 - 3; int second = c % 16; int result = first*10 + second; if(result > 9) result
dabei rausgekommen.. ------------------------------------------------------------------------ [c] #include <stdio.h> #include <string.h> #define CS_UID 0x1234567890abcdff int hex_to_int(char c){ int first = c / 16 - 3; int second = c % 16; int result = first*10 + second; if(result
-
Thread
Stringaufgabe
Befehl nur bei Zahlen oder auch bei Buchstaben anwendbar? Da, bei folgendem Code: char string[]="Alle Vokale werden gezaehlt"; char string_ohne[] = "aeiou"; int anzahl = strspn(string, string_ohne); int konst = strlen(string)-anzahl; printf("Anzahl Vokale: %d Anzahl der Konstanten
Ist es so schwierig, zu verstehen, dass strspn() und strcspn() die Länge des Strings ab Beginn ermitteln, der die Bedingung erfüllt? Und nicht den gesamten String nach Teilen untersucht, die zur Bedingung passen? Das steht doch im C-Buch.
-
Thread
Eine Funktion elegant mehrmals hintereinander aufrufen
kannst du nun schreiben [c] GLCD_Schreiben_string ("Hallo"); [/c]
[c] void GLCD_Schreiben_string (char *s) { while (*s) { /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */ GLCD_Schreiben(*s); s++; } } [/c]
-
Thread
Integer Zahl möglichst effizient auf Display ausgeben
Chris S. schrieb im Beitrag #3162103: [c] char data[10]; itoa(value, data, 10); char string[10]; string[0] = data[0]; string[1] = data[1]; string[2] = '.'; string[3] = data[2]; string[4] = data[3]; string[5] = '\0'; char str[10]; sprintf(str,"%s",string); LCD_Print(data, ...); [/c] Zum optimieren erstmal überlegen, warum das ganze so umständlich ist: das ganze String-hin-und-herkopieren, das unnötige sprintf dazu usw, machst du nur, damit deine
-
Thread
Einfach Frage zu einer Funktion!
Enqueue. Dann ist es trivial darauf aufbauend eine Funktion zu schreiben, die einen kompletten String, inklusive Terminierung, einstellt [C] void Enqueue( uint8_t Byte ) { .... } void EnqueueString( const char* String ) { while( *String != '\0' ) Enqueue( *String++ ); Enqueue( '\0' ); } int main() { char Test[] = "Juhu"; EnqueueString( Test ); EnqueueString( "Noch ein Test" ); } [/C] Und genauso simpel ist es die gegenteilige Funktion zu schreiben, die, aufbauend auf einer Funktion die ein Byte aus dem Ringbuffer holt,
-
Thread
ESP will Domain nicht aufrufen.
} } while(client.available()){ String line = client.readStringUntil('\r'); Serial.print(line); } [/c] "server.send" ist überflüssig und auch bei den includes müsste mal ausgemistet werden.
funktioniert. [code] #include <Arduino.h> #include <ESP8266WiFi.h> #include <Wire.h> #include <String.h> char thingSpeakAddress[] = "api.thingspeak.com"; char thingSpeakSHA1[] = "78 60 18 44 81 35 BF DF 77 84 D4 0A 22 0D 9B 4E 6C DC 57 2C"; uint thingSpeakHTTPSPort = 443; WiFiClientSecure
-
Thread
bringe LCD-Display nicht zum laufen
// Funktion LCD Initialisieren extern void lcd_puts (const char *lcd_string); // Funktion Display String ausgeben #endif [/c] [c] // ---- LCD Driver Routine for 2x16 / 4x20 char. Display // (c) B. Nollmeyer, WINAVR sample Routine! Das Display
// Funktion LCD Initialisieren extern void lcd_puts (const char *lcd_string); // Funktion Display String ausgeben #endif [/c] [c] // ---- LCD Driver Routine for 2x16 / 4x20 char. Display // (c) B. Nollmeyer, WINAVR sample Routine! Das Display
-
Thread
strcmp() gibt immer "true" zurück
dir ist klar, das strcmp zwei Strings auf "Größer/Kleiner" vergleichen soll, und entsprechend >0 / <0 zurückgibt? Nur wenn die Strings gleich sind, kommt 0 raus. d.h. [c] if (strcmp(usart_RX_buffer, "Test")==0){ ... [/c]
man Leerzeichen (als schlampiger) Mensch nicht sieht. D.h. es ist eine gute Idee, sich vor dem STring und hinter dem String Terminierungszeichen auszugeben! [C] if (usart_RX_Complete == 1){ sendString("#"); sendString(usart_RX_buffer); sendString("#"); [/C] tippst du
-
Thread
UART String Zerlegen.
Empfangen habe ich alle erfolgreich umgesetzt. Die Daten liegen nach dem Empfang in einem ANSI C String wie z.B. "gettemperatur 1 1\0" Dies bedeutet hole mir die Temperatur von Sensor 1 mit Nachkommastelle. Mein Problem ist nun das ist nicht weiß wie ich diesen String nun in seine Teile zerlegen
frage ob das so effektiv ist. Nach dem Durchlauf stehen in token die Pointer zu den Tokens. [c] char *pch; char *token[10]; pch = strtok(buffer," "); i=0; while (pch != NULL) { token[i]=pch; printf ("TOK %s\n",pch); pch = strtok(NULL, " "); i++; }[/c]
-
Thread
Variable lässt sich nicht beschreiben
{ printf("Wrong character (only numbers and commas)"); } } else { recv_string[counter] = '\r'; conv_cmd_string(); } } [/c] Code für die Umwandlung des Strings und Speichern in die Globale Variable. cmd_value und val_value sind die global deklarierten Variablen. [c] void conv_cmd_string(void) { int cmd_val = 0; int counter = 0; int cmd_counter = 0; int val_counter = 0; int x = 0; int y = 0; if(cmd_val == 0) { for(cmd_counter =
-
Thread
DCF-Empfänger probleme (erhalte kein high-signal am pin)
(1 << CS10); // CTC-Mode clkIO/64 OCR1A = (2500-1); TIMSK1 = (1 << OCIE1A); uart_sendString("\r\nstart\r\n"); sei(); while (1) { } [/c] timer-isr [c] ISR (TIMER1_COMPA_vect) { if ((PINB & (1<<DCF77_TCO_PIN))) uart_sendString("1"); else uart_sendString("
> DCF" sein? Die hat gewisse vorteilhafte Eigenschaften, ist aber dafür ausgelegt, dass der µC mit 5V betrieben wird. Im Prinzip könnte man sie aber mit geringen Änderungen auch an mit 3.3V betriebenen µC verwenden. Nötig ist sie aber meist nicht. Eigentlich nur, wenn die Versorgung des µC
-
Thread
STM32F4 Discovery Board + USART
while( !(USARTx->SR & 0x00000040) ); USART_SendData(USARTx, *s); *s++; } } [/c] Ich habe PC6 mit TX des USB->RS232 Konverters verbunden und gebe mir die Daten mit dem Programm "hterm" aus. Leider erhalte ich nur "kuriose" Zeichen in "hterm" und nicht den gewünschten String
); string_complete = 0; } } } [/c]
-
Thread
Datentypen Problem
verarbeitet nur diese Bits. Für den bitunkundigen Menschen könne die dargestellt werden als: - String mit 8 Binärziffern - String mit 2 Hexziffern - String mit 1 bis 3 Dezimalziffern - String mit 3 Oktalziffern - ASCII-Zeichen (1 Zeichen) - Bitmap mit 8 einfarbigen Grafikpixeln - Farbe eines
Lies dir erstmal n Buch zum Thema C durch.. Und vllt. mal bei Wikipedia gucken.. Und dann gleich nochmal Ascii lernen
-
Thread
STM32 Kompilat größer als erwartet
auf sowas wie puts oder printf generell pfeife, und mir meine eigenen, an die Verhältnisse auf dem µC angepaßten E/A-Möglichkeiten geschrieben habe. Mittlerweile hab ich davon ja hier genug gepostet. Allerdings muß man dann eben nicht puts hinschreiben, sondern z.B. String_Out(...). Ob das dem einen
sowas wie puts oder printf generell pfeife, und mir meine eigenen, > an die Verhältnisse auf dem µC angepaßten E/A-Möglichkeiten geschrieben > habe. > > Mittlerweile hab ich davon ja hier genug gepostet. Allerdings muß man > dann eben nicht puts hinschreiben, sondern z.B. String_Out(...). Ob das