-
Thread
Prüfroutine implementieren
charCounter == 32 || charCounter == 38 ) { // die neuralgischen Punkt if( c == '1' || c == '2' || c == '4' || c == '8' ) { // UND dann auch noch das richtige Zeichen hitCount++; if( hitCount == 50
OK, ich hab mich da auch ein bisschen ungeschickt ausgedrückt... Ich will einen kompletten String "sammeln" damit ich ihn dann zum Versand übergeben kann. --> Nächster String "sammeln", versenden... Und so weiter. > definiere 'länger' Ich meinte damit genau dieses Procedere. Also die 50 Strings
-
Thread
STRING AUS FLASH
Was läuft denn hier falsch, bekomme die Strings nicht aufs LCD PROGMEM wird vom compiler ignogiert?? #define F_CPU 800000UL #include <avr/io.h> #include <util/delay.h> #include <lcd.h> #include <lcd.c> #include <avr/pgmspace.h> int
pgm_read_byte (liest 1 Byte) und pgm_read_word (2 Bytes), zu finden im Header <avr/pgmspace.h> Deine lcd_string() Funktion wird wahrscheinlich einen String im RAM erwarten, du musst sie umschreiben.
-
Thread
String-Übertragung über USB (Borland C++)
PC und einem ATmega128 eine grafische Oberfläche zu basteln. Die Kommunikation an sich läuft über String-Vergleiche und funktioniert mit einer Terminal-Software (Super-Terminal von Bray) einwandfrei. Das Borland-C++-Programm verwendet die Komponente TComPort um Strings über einen USB-Port zu schicken
habe, fiel mir dann doch auf, das es viel einfacher ist. Ungeschickterweise habe ich immer ganze Strings geschickt. Der µC konnte die einzelnen Zeichen aber wohl nicht schnell genug verarbeiten. Daher wird jetzt alles mit kleinen Pausen einzeln gesendet. Hätte man früher drauf kommen können. Oder
-
Thread
usart problem mit ttl-Pegel
Drahtverhau führt die uc-pins zur Steckerleiste: //m328 //d2 d3 d4 d5 d6 d7 b0 b1 b2 b3 b4 b5 ++ -- rst c1 c2 c3 c4 c5 Die Widerstände sind für i2c + ds1820. Funktioniert bzw. nicht bestückt. der Anschluss Adapter zu uc hat nur 4 Leitungen: rs485 GND-----------GND M328 RXD--
Falk B. schrieb im Beitrag #7776313: > Das müßte > man messen und testen. [c] uart_str_count = 0; while(uart_str_count<7) { uart_string[uart_str_count++]=sub_usart_rx(); } lcd_goto(3,1);// lcd_int(uart_string[0]);lcd_write(" ");//01 lcd_int(uart_string[1
-
Thread
0x00 über UART übertragen
Schreib am anfang des strings die länge des Strings. Dann sendest du soviele Zeichen wie am anfang des Strings angegeben ist.
); } [/c] sowas in der Art vielleicht?
-
Thread
DHT22 liefert eigenartige Werte
; //lcd_string("Hello World!"); } return 0; } [/c]
lcd_string( "Luftfeuchte: %s", Buffer ); _delay_ms(500); } return 0; } [/c]
-
Thread
rs232 USBProg Problem
-MD -MP -MT usbnapi.o -MF dep/usbnapi.o.d -c ../usbn2mc/tiny/usbnapi.c avr-gcc.exe -mmcu=atmega32 -Wall -gdwarf-2 -Os -fsigned-char -MD -MP -MT usbn960x.o -MF dep/usbn960x.o.d -c ../usbn2mc/tiny/usbn960x.c avr-gcc.exe -mmcu=atmega32 -Wall
USBNWrite() rumfummeln und versuchen es dort stabiler zum laufen zu bekommen. Ein Tip an Benedikt: [c] sei(); // activate global interrupts UARTInit(); // only for debugging // setup usbstack with your descriptors USBNInit(usbrs232,usbrs232Conf); _USBNAddStringDescriptor(""
-
Thread
Full Speed WinUSB-Gerät gesucht
00 54 00 31 00 30 00 30 00 21 00 OUT (ACK) SETUP: 80 06 03 03 09 04 FF 00 - Get Standard String Descriptor Index:03 (Len:FF) IN 10: 10 03 4A 00 46 00 37 00 33 00 38 00 31 00 39 00 OUT (ACK) SETUP: C0 21 00 00 04 00 10 00 - Get MS Compatible ID Feature Descriptor (Len:10) IN 10: 28 00 00
00 00 00 00 00 - Set Configuration: 01 IN (ACK) SETUP: 80 06 00 03 00 00 FF 00 - Get Standard String Descriptor Index:00 (Len:FF) (Language) IN 04: 04 03 09 04 OUT (ACK) SETUP: 80 06 01 03 09 04 FF 00 - Get Standard String Descriptor Index:01 (Len:FF) (Manufacturer) IN 2C: 2C 03 49 00 6E 00
-
Thread
uhr richtig anzeigen lassen 00:00
[c] sprintf(buffer, "%2i:%02i", stunde, minute); [/c] Gruß Oliver
Hallo basti, Du solltest wohl mitteilen ob Du in C oder Assembler programmierst,nebenbei wäre auch noch der Typ des µC interessant. Du bekommst sonst Ratschläge in C Kobol, Assembler C++ Basic usw.. :-) mfG Ottmar
-
Thread
UART-Empfangsproblem Atmega88pa
); [/c] Was ich zum laufen bekommen habe ist das Senden vom AVR zum PC: [C] if (T1) //wenn auf Taster1 gedrückt, sende an UART und zeige auf LCD { USART_tx_string("Sende:"); USART_tx_string
0 nicht narrt. [c] c = uart_getc(); itoa(c,buffer2,10); lcd_goto(0,0); lcd_string(buffer2); lcd_string(" "); [/c]
-
Thread
Warten per leere Anweisung
allerdings gibt es Probleme, wenn der Puffer tatächlihc voll ist. Die Funktion sieht so aus: [c] /*String in Ringpuffer schreiben*/ void put_string_to_ringbuffer(struct t_buffer* buffer, uint8_t* p_start) { do { /*so lange versuchen, bis kein Fehler mehr zurückkommt*/ while(put_to_ringbuffer
RX_BUFFERSIZE - 1), rx_buffer_data, rx_buffer_data, rx_buffer_data, rx_buffer_data, rx_buffer_data} [/c] und Funktion [c] /*String in Ringpuffer schreiben*/ void put_string_to_ringbuffer(volatile struct t_buffer* buffer, uint8_t* p_start) { do { /*so lange versuchen, bis kein Fehler mehr
-
Thread
ADC Ergebnis auf dem Display ausgeben
Dann gib im sprintf-Aufruf eine minimale Ausgabebreite für x an [C] sprintf( Buffer, "%3d", x ); [/C] Dann werden immer drei Stellen ausgegeben. Ich würde aber für sowas nicht sprintf nehmen, weil ich i.d.R. mit meinen Speicherressourcen ein wenig haushalte. Nimm
johnny.m wrote: > Dann gib im sprintf-Aufruf eine minimale Ausgabebreite für x an > [C] > sprintf( Buffer, "%3d", x ); > [/C] > Dann werden immer drei Stellen ausgegeben. Ich würde aber für sowas > nicht sprintf nehmen, weil ich i.d.R. mit meinen Speicherressourcen ein > wenig haushalte
-
Thread
atmega8 Dez to: Hex & Bin [ funktioniert nur zum Teil!]
{i = i + leer;} q = q*10; } lcd_setcursor( 0, 2); lcd_string("binär: "); lcd_setcursor( 8, 2); sprintf(text,"%d",i); lcd_string(text); return 0; } hier der pc code: // deztobin.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung. //
i ] = '1'; Zahl = Zahl / 2; } Result[8] = '\0'; lcd_setcursor( 0, 2); lcd_string("Bin: "); lcd_setcursor( 8, 2); sprintf(texxt,"%s",Result); lcd_string(texxt); return 0; return 0; }
-
Thread
STM32F103 GPIO
LD). Ist so im Endeffekt sogar einfacher. Achja, von wegen Einfachheit: Programmiere mal diese C-Funktion in AVR-Assembler: [c]uint32_t shift (uint32_t x, uint32_t y) { return x << y; }[/c] Im ARMv7M-Assembler sieht's so aus: [avrasm]shift: lsl r0, r1 bx lr[/avrasm] Na, ists auf
, die z.B. einen string in einem anderen string suchen? Da brauchst du auch 4 Varianten - Eine wo beide Parameter-Strings im Flash sind, eine wo String1 im Flash und String2 im RAM ist, usw. Moby A. schrieb im Beitrag
-
Thread
String in Hex umwandeln
'0' && Nibble <= '9' ) return Nibble - '0'; return 0; } [/C] und damit ist es dann leicht aus 2 einzelnen Charactern, die du aus dem String rausholst, eine komplette Zahl zusammenzubauen [C] uint8_t byteToBin( char character1, char character2 ) { return toBin( character1 ) * 16 + character2; } [/C] Aus dem vom Benutzer eingegebenen String "A8", holst du dir die Character 'A' bzw. '8' raus, rufst byteToBin auf und von der Funktion kriegst du dann einen uint8_t mit genau dem Zahlenwert, der
-
Thread
Problem beim Empfang mit ATMEGA8 über UART
aktivieren uart_init(); // UART initialisieren char Line[40]; // String mit maximal 39 zeichen char z[5]={"A\n"}; sei(); while (1) { uart_put_string(z); //_delay_ms(500); //uart_gets(Line,sizeof(Line)); } return 0; } [/c]
void uart_puts (char *s) { while (*s) { /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */ uart_putc(*s); s++; } } das der String zu ende ist? In uart_putc wird nicht auf auf *c == '\0' geprüft. Nur falls Du Dich wunderst, dass im HT kein A -
-
Thread
AVR-GCC pointer post-increment
t i= 0; i < 16; ++i) { foo = *(ptr)++; // oder: // foo = string[i]; // (erzeugt gleichen asm) } while (1); } [/c] Allerdings programmiere ich lieber mit einem C++ Projekt. Dort müsste ich das dann in extern "C" packen? Nur "checkt" der Compiler "__flash" irgendwie nicht, obwohl der C-Compiler -std-gnu99 gesetzt hat. Was hab ich vergessen?: [c] extern "C" { const char __flash string[16] = "Hello World!"; }; [/c] Comp. Error: "expected initializer before 'string'" Wenn
-
Thread
Daten empfangen über UART
) { unsigned char c = UDR0; if( c == '\r' ) { // das wars, der String ist vollständig string[nextCharPos] = '\0'; StringReady = 1; nextCharPos = 0; } else { string[nextCharPos] = c; nextCharPos++; } } [/C] in deiner main() Funktion wertest du dann aus, welcher String empfangen wurde. [C] int main() { char receivedString[100]; ... ... nextCharPos
-
Thread
Regler für Bürstenmotor
PD6); //wenn der Knüppel oberhalb der Mittelposition LED = aus } lcd_clear(); lcd_string("PWM:"); lcd_setcursor( 0, 2); char Buffer[20]; itoa( pwm, Buffer, 10); lcd_string( Buffer ); _delay_ms(100); } }[/c]
PD6); //wenn der Knüppel oberhalb der Mittelposition LED = aus } lcd_clear(); lcd_string("PWM:"); lcd_setcursor( 0, 2); char Buffer[20]; itoa( pwm, Buffer, 10); lcd_string( Buffer ); _delay_ms(100); } }[/c]
-
Thread
DS18B20 mit Atmega8 bekomme nur 1 empfangen
" " ; Celsius ; Chr(0) ; "C" End If Temp_string = Str(temp_soll) Temp_string = Format(temp_string , "+0.0") Locate 2 , 1 Lcd "Soll:" If Temp_soll < -99 Or Temp_soll > 99 Then Locate 2 , 10 Lcd Temp_string ; Chr(0) ; "C" Else Locate 2 , 10 Lcd " " ; Temp_string ; Chr(0) ; "C" End If If Temp_soll >= Temp_ist Then Portc.0 = 0 Else Portc.0 = 1 End If If Pinc.3 = 1 And Temp_soll < 300 Then Temp_soll = Temp_soll
-
Thread
unerklärlicher SIGSEGV
René H. schrieb im Beitrag #6120252: > Nope, kann es nicht. Sonst zeig mir wie ..... Sicher: [c] printf("%02d\n", 12345678); [/c]
René H. schrieb im Beitrag #6121162: > Klär mich auf, bitte! [c] struct tm my_tm; auto result = gmtime_r(&tv, &my_tm); [/c]
-
Thread
String aus __TIME__ & __DATE__
Du denkst zu kompliziert ;-). Da [c] "a" "b" [/c] dem String "ab" entspricht, reicht sowas wie [c] __DATE__ " " __TIME__ [/c] bereits aus.
War wirklich einfacher als gedacht. Das man mit [c]" "[/c] die Strings zusammenfassen kann, war mir neu... Danke.
-
Thread
Keil uVision 3 Warning L16
-------------// // Purpose: // // Routine to write a zero terminated char_string // // to the serial port // ////////////////////////////////////////////////////// void send_string_with_cr(char* string) { send_string(string); send_char(0x0D); } //
?C_STARTUP CSEG AT 0 ?C_STARTUP: LJMP STARTUP1 RSEG ?C_C51STARTUP STARTUP1: IF IDATALEN <> 0 MOV R0,#IDATALEN - 1
-
Thread
Geht das auch einfacher?
Kannst du nicht jede Zeile in ein String packen und dann auf einmal ausgeben? [c] char tmp[20]; snprintf( tmp, "Aussen: %d Grad", grad ); display.setCursor(0,8); display.println(tmp); [/c]
Display ISO8859-1, kann man das eben nicht direkt schreiben. Ansonsten kann man immer noch strings verketten: [c] #define grad "\xb0" ... (... "Temperatur ist %02d " grad "C" ...) [/c] Das kostet auch keinen zusätzlichen Aufruf.
-
Thread
Anruferkennung Handy-USART?
& buffer!='\r'){ string[str_count]=buffer; str_count++; } string[str_count]='\0'; str_complete=1; } } [/c]
sry, das ist noch die fehlerhafte isr gewesen: [c] ISR(USART_RXC_vect) { unsigned char buffer; // Daten aus dem Puffer lesen buffer = UDR; // Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht
-
Thread
Sring in mehrere Zahlen umwandeln
1 of 'atoi' makes pointer from integer without a cast Also übergib den Zeiger auf den String an atoi: [c] waiting = atoi(&Line[1]) oder waiting = atoi(Line+1) [/c]
void bla( char * Sting ) { uint8_t index; uint8_t value; index = get_digit( String[0]); value = get_digit( String[1]) * 10 + get_digit(String[2]); } [/c]
-
Thread
String
Hallo ivh habe in der main-Funktion eine Variable folgendermassen definiert. char text[] = "Hallo"; Der Compieler mekert auch nicht. Beim Testen des Programms in AVR-Studio 4 sind alle Speicherstellen mit 0XFF belegt. Die Datei wurde mit dem Befehl "make extcoff" compiliert. Wo liegt mein Denkfehler ? mfg Mario Schmitt
-
Thread
c: gcc/avr gleiche/ungleiche varianten of string declarartion
geht natürlich auch das Analogon von Variante A: *Variante C* [c] const __flash char unitTable[][6] = { "uSv/h", "uR/h", "mR/h" };[/c] Nachteil der Varianten A und C ist, dass man die Maximallänge der beteiligten Strings kennen muss, und dass man Verschnitt
return strings[index][0]; } char get_first_C (const __flash char strings[][6], uint8_t index) { return strings[index][0]; }[/c] compiliert zu: [avrasm] get_first_B: mov r30,r22 ldi r31,0 lsl
-
Thread
Intertechno Funksteckdosen per AVR steuern
Byte Dim Abfrage As Byte Dim Stu2 As Byte Dim Min2 As Byte Dim Sec2 As Byte Dim Teil_st As String * 2 Dim Teil_min As String * 2 Dim Teil_min1 As String * 5 Dim Teil_sek As String * 2 Dim Stellen As Byte Dim D As String * 8 Dim Zahl As Byte Dim Licht As Byte Licht = 20 Dim Anzeige
Dim I As Byte Dim X As Byte Dim Funk_repeat As Byte Funk_repeat = 3 Dim Funkcode_complete As String * 12 Dim One_str As String * 1 Dim A As Byte Dim B As Byte Dim C As Byte ' billige Schalter Const Dose_ein = "0F" Const Dose_aus = "F0" Dim Systemcode As String * 5 Dim Steckdose As String
-
Thread
LCD-Dispaly ansteuern
Programmtext stehen dann die Daten: [pre] mt0: .db 4,0 mt1: .db 4,"Max. Temperatur",13,5,39,"C",0,0 mt2: .db 4,"Hysterese",13,5,39,"C",0,0 mt3: .db 4,"Ausschalt-Zeit",13,6," mmm:ss",0,0 mt4: .db 4,"Alarmton-Start",13,5,0 mt5: .db 4,"Alarmton-Sweep",13,5,0 mt6: .db 4," (c) 03
lcd_clear ; Display löschen ldi ZL, LOW(text1*2) ; Adresse des Strings in den ldi ZH, HIGH(text1*2) ; Z-Pointer laden rcall lcd_flash_string ; Unterprogramm gibt String aus der ; durch den
-
Thread
Struct mit String im Flash Zugriff
Hallo, ich habe ein Veständisproblem mit den Zugriff auf Strings welche im Flash liegen und der Zeiger davon in einem Struct was auch im Flash liegt. [c] ////////////////////////////////////////////////////////////////////////// typedef struct{ const
NULL-Pointer? Der hätte an dieser Stelle übrigens deutlich mehr Sinn, und dann die Auswertung mit [c] if(CommandStruct[i].cmdString == NULL) { break; } [/c] Das spart eine Dereferenzierung aus dem Flash.
-
Thread
USB CDC von Stefan Frings und WS
zusammen packen zu können, weshalb ich dann schnell wieder C++ genommen hab. Dank C++ können die USB-UTF16-Strings bei mir so aussehen (und sind vollkommen unabhängig von der Kodierung der Source-Datei): [c]static constexpr auto strManufacturer = EncodeDescriptors::USB20::string (u"ACME Corp.");[/c] Während sie in W.S.' C-Code so aussehen müssen: [c]const byte VendorStringDescriptor[] = { 16, /* bLength */ DESC_STRING, /* bDescriptorType
-
Thread
PIC - Stringzuweißung (CC5X)
Hallo, ich versuche seit längerem einem String (Programmiersprache C, Compiler CC5X) einen Text zuzuweißen: unsigned char string [11]; string = "Hallo"; Doch leider bekomme ich immer die Fehlermeldung "Incompatible storage, 'const *' is
Klaus m. ... schrieb im Beitrag #2128586: > Hallo, > ich versuche seit längerem einem String (Programmiersprache C, Compiler > CC5X) einen Text zuzuweißen: > > unsigned char string [11]; > string = "Hallo"; Hallo, also in C gibt es den Datentyp String eigentlich nur als Pseudodatentyp
-
Thread
Daten vom PC über RS232 zum MC schicken
uart_getc(); declariert ist. Anschließend schicke ich diese wieder zurück: uart_putc(s1); Das C# Programm liest dann diesen Wert in ein byte Array ein und gibt ihn in Textfeldern aus: byte[] inbuffer = new byte[4]; serialPort.Read(inbuffer,0,4); label1.Text = Convert.ToString(inbuffer
Thomas wrote: > C# Programm: Das C# Programm interessiert hier nicht weiter. Du wunderst dich doch, dass der µC 4 Byte zurückschickt und wo er die her hat. Also ist dann wohl auch die Programmierung des µC ineterssant
-
Thread
Kann nicht die zweite Zeile der LCD einschalten
Wie gesagt habe auch ein String gesendet. einen langen. ;-) lcd_string("Halllooooooooooooooxywert");
habe auch in die 2 Zeile set_cursor (16, 2); lcd_data ('C'); lcd_string("Halllooooooooooooooxywert"); geschrieben, aber tut nichts... grüße
-
Thread
Strings im Flash in zentraler Datei
){ if (uiNr >= (sizeof(strings)/sizeof(strings[0]))) uiNr =0; return (const char*)(pgm_read_word(&(strings[uiNr]))); } [/c]
Strings an. [c] const char * PROGMEM const strings[] = { string1, string2, string3, string4 }; [/c] So - und um nun den String[index] aus dem Flash zu lesen, musst Du zuerst in
-
Thread
Switch Case überspringt break;
Dein Problem hat nichts mit dem switch-case zu tun [C] unsigned char aufforderung[16]="Frequenz in Hz: "; [/C] das Array ist um 1 Zeichen zu kurz dimensioniert und damit hat dieser String keine 0-Terminierung und geht nahtlos in den nächsten String
Noch besser ist allerdings diese Lösung (sofern auf deinem µC es keine Probleme mit konstanten Strings gibt [C] void SendString( const char* string ) { while( *string ) { SBUF = *string; Warte10Us(200); string++; } } void funktion
-
Thread
Variable auf LCD ausgeben
LCD_Port = LCD_Port | (0x0F & Zeichen); LCD_STROBE; LCD_RS = 0; } // Schreibe ein String auf die LCD void lcd_puts(const char * s) { while(*s) lcd_write(*s++); } [/c] und wie oben schon der Schreibbefehl für das Display: [c] Temp1 = AN0; Temp1 = Temp1 / 2 -17;
[c] void Anzeige_Display(void) { switch(Display) { ... [/c] Der einzige Unterschied in deinen cases ist die Ausgabe eines Strings. Du könntest die Cases alle weglassen. Besonders solange
-
Thread
Hex in Dez Ausgabe
konstant. Das const ist nur insofern wichtig, als es damit ermöglicht, die Funktion so aufzurufen [c] lcd_print( "Hallo World" ); [/c] Denn "Hallo World" ist ein konstanter String (ein String-Literal), welches als solches per Definition unveränderlich ist. Daher muss die Funktion die Zusicherung machen, nicht zu versuchen den String den sie bekommt zu verändern. Mit dem const macht sie genau diese Zusicherung. Du kannst dich also darauf verlassen, dass die Funktion nichts derartiges machen wird [c] void lcd_print( const char
-
Thread
veränderlichen String zerlegen?
Hallo! Ich habe mal eine Frage. Ich empfange mit dem yC vom Rechner einen String, der so aussieht 18:20:50. Der String kann aber auch so aussehen 18:5:8. Ich möchte jetzt den String zerlegen. Die 18 in eine Variable std, die 5 oder 20 in die Variable min
[c] sscanf( string, "%d:%d:%d", &std, &min, &sek ); [/c] Peter
-
Thread
Deklaration Liste von Strings
erkennen und es ist keine zusätzliche Anzahl-Variable vorhanden, die einen falschen Wert haben kann. [c]const char * const List[] = { "Hello world!", "Text", NULL };[/c]
enthaletn ist. Mit zusätzlichen { } Klammern, die die eingebettete Datenstruktur kenntlich machen [c] const tl = {3, { "murks","mehrmurks","nochmehrmurks" } }; [/c]
-
Thread
ISR Aussetzer durch Volatile-Variablen-Polling ?
Speicherzellen benötigt. Sie wird nie benötigt und ist auch falsch für normale Speicherzellen im Sinne des C/C++-Speichermodells: also auch nicht für Variablen mit nebenläufigem Zugriff. Alle Howtos und Tutorials, die derartiges behaupten, sind schlicht falsch. In C/C++ ist es grundsätzlich UB, wenn
Registern lagern. > Volatile nur auf die "eine". Du kannst ja mal einen Vergleich konstruieren. [c] __asm__ __volatile__ ("" : : : "memory"); [/c] macht die Optimization Barrier auf alles im RAM, [c] uint8_t flag; ... __asm__ __volatile__ ("" : "=m"(flag) ); [/c] macht das nur für eine
-
Thread
AVR Studio / GCC C - OOP - Anfänger Frage(n)
verglichen wird. Ein C++ welches mit std::string arbeitet hat nun mal als EXE eine meistens größere Signatur, als ein C Programm, welches die STringverarbeitung mit der heißen Nadel zusammenstrickt. Ergänzt man im C Programm
Funktionalität verglichen wird. Ein > C++ welches mit std::string arbeitet hat nun mal als EXE eine meistens > größere Signatur, als ein C Programm, welches die STringverarbeitung mit > der heißen Nadel zusammenstrickt. Ergänzt man im C
-
Thread
ATMega328, komisches Verhalten bei fast vollem Speicher
restored)"); Hast du mehrere Code-Zeilen dieser Art? Speicher kannst du dann sparen indem du den String im Flash lässt und dir eine screen_print-Variante schreibst, die auch einen String aus dem Flash schreiben kann, z.B.: [c] //fuer den Zugriff auf den Flashspeicher #include <avr/pgmspace.h> .
Definition in der Funktion erstmal auf 0. [c] int x = 0; [/c]
-
Thread
__PART_NAME__ in AtmelStudio 7 und C
Vielleicht so? [c] // Prozessor defines in <avr/io.h> #ifdef __AVR_ATmega644__ #define ID_STRING "Das ist ein ATMega644" #endif #ifdef __AVR_ATmega328P__ #define ID_STRING "Das ist ein ATMega328p" #endif #ifdef __AVR_ATmega2560__ #define ID_STRING "Das ist ein ATMega2560" #endif [/c]
-
Thread
Zeichen (hex) binär ausgeben
} return bin; } Aufruf... // botschaft[8] beinhaltet Zeichen 0...F lcd_string(hex_to_bin(botschaft[8])); [/c] Liebe Grüße
[c]char bin[4]; [/c] muss sicher mal: [c]char bin[5]; [/c] sein, da ein string mit \0 abgeschlossen wird bei strcpy.
-
Thread
Unerklärlicher Reset, ATmega16
Kann gut sein, dass nicht nur die Strings das Problem sind, sonder auch das Menükonstrukt. [c] typedef struct menu { struct menu *father; struct menu *subs[4]; char *zeile[16]; int (*func)(int); } MENU; [/c] Hatte bis
Frank Kalka schrieb: > Kann gut sein, dass nicht nur die Strings das Problem sind, sonder auch > das Menükonstrukt. > > [c] > typedef struct menu { > struct menu *father; > struct menu *subs[4]; > char *zeile[16]; > int (*func)(int); > } MENU;
-
Thread
Uart string einlesen und speichern
die vom Temperatu-Modul kommen sehen so aus +243 13 die 13 Bedeutet ende der Übertragung. [C] for (;;) { c = uart_getc(); if( c != UART_NO_DATA ) { // Lese solange, bis von der anderen Seite die // Return Taste betätigt wurde. while( c != 13 ) { if( c != UART_NO_DATA ) { Eingabe[Count++] = c; c = uart_getc(); } } Eingabe[Count] = '\0'; uart_puts( "Temperatur" ); uart_puts( Eingabe
-
Thread
GCC Statische initialisierung.
prüft ›C‹** evtl. nicht wirklich was da im (Pfad-)String drin steht. ** Wohl eher der Präprozessor
Aber "..." bei #include "..." ist gar kein string-literal sondern ein Anführungszeichen gefolgt von einer q-char-sequence gefolgt von einem Anführungszeichen. Interessanter wird es bei [c] #define N "subdir\neuedatei.h" #include N [/c] Da gilt
-
Thread
String mit UART Senden/Empfangen -> code macht ASCII aus char
[c]type_string (rxd_data + '\0');[/c] so ists richtig
machst, ist im Grunde nichts anderes als (wenn wir die UART Übertragungsstrecke mal weglassen) [C] while( *s ) { c = *s++; itoa( c, buffer, 10 ); type_string( buffer ); } [/C] Du gehst also einen String in s durch und lässt dir von jedem einzelnen Character im String