-
Thread
Verständnisfrage zu char
raten angesagt... Ich versuch mich mal am Raten. Du verwnedest in den Funktionen irgendwo eine string Funktion? Sowas wie strcpy vielleicht? [c] char Eheit2 =65;// 'A'; [/c] Hier fehlt die abschließende 0, der einen String abschließt. Bei der Version: [c] char *Eheit2 ={"A"}; [/c] wird diese
Ja also genau das was wir vermutet hatten. Im ersten Fall hat einfach die "String-Kennzeichnung" gefehlt. http://www.exforsys.com/tutorials/c-language/handling-of-character-strings-in-c.html
-
Thread
STM32 OLED MiniScope
HAL_ADC_Start (&hadc1); ssd1306_SetCursor(0,0); ssd1306_WriteString("20ms", Font_7x10, White); ssd1306_UpdateScreen(); break; } [/c] Initialisierung in adc.c [c] /* ADC1 init function */ void MX_ADC1_Init(void) {
Ich programmiere mein STM32F103C8T6 Board über einen STLINK V2 Adapter vom Nucleo-Board. USB hab ich noch nicht ausprobiert. Zum ADC: Laut Datenblatt schaft der STM32F103C8 1MHz Samplerate (12Bit) bei 14MHz Clock Frequenz.
-
Thread
allgemeine PicoMite Anfängerfragen
Weiter mit I²C: Es lag nicht an den externen Pullups sondern an der falschen Version des LM73 (I²C Temperatursensor). Ich habe deshalb mal einen I²C-Scanner gebastelt: [code] izs: SetPin gp20,gp21,i2c I2C open 100,1000 For adr = &H00 To &Hff I2C read adr,0,1,reg If MM.I2C = 0 Then Print "Adresse: "Hex$(adr)" = "Bin$(adr)" Wert: "Hex$(reg)" = "Bin$(reg) EndIf Next adr I2C close [/code] Der LM73 hat laut Datenblatt die Adresse &B1001
-
Thread
Menüstruktur mit Text im Atmel
Ach, noch was: Ich gebe mir über USB viele Debug-Ausgaben. Z.B. so: [c] usb_puts("Menu active"); [/c] Wie kann ich diese Strings in den Flash bringen? Kann ich die in den Flash casten, oder muss ich die als Variable deklarieren und dann auslesen?
da nicht - der AVR selbst weiß auch nicht, dass MeinArray im Flash liegt. > Wie kann ich diese Strings in den Flash bringen? Für Strings gibt es ein Makro: [c] usb_puts_P(PSTR("Menu active"))); [/c] Das PSTR sorgt automatisch dafür, dass der String dahinter im Flash abgelegt wird, ABER ACHTUNG
-
Thread
itoa mit zwei Dezimalstellen
dem String eine führende 0 zu verpassen?
char puffer[4]; lcd_clear(); itoa((int) stunden+100, puffer, 10); lcd_string(&puffer[1]); lcd_string(" : "); itoa((int) minuten+100, puffer, 10); lcd_string(&puffer[1]); lcd_string(" : "); itoa((int) sekunden+100, puffer, 10); lcd_string(&puffer[1]);
-
Thread
I2C Real Time Clock/Calendar (DS1337
Normal muss doch der String mit \0 terminiert werden. Ggf. überschreibt es dir etwas im Speicher bei Minuten und Stunden mit dem \0. Kannst du den µC debuggen und dir den Speicher vor und nach dem beschreiben der Sekunden
) > { > > for( uint8_t i = getDigitCount(value); i < c; i++) > lcd_print_P(PSTR("0")); > } > lcd_print(str); > } > [/c] [c] ... void lcd_print(char *string) { while(*string) { lcd_putchar(*string++); } } [/c] schneller
-
Thread
String in integer umwandeln
Pfeiffy schrieb im Beitrag #2728968: > wende ich atoi falsch an? Ja. [c]channel= atoi(&uart_string[1]);[/c]Funktioniert aber nur, wenn nach der '1' keine weiteren Ziffern kommen.
Wenn es nur eine Ziffer ist, kannst du auch [c]channel = uart_string[1]-'0';[/c] schreiben.
-
Thread
Uart, Empfangener String ist leer
"Uuund..."); //Debuggen UART_SPS; //Mux auf SPS einstellen uart_gets(dateiname_c, 7); //String empfangen strcpy(filename, dateiname_c); // Erstellung des Filenames strcat(filename, ".TXT"); UART_USB; //Mux auf USB einstellen uart_puts(dateiname_c); //Kontrolle uart_puts(filename); [/c] [c] void uart_gets( char* Buffer, uint8_t MaxLen ) { uint8_t NextChar; uint8_t StringLen = 0; NextChar = uart_getc(); // Warte auf und empfange das nächste Zeichen
-
Thread
Uart funktioniert nicht
char buffer; int main(void){ uart_init(); while(1){ uart_send_string("on"); _delay_ms(1000); uart_send_string("off"); _delay_ms(1000); } } [/c] Hier die Lib: uart.c [c] #include <avr/io.h> #include <stdlib.h> #include "uart.h
HIGH(x) (((x) >> 8) & 0xFF) //Highbyte void uart_init(void); void uart_send_char(unsigned char c); void uart_send_string(char* s); uint8_t uart_get_char(void); void uart_get_string(char *buffer, uint8_t MaxLen); #endif [/c] Was stimmt net?
-
Thread
Größere Datenmenge über UART
); uart_puts((char *)send); uart_puts("\n"); [/c] Empfänger: [c] char uart_string[80] = ""; uint32_t buffer=0; char result[10]; buffer=atoi((const char *)uart_string); bx= buffer%1000; itoa(bx, result1,10);
} p++; pos--; } *valuep = atoi (p); return 1; // OK! } [/c] Aufruf dann: [c] if (myscan (uart_string, 0, &P_Ry1) && myscan (uart_string, 1, &P_Ly1) && myscan (uart_string, 2, &by) && myscan (uart_string, 3, &bx)) {
-
Thread
UART läuft auf ATMEGA 32 aber nicht auf 328
Mischmasch aus alter+neuer String entstehen.
1<<LED_ARDUINO) #define LED_ARDUINO_OFF LED_ARDUINO_PORT &= ~(1<<LED_ARDUINO) #endif [/c]
-
Thread
Anzahl der Array Elemente
= 0; for(str=0; str<(sizeof(data_string)/sizeof(char));str++) { LCD_OutChar(data_string[str]); } } [/c] danke schonmal für eure Hilfe :)
LCD_OutString( const char* c ) { while( *c != '\0' ) LCD_OutChar( *c++ ); } [/C] Fertig. Informier dich über Stringverarbeitung in C. Das ist täglich Brot und sind Grundlagen.
-
Thread
string to int [8051]
Hä? Ein String wird in '"' geschrieben und dort ist dann automatisch eine Nullterminierung drin. [c] char test[4] = {'0','1','0',0}; [/c] ist genau das gleiche wie [c] char test[] = "010"; [/c] ist genau das gleiche wie [c] char test[] = {'0','1','0',0}; [/c]
-
Thread
ADC Text-LCD-Ausgabe
kHz bei F_CPU = 8 MHz) eingestellt. Weiterhin habe ich ein Text-LCD am PortA und 8 LEDs an PortC dran. Mit der Einbindung und Anpassung der "lcd.h" und "lcd.c" funktioniert die lcd_data-, als auch lcd_string- Über-/Ausgabe einwandfrei. Eine als string deklarierte Zahl kann mittels "my_print_lcd
angeschlossen habe (Labornetzteil zur manuellen veränderung dran!). Ich starte die Umwandlung, der µC rödelt zu meiner Zufriedenheit los und gibt mir einen digitalen Wert zurück. SUPER!!! Den digitalen Wert übergebe ich anschließend auf die itoa() Funktion und lass einen 5stelligen String erzeugen,
-
Thread
Array an Funktion übergeben (Pointer)
(char *string){ while(*string){ send_Char(*string++); } }[/c] RX Interrupt: (ein Zeichen wir so lange in rx_buffer gespeichert, bis 0xFD emfpangen wird) [c]ISR(USART0_RX_vect){ static unsigned
Ben Ha schrieb im Beitrag #2429729: [c]unsigned char rx_buffer[100];[/c] [c]void send_String(char *string)[/c] [c]send_String(&rx_buffer[0]);[/c] Wie der Compiler bereits gesagt hat, sind Parameter und erwarteter Typ nicht (notwendigerweise
-
Thread
codier schalter
>> lcd_string((PINC & 0x0f) | 0x30 ); > > was schreibe ich dann in die if schleife.? bzw. else if [c] #include <avr/io.h> #include "lcd-routines.h" #include <util/delay.h> int main(void) { lcd_init
(100); } return 0; } [/c]
-
Thread
AVR: char arry in string copieren + fehlerhaftes Verhalten
die Char_Array aus, ist die Welt heil. Also wird das Problem beim Umkopieren vom Char Array nach String auftauchen, was ich mir jedoch nicht erklären kann. Hier ist mein Code: [c] char *my_str; char char_arr[127]; u8 uart_getc(void) { while (!(UCSR1A & (1<<RXC1))); return UDR1
my_str = char_arr; // ist das falsch? my_str[len] = '\0'; // release received string len = 0; received = 1; /* if (my_str[0] == 0x03) { my_str += 1; } */ } } ISR (USART1_RX_vect) { uart_gets(MAX_STR_LEN); } [/c] PS: Für my_str reserviere
-
Thread
Zeichenketten ueber UART
Usart_Rx(void) { while (!(UCSR0A & (1<<RXC0))); return UDR0; } void uart_put_string (unsigned char *data_string) { while(*data_string) Usart_Tx(*data_string++); } [/c] Gruss Owen
Was mir erstmal auffällt: [c] if (enter) { enter = 0; uart_put_string(str); } else { temp = Usart_Rx(); // enter = Usart_Rx(); //while(1); } [/c]
-
Thread
MSP430 Eclipse und mspgcc
Schleifen hin gekriegt, bei der anderen will es nicht. Die Schleife lautet folgendermassen: void sendString(char* string) { for(int i = 0; string[i] != '\0'; ++i) Wenn ich das jetzt so schreibe: void sendString(char* string) { int i; for(i = 0; string[i] != '\0'; ++i) bekomme ich wieder
Tjo, weiß ich auch nich, aber mach doch: [c] while(string) { Senfunktion.... string++; } [/c]
-
Thread
GCC section für string
Hallo zusammen! Ich hab ne Frage zu GCC: ich möchte einen String im EEProm ablegen. Das geht ja über [c]__attribute__((section (".eepromSection"))) [/c] (mit einer entsprechenden section im linker file. leider funktioniert das nur bei Variablen: [c]char __attribute__((section (".eepromSection"))) abc[] = "meinStringImEEPROM"; [/c] Es funktioniert aber nicht, wenn ich einfach einen konstanten String aus dem EEPROM einer Funktion übergeben will: [c]void function(char * arg); function(__attribute__((section
-
Thread
Fehler bei SRAM Berechnung?
ifndef UART_TX_BUFFER_SIZE #define UART_TX_BUFFER_SIZE 32 #endif #define STRING2(x) #x #define STRING(x) STRING2(x) #pragma message("Wert = " STRING(RAMEND)) #pragma message("Wert = " STRING(UART_RX_BUFFER_SIZE)) #pragma message("Wert = " STRING(UART_TX_BUFFER_SIZE)) #pragma
dieses "-save-temps -g3" mit aktiviert und die defines sehen in den *.i Dateien so aus, wie erwartet: [c]#define RAMEND 0x10FF #define UART_RX_BUFFER_SIZE 32 #define UART_TX_BUFFER_SIZE 32[/c] @amateur: Welche Makros meinst Du? Die String und pragma message Zeilen können wir getrost ignorieren; die
-
Thread
MSP430 Problem mit UART Empfang
zurück und erlaubt so der Interrupt Funktion die nächste Zeile in diesem Buffer zusammenzusetzen. [C] ... char tmp_str[40]; unsigned char NextStr; volatile unsigned char StringReady; #pragma vector=UART0RX_VECTOR __interrupt void usart0_rx (void) { if( StringReady == 1 ) { /*
mehr gebraucht wird. */ LCDOuts( "°C" ); } } } [/C]
-
Thread
Array als define definiert
[c] #define ERROR_NO_ARRAY const char ERROR_NO[] = { 18, 19, 20, 21, 22, 23, 24, 25}; #define ERROR_NO_ARRAY_SIZE (sizeof ERROR_NO / sizeof ERROR_NO[0]) [/c]
Erstens kennt C keinen Datentyp "string", weshalb man auch in C keinen String als Ganzes zuweisen kann. Das ist aber genau das, was Du da versuchst. Und wenn die Strings in einem Array abgelgt werden sollen, dann wird
-
Thread
Lohnt sich embedded in C++ zu programmieren
/articles/C_vs_C%2B%2B
. Es gibt ein new im Konstruktor und zwei im Code, die kann man aber wegoptimieren wenn der json string im Ram liegt. Läuft wunderbar auf einem kleinem Cortex-M0 mit 16 kB Flash. Hat natürlich nicht soooviel Komfort aber immerhin. Der C-Programmierer lässt den C++ Wrapper weg und nimmt das nackte JSMN
-
Thread
Brute Force mit dem Arduino
@ Autor: Simon Spettmann (simonsp) Hast du schon einmal daran gedacht C/C++ zu lernen?
Jetzt geht es. Und ich soll C/C++ lernen...
-
Thread
dualzahlen in Dezimalzahl mit dem AT89C51
So könnte man das wahrscheinlich auch machen: [c] #include <stdio.h> #include <string.h> #include <inttypes.h> int main(void){ #define LENGTH_DUAL 16 char input_dual[LENGTH_DUAL]={0}; puts("Zahl (binaer) eingeben:");
c &= 1; zahl = (zahl<<1) | c; idx++; break; default: MeckerText_Out("Bitte nur 0 oder 1 eingeben"); } [/c] W.S.
-
Thread
String in Array reinschreiben
Hallo, würde mich freuen wenn mir hier einer helfen könnte.: Ich habe folgendes Problem. Ich möchte mehrere Telefonnummern (Handynummern) in ein Array speichern. Programmiersprache ist C. Da diese Nummern ja sehr lang sind weiß ich nicht wie ich das anstellen soll. Komme einfach nicht zum Ziel: unter anderem habe ich es mit folgenden Zeilen probiert. char Number[30]; Nummer[0] = "+49...."; Für einen Tipp wäre ich dankbar! Gruß Thomas
-
Thread
AVR Studio - "location not valid"
wo? Ein Tip: klau nie wieder bei dem Typen. Stringbehandlung ist der erste Stolperstein für jeden C-Programmierer. Und da siehts bei ihm eher düster aus, wenn er nicht weiß, dass er für einen String mit 2 sichtbaren Buchstaben ein Array der Länge 3 braucht und was er mit dem 3.ten char im Array machen
16) == value)[/c]
-
Thread
S: Doku für SI5351 I2c LowLevel
=I2C_ReceiveData(I2C_EE); snprintf(obp,40,"si5351 read8 nach ReceiveData"); USART3_PutString(obp), USART3_PutString("\r\n");; I2C_AcknowledgeConfig(I2C_EE, DISABLE); /* Send
(I2C2, i2c_address << 1, I2C_Direction_Transmitter); while(!I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)); I2C_SendData(I2C2, reg); while(!I2C_GetFlagStatus(I2C2, I2C_FLAG_BTF
-
Thread
atmega 1284P Jtag (aus) PINC2 ohne Funktion
eine universelle Zahlenausgabe haben will. Mach dir halt eine einfach zu benutzende Funktion dafür! [C] void lcd_int( uint8_t line, uint8_t col, int number ) { char buffer[7]; itoa( buffer, number, 10 ); lcd_setcursor( line, col ); lcd_string( buffer ); } [/C] ... dann hast du an einer
[C] void lcd_text( uint8_t line, uint8_t col, const char* text ) { lcd_setcursor( line, col ); lcd_string( text ); } [/C] [C] uint8_t vs[4]={36,20,24,40},hs[8]={36,4,20,16,24,8,40,32},
-
Thread
Uhrzeit in einem String zusammen packen!
möglich ohne großen Aufwand... meine Daten --> Sekunden... Minuten... Stunden... in einen String zu packen und gemeinsam auf dem GLCD aus zu geben ?! hier der Code... Ich mache es imoment so... eine kleine frage noch... Code: [c] Sekunden &= 0x7F; Minuten &= 0x7F; Stunden &=
einzelner Ausgabe, die Einzelteil halt zunächst mal in einem String zusammensetzen [c] void WriteTime( uint8_t hour, uint8_t minute, uint8_t second ) { char timeStr[9]; timeStr[0] = ( hour >> 4 ) + '0'; timeStr[1] = ( hour & 0x0F ) + '0'; timeStr
-
Thread
Adresse eines Pointers sichern in C
einfach machen: xx = (unsigned long)&feld; PS: Du brauchst Literatur. Eine Sprache wie C kann man nur bis zu einem gewissen Grad (der schnell erreicht ist) durch Versuch und Irrtum erlernen.
Das sollte funktionieren: [c] char feld; unsigned long ptr; ptr=(unsigned long)&feld; printf("%p, %x\n", &feld, ptr); [/c]
-
Thread
strlen()
/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F
, dann musst Du denjenigen, der den *FEHLER* zu verantworten hast, darauf hinweisen. Es gibt in C keine Strings, die in einfachen Hochkommata notiert werden. 'ich bin kein String in C'
-
Thread
ASCII in Binär: Bitweises Vergleichen zweier Zeichen
Hallo, ich möchte gerne aus einem empfangenen String zwei Zeichen mit den darauf folgenden zwei Zeichen vergleichen (in C). Also so: 1. String: "A0" = 1010 0000 2. String: "20" = 0010 0000 Der zweite String beinhaltet keine neu 1, die String 1
Es ist sowieso immer alles binär. Wandeln braucht man da gar nichts. Vermutlich soll "A0" kein String sein, sondern die Hex-Darstellung des Zeichens. C hat entsprechende Operatoren für bitweise logische Funktionen. [c] char c1 = 0xA0; char c2 = 0x20; int counter = 0; if ((c1 | c2) != c1
-
Thread
sprintf, printet nicht mehr.
sprintf(ADCwert3,"rueckgabe3: %i",ADC3); sprintf(ADCwert4,"rueckgabe4: %i",ADC4); I2C_LCD_send_string_xy(" ",12,0); I2C_LCD_send_string_xy(" ",12,1); I2C_LCD_send_string_xy(" ",12,2); I2C_LCD_send_string_xy(" ",12,3); I2C_LCD_send_string_xy(ADCwert,0,0); I2C_LCD_send_string_xy(ADCwert2,0,1); I2C_LCD_send_string_xy(ADCwert3,0,2); I2C_LCD_send_string_xy(ADCwert4,0,3); }; }//Ende ADC-Routinen[/c] Das ist der Code, ein Wert wird von I2C-ADC abgegriffen (was überprüft wurde im real-time-debugger
-
Thread
High- und Lowbyte Übertragung zw. µC und PC
(Elementgröße) 1000 × 3 × 2 = 6000 Bytes/s Das geht als Binärdaten locker bei 115200 Baud. [c]Serial.write( val & 0xff ); Serial.write( val >> 8 );[/c] Als Strings geht es bei 115200 Baud nicht, das ist richtig. Aber andererseits kannst du mit dem Arduino 1 MBaud nicht bedienen, da ist der
Rudolph schrieb im Beitrag #3705335: > Wie ist überhaupt der Sensor angebunden? SPI oder I2C? Der Sensor ist mittels I2C angebunden.
-
Thread
Hex-Wert in char-Array umwandeln?
http://www.nongnu.org/avr-libc/user-manual/group__avr__eeprom.html#ga88df934c94c037b10ebeb337a6883a74
> and $C Magst Du mir das bitte erklären?
-
Thread
Typvereinbahrungen, array von Zeigern auf Flash
es Typdeklarationen mit signed/unsigned char aber nich mit char allein, kann es daran liegen? c) Die Funktion <strlen()> die in <string.h> deklariert ist, liefert einen Wert vom Typ <size_t> zurück, aber wo ist <size_t> deklariert? Ich habe angenommen das müsste beim AVR 8Bit, also <int8
verschiedene Typen. Wenn du Zeichen darstellen willst, nimm char. Dafür ist er da, und nur dafür. > c) Die Funktion <strlen()> die in <string.h> deklariert ist, liefert > einen > Wert vom Typ <size_t> zurück, aber wo ist <size_t> deklariert? stddef.h und andere (z.B. stdlib.h) > Ich habe
-
Thread
Stringauswertung Problem
Hallo, ich habe ein kleines Problem beim Auswerten eines Strings. Der String sieht folgendermaßen aus: 1.f.0.0.0.1.$ Diesen String möchte ich gern mit folgendem Code auswerten und die einzelnen Zahlenwerte in ein Array schreiben: [c] long eingang[10];
/ ---------------------------------------------------------------------------- #define PRINT(string, ...) printf_P(PSTR(string), ##__VA_ARGS__) static int putchar__(char c, FILE *stream) { uart_putc(c); return 0; } static FILE mystdout = FDEV_SETUP_STREAM(putchar__, 0, _FDEV_SETUP_WRITE
-
Thread
Größe einer beliebigen Reihe, auch unterschiedlich viele Elemente, berechnen.
Stringendezeichen '\0' als sentinel in einem Array von char bzw. byte. Das ist die Konvention (!) für C-Strings. Kannst Du aber nicht in einem Array von byte anwenden, wenn das numerische Bedeutung (wie bei Arduino als uint8_t) hat. nullptr oder (void*)0 (aka NULL in C) passt doch vom Dt nur in eine
im letzten Jahrtausend, sorry. Und so etwas gibst Du einem Anfänger mir. Fahrlässig. Die durch C-Strings motivierte Ausnahme mit '\0' als Sentinel ist schon schlimm genug. Sie wäre nur dann gerechtfertigt, wenn der DT char definitiv nur für (ASCII)-Zeichen reserviert wäre. Aber er ist ein normaler
-
Thread
Bluetooth Empfänger mit iPhone App verbinden/steuern
MC erzeugt? Ich nehme an, in dem String ist dann der Aufruf einer C-Funktion auf dem MC codiert? Hatte zuletzt vor etwa 5 Jahren ein paar kleinere MC Projekte gemacht (aber „lokal“ ohne Netzwerk) - muss mich da auch nochmal reinfuchsen
Michael schrieb im Beitrag #7516592: > Ich nehme an, in dem String ist > dann der Aufruf einer C-Funktion auf dem MC codiert? Jepp, der Mikrocontroller kann ein rudimentäres SCPI-Protokoll, die zugehörige App muss lediglich die Benutzereingabe in dieses Protokoll
-
Thread
Problem beim Anlegen mehrerer EEMEM-Variablen
inc/lcd_toolbox.c:21: error: desc_condition_string causes a section type conflict inc/lcd_toolbox.c:22: error: desc_output_string causes a section type conflict inc/lcd_toolbox.c:23: error: desc_alarm_string causes a section type conflict inc/lcd_toolbox.c:24: error: desc_hysteresis_string causes a section type conflict inc/lcd_toolbox.c:25: error: desc_address_string causes a section type conflict inc/lcd_toolbox.c:26: error: desc_target_value_string
-
Thread
Probleme mit Funktion "itoa"
Hi, versuch es mal mit: lcd_write_string_xy(1,5,test); Gruß Andreas
out(0x24,address & 0xff,address >> 8); while (*text) { out(0xC0,0,(*text++)-0x20); } }
-
Thread
Klarer unterschied zwischen CHAR und BYTE
Das bedeutet für mich aber auch jedesmal casten zu müssen. Mal ein Beispiel von Microchip [c] BOOL StringToIPAddress(BYTE* str, IP_ADDR* IPAddress) [/c] Diese funktion verwendet doch ganz klar einen BYTE pointer, und nicht ein char pointer fuer seinen string, somit bleibt mir doch nur die
doch nur die Wahl > zu casten oder ebend doch Zeichen als BYTE zu deklarieren. [C] inline BOOL CharsToIPAddress( const char* str, IP_ADDR* IPAddress ) { return StringToIPAddress( (BYTE*)str, IPAddress ); } [/C] oder auch [C] #define CharsToIPAddress(s,a) StringToIPAddress
-
Thread
Unbekannter Assembler erzeugt große Änderungen bei kleinem Programm
TEST[2] = 'L'; TEST[3] = 'L'; TEST[4] = 'O'; while (1) { } } [/c] und nach den Hexzahlen *0x48414C4C4F* und *0x4F4C4C4148* gesucht - leider keine Ergebnisse. Die Ausgabedateien mit "HALLE" anstatt "HALLO" unterscheiden sich erneut zu großen Teilen.
Ich meine natürlich PMS154C ;-O mfg
-
Thread
Bitshift funktioniert auf AVR nicht - warum?
holger schrieb im Beitrag #5172615: > Zeig mal die Zeile wo du die Variable per UART ausgiebst. [c] char String[10]; itoa(Variable, String, 10); uart_puts("Variable: "); uart_puts(String); [/c]
((uint32_t)i2cdata[2] << 16) | ((uint32_t)i2cdata[3] << 24); itoa(Variable, String, 10); puts("Variable: "); puts(String); return 0; } [/c] Offensichtlich verhält sich itoa() in der avr-lib anders als in der Libary für Windows. Warum?
-
Thread
String bilden
zahl2=2; unsigned char zahl3=3; unsigned char zahl4=4; unsigned char zahl5=5; //daher ist der String immer 5-stellig char ausgabe[6]; //werden nacheinander eingefügt und bilden einen String strcat(ausgabe,zahl1); strcat(ausgabe,zahl2); strcat(ausgabe,zahl3); strcat(ausgabe,zahl4); strcat(
>Wie kann ich dieses Problem anderes lösen ??? Ein C Buch kaufen. >Müssen die Variablen zahl1 bis zahl5 null terminiert sein ? Wenn es Strings wären ja. Es sind aber nur Zahlen und auch kein ASCII Code.
-
Thread
LCD Display, komische Ausgabe.
Wenn ich jetzt die Funktion so Aufrufe: [c] zeile=0; spalte=0; lcd_string(registernames[0]); [/c] dann bekomme ich irgend einen Mist auf dem Diplay. Die Funktion lcd_string schaut so aus: [c] void lcd_stringr (char *s)
Huch, aja! richtige Funktion ist: [c] void lcd_string (const char *progmem_s) // Display String from flash { unsigned char c; while ((c = pgm_read_byte(progmem_s++))) lcd_writechar(c); } [/c] Und ja
-
Thread
Atmega32: malloc stürzt bei mehrfachem Aufruf ab
Funktion: <code> void draw_line(char x1, char y1, char x2, char y2) { char start_of_output_string; char output_string; char *start_of_output_string_ptr; char *output_string_ptr; start_of_output_string_ptr = &start_of_output_string; //output_string_ptr = &output_string; output_string_ptr
daher ist nicht sicher, daß auch nur der erste Aufruf geklappt hat. Deine Schreibzugriffe auf output_string_ptr können also irgendwo im Speicher herumschreiben mit welchen Folgen auch immer. Was soll das hier? [c] start_of_output_string_ptr = output_string_ptr; output_string_ptr = start_of_output_string_ptr
-
Thread
String-Arrays im Flash-Memory bei AVR-GCC?
[] PROGMEM = "String2"; const char* Strings[] PROGMEM = { Str1, Str2 }; [/C]
des gewünschten Strings aus dem Flash holen. Dann an das LCD übergben ? [c] tempString = (const char*)( pgm_read_word( &(Strings[1]) ) ); lcd_puts(tempString); [/c] Passt das so? Gruß