-
Thread
Tasterabfrage nach Dannegger – plötzlich unplausible Resultate
jetzt: [code] while(1) { uint8_t keys; keys = get_key_press(0xff); lcd_gotoxy(0,1); lcd_itoa(keys); // menue system #define DISPLAY_NORM_INIT 0 #define DISPLAY_NORM_WAITKEY 1 #define DISPLAY_MENU_INIT 10 #define DISPLAY_MENU_CHANGED 11 #define DISPLAY_MENU_WAITKEY 12 switch( display ) { case DISPLAY_NORM_INIT: display = DISPLAY_NORM_WAITKEY; lcd_clrscr(); lcd_gotoxy(1,
-
Thread
arduino display geht aus
IsO-Mick created made to specifically support the WS2812 RGB LED strips running with an SD Card, an LCD Display, and the Arduino Mega 2560 Microprocessor board. The functionality that is included in this code is as follows: Menu System 1 - File select 2 - Brightness 3 - Initial
!=menuItem) > { >> lcd.begin(16,2); >> lcd.print("1:File Select "); >> lcd.setCursor(0, 1); >> lcd.print(m_CurrentFilename); > > old_menuItem=menuItem; > } >> break
-
Thread
Menü programmieren
Menüs mit viel mehr Möglichkeiten mit 3 Tasten ohne so ein Mist aber mit einen einfachen 2 * 16 Display. Taste 1 : PLUS Taste 2 : MINUS Taste 3 : MENÜ oder OK. Alle Tasten sind während des Betrieb mit anderen Funktionen belegt. Je nach Projekt ist die Menü-Taste auch doppelt belegt (dann
einstellen muss. Diese könnte ich zwar im Code hinterlegen aber ich mag es etwas flexibler. Was das Display angeht. Mir reichen die China-Text-Display via i2c völlig aus. Preiswert, einfach anzusteuern und ich muss wenig Coden. Code : lcd.Initialize(0x27, 16, 2) lcd.Backlight = True lcd.SetCursor
-
Thread
LCD Menü
String auf dem LCD auszugeben: [c] strcpy_P(lcd_value, (char *) pgm_read_word(menue[actual_menu_entry].text)); lcd_puts(lcd_value); [/c] actual_menu_entry steht auf einem Wert zwischen 0 und 2. (lcd.c von Peter
dem Flash holen und auf dem Display ausgeben. "encoder" ist die Menüvariable strcpy_P(buffer, (char*) pgm_read_word (&menue[encoder].text)); lcd_puts(buffer); if( get_key_short( 1<<KEY0 )){ //Taster kurz gedrückt?
-
Thread
Gibt es listen in C wie in C++
wie kann ich jetzt ein menü ausgeben auf dem lcd display wenn ich eine taste drücke.
und schreibst die einzelnen Menuepunkte da rein. In main kannst Du dann z.B.menue[0] an Deine LCD-Ausgabefunktion übergeben, die dann den ersten Eintrag aus deinem Menue auf dem Display darstellen sollte.
-
Thread
MENÜ-STEUERUNG
Hallo Kay, was verstehst Du unter "Menü-Steuerung" ? Softkeys unter einem LC-Display ? Gruss Otto
rechts den PWM-Wert des entsprechenden Kanals. Denn in Deiner Anwendung braucht es eigentlich kein Menü mit auswechselbaren Texten. Zeige einfach an 8 definierten Stellen Deines LCDs die 8 Werte an und markiere den Teil des LCDs, der den gerade veränderbaren anzeigt auf geeignete Weise. Falls Dir Blinken
-
Thread
Fehlermeldung: near initialization for
* lcd) { lcd_clrscr(); for(int i = 0; i < LCD_LINES; i++) { lcd_gotoxy(0,i); lcd_puts_p((PGM_P)pgm_read_word(&lcd->text_zeile[i])); } } show_display_lines(&main_menu[index].
}, 1, 1, eingabe_betrieb } };[/c] Ausgabe ist dann einfach so: [c] void show_display_lines (const __flash t_menu *menu) { lcd_clrscr(); const __flash char *const __flash *texte = & menu->texte[0]; for (int i = 0; i < LCD_LINES; i++) { lcd_gotoxy
-
Thread
[AVR-ATmega8] LCD-Menü mit 2 Tastern
die Tastenbehandlung und bringst die zum laufen. Dein Programm könnte zb so aussehen [C] lcd_put_choice_p( uint8_t row, const char* text ) { lcd_gotoxy( row, 2 ); lcd_puts_p( text ); } void Menu1() { uint8_t choice; lcd_clear(); lcd_put_choice_p( 0, "AND" ); lcd_put_choice_p
simulieren und mit Tastendruck wird dieses 'irgendein' gegen ein anderes ausgetauscht. [C] void DisplayGatter( int was ) { lcd_clrscr(); lcd_gotoxy( 0, 0 ); if( was == 1 ) lcd_puts( "AND / 1,2=I 3=O" ); else if( was == 2 ) lcd_puts( "OR / 1,2=I 3=O" ); else lcd_puts
-
Thread
Menüstruktur unter Bascom
Achso, wenn Deine Subs ausgeführt werden, muß natürlich noch Call Print_menu(menustate) aufgerufen werden, um das LCD zu aktualisieren.
Habe das Codebeispiel von sebezahn benutzt und nur auf mein Display angepasst. Menü funktoiniert super! Nur möchte ich jetzt z.B. etwas ausgebe. Z.B. bei IP_Adresse gebe ich dann im Case 11 ein : LCD "Testsystem", dann werden aber wenn ich das ganze Aufrufe am Display
-
Thread
Arduino Menü erstellen
Hallo, ich habe folgendes Problem. Ich habe ein 16x2 Lcd Display und möchte dafür gerne ein Menü, welches ich über einen Taster steuern kann. Folgende Funktionen soll es haben: Wenn ich den Taster zum ersten mal drücke, soll die Lcd Hintergrund Beleuchtung
lcd.println("RTC has set the system time"); } void loop(void) { digitalClockDisplay(); delay(1000); } void digitalClockDisplay(void) { lcd.begin(16, 2); lcd.print(hour
-
Thread
lcd switch case Eintrage aktualisieren
ganzen braucht, hänge ich noch zip-Sketch an. //---Submenu1_1--// void submenu1_1() { menuState1_1 = true; switch (menu) { case 1: lcd.clear(); lcd.setCursor(0, 0); lcd.print("Timer einstellen"); lcd.setCursor(0, 1); lcd.print(PotiWert(1))
aufs "Display-RAM" fix geht, ich auf das Display nicht warten muss und dass die Anzeige auf dem Display dank des unnötigen lcd_clear() nicht flackert. Aber wie immer: jeder nach seinem Gusto... ;-)
-
Thread
Menü Programmierung
} } [/C] Eine kleine Ergänzung sollte man in DoMenu dann noch vornehmen: Wenn DoMenu die Funktion aufruft, sollte sie vorher das LCD löschen um der Funktion keine Altlasten zu hinterlasten und es sollte nachdem die Funktion zurückgekehrt ist, sein Menü-Display
( OptionsMenu[MENU_POSITION].Number); LCD_String( OptionsMenu[MENU_POSITION].Text); break; case SubMenu: LCD_Clear(); LCD_Cursor_Home(); LCD_String( OptionsMenu[MENU_POSITION].Text);
-
Thread
Frage zu Interrupt - Arduino
---------------------- void LCD_Seite_1() { if(LCD_Menu == 1) // wenn man bereits im LCD_Menu_1 ist... { LCD_Menu = 0; // ...setze LCD_Menu_Variable auf 0.. loop(); // und starte die loop()-Funktion
[c] //... void LCD_Seite_1() { if(LCD_Menu == 1) // wenn man bereits im LCD_Menu_1 ist... { LCD_Menu = 0; // ...setze LCD_Menu_Variable auf 0.. loop(); // und starte die loop()-Funktion
-
Thread
Funktions Pointer
].text); sub_menu_index = pgm_read_word(&menu[menu_index].sub); } lcd_gotoxy(0,0); lcd_puts_p(pgm_read_word(&menu[menu_index].text)); lcd_gotoxy(0,1); lcd_puts_p(pgm_read_word(&menu
.6) { menu_index = pgm_read_word(&menu[menu_index].text); sub_menu_index = pgm_read_word(&menu[menu_index].sub); lcd_gotoxy(0,0); lcd_puts_p(pgm_read_word(&menu[menu_index].text));
-
Thread
8 oder 16 Zeichen 4 Zeilen LCD mit 9 mm Zeichenhöhe
20x%204%7C~20%20x%204%7C~40%20x%204&display%20mode=LCD%7C~Reflective%7C~Transflective~~Transmissive&product=COG%20LCD%20Character%20Display%20Modules%7C~LCD%20Character%20Display%20Modules~~LCD%20Character%20Displays&viewing%20area%20-%20w%
6,75 mm. Wenn Dir scheinbar 5mm reichen sollten die es auch. Hier noch ein Link: https://www.lcd-module.de/lcd-module/produkte/lcd-oled-tft-hmi-display-industrie-medizintechnik/dotmatrix.html Aber, wie schon gesagt, überlege Dir erstmal was Du eigentlich möchtest.
-
Thread
Display-Menü programmieren
Ich habe die Befürchtung, dass diese Zeilen: in LCD_sheet0.c: [c] if( !(EINGABE_TASTEN & (1<<NEXT_PAGE_TASTE)) ) //Next-page Taste gedrückt wird dann soll er nicht zurück ins Hauptprogramm sindern die nächste Seite anzeigen { displayLoad_POSSIBILITIESofACTING1
//INLINE da sonst Probleme wenn mehrere Pages mit Rücksprungadresse { //LCD-Menü Deklarationen und Definitionen: show0(); do { if(EINGABE_TASTEN & (1<<RAUF_TASTE)) //Wenn auf Runtertaste gedrückt wir dann: { _delay_ms(20); //entprellen if
-
Thread
Prog. läuft auf Mega128 aber nicht auf Mega8!
(0,1); lcd_string("Set max. Temp."); set_cursor(0,2); if (debounce (&MENU_PIN, MENU_UP)==1) { intMaxTemp++; } if (debounce(&MENU_PIN, MENU_DOWN)==1) { intMaxTemp--; } itoa(intMaxTemp, strMaxTemp, 10); lcd_string(strMaxTemp); long_delay(23); break; case 2: lcd_clear(); set_cursor(0,1); lcd_string("Set Offset Temp."); set_cursor(0,2); if (debounce(&MENU_PIN, MENU_UP
-
Thread
Display mit Touchscreen bei Pollin?
es ist natürlich .equ LCD16080_CS = 3 ; display Pin15 .equ LCD16080_RST = 4 ; display Pin16 da stimmen die Kommentare nicht. Ich habe die Pinbelegung schon nachgeprüft (Pins mit pulsfolgen belegt
Case "D" : Gosub Dach End Select Touch_meldet = Erledigt End If Loop Until F_taste = _menue Gosub Auswahl Return Keller: Lcd_select = 2 Command = &H08 'Befehl: Display Start Low Datenwert = &H00 Gosub Zum_glcd Command =
-
Thread
Menü Programmierung ATMega32
mehr Code du bei deinen ersten Tests hast, desto mehr Fehler kannst du machen. [C] void MainMenu() { int8_t key = NO_KEY; uint8_t selectedOption = 0; lcd_setcursor( 0, 1 ); lcd_string(" Option 1"); lcd_setcursor( 0, 2 ); lcd_string(" Option 2"); lcd_setcursor( 0,
(); lcd_lcd_setcursor( 0, 1 ); lcd_string( "Press key 1" ); do { key = keyPressed(); } while( key != KEY_1 ); MainMenu(); } } [/C] Probier das mal aus. Im 'Menü' kannst
-
Thread
LCD Inhalt regelmässig aktualisieren
LCD schreibe in meinen Speicher des uC speichern Das wäre bei meinem 4x20 Zeichen Display 80 Bytes. und dann hätte ich ein komplettes abbild des LCDs in meinem Speicher drin. Ich habe schon etwas
ich es mal auf eine Zeile: gehen wir von folgendem fiktiven szenario aus. Ich gebe auf meinem Display folgendes aus: [c]char out[21]; sprintf(out, "Menu1: TEST"); set_cursor(0,1); lcd_string( out ); char bufferuC[21]; strcpy( &bufferuC[0], out); [/c] dadurch steht in meinem
-
Thread
Text in Variable??
, 0 Also quasi wenn menu_cnt 0x01 ist dann soll im display menuepkt 1 stehn und so weiter.
ausgabe_menue_3: ldi ZL, LOW(menuetext_3*2) ; Adresse des Strings in den ldi ZH, HIGH(menuetext_3*2) ; Z-Pointer laden rjmp ausgabe_menue ausgabe_menue: lcd_flash_string
-
Thread
Menüstruktur mit Pointern und structs
( 1<<KEY_ENT )) { //Aufruf der zugehörigen Funktion menue[MENU_COUNT].fp(); } if( MENU_COUNT != MENU_COUNT_OLD ) { lcd_clrscr(); lcd_gotoxy(1,0); strcpy_P(HelpStr, (menue[MENU_COUNT].text)); lcd_puts(HelpStr); MENU_COUNT_OLD
if( ActEntry != ActEntryOld) update_display(); } void update_display(void) // Update der Anzeige { lcd_clrscr(); lcd_gotoxy(0,0); strcpy_P(HelpStr, ActMenu->Menu_Name); lcd_puts(HelpStr); lcd_gotoxy(0,1); strcpy_P
-
Thread
LCD Menü schreiben
Hallo, ich habe ein 2x16 LCD-Display und 5 Taster zum Steuern und möchte dafür ein Menü schreiben. Wenn ich den mittleren Taster drücke, so wird ein Interrupt ausgelöst und in der Interruptfkt wird die Funktion "show_menu" aufgerufen
} else { // das LCD löschen } } if( MenuOnScreen ) { // wenn das Menue aktiv ist, werden // auch die anderen Tasten ausgewertet if( get_key_press( 1<<KEY1
-
Thread
const char *text in C Struktur zur Laufzeit ändern
String mit 2 Kommastellen strcat(txt_,txt); // gewandelte Float Zahl dran Lcd_Cmd(_LCD_CLEAR); // Clear display Lcd_Out(1,1,txt_); // LCD Ausgabe [/c] Der Menüeintrag ist jetzt also ein geänderter String mit Zahlen. Wenn ich diesen einfach mal direkt aufs LCD Display ausgeben lasse, klappt das ja. siehe Bild. Wenn doch alles klappt, warum geht es dann nicht so? [c] menu[1].text = *txt_; [/c] Gruß CL
-
Thread
Menü vorlage
Hallo, bin hier im Forum auf folgende Vorlage für ein Menü gestossen und wollte mal fragen für welche art von Display diese geeignet ist also GLCD oder ein Text-LCD. Danke für eure hilfe
Ich bin mir zu 98% sicher, dass diese Menü für GLCDs gedacht ist. Text-LCD-Menüs sind derart trivial, dass sich keiner die Mühe macht, dafür einen Artikel aufzubauen. Kleines Beispiel: Hardware: Controller, 2-zeiliges Display, 4 Tasten
-
Thread
Nicht noch ein Cocktailautomat -.-
schrieb im Beitrag #5469514: > Vincent H. schrieb im Beitrag #5469458: >> Das zurück/exit wird im Menü mit eingebaut und kann über die hoch runter >> Taster erreicht werden. > > 16x2 LCD und Menü wird aber schon sportlich :-) Für das Display gibt es ja Gott sei dank eine library :D Man wächst
bis fertig mit Meldung Sehr gute Idee ich denke drüber nach aber wieviel Pins braucht ein 20x4 Display? > Pete K. schrieb im Beitrag #5469514: >> 16x2 LCD und Menü wird aber schon sportlich :-) > > nun ja ist machbar aber eng, Platz wird nicht das Problem sein also > warum nicht einen mega2560
-
Thread
Strings für LCD im Flash ablegen
; if ( menu_state[uint].state == LCD_Status ) { strcpy_P(M01_String, menu_state[uint].ptext_01); LCD_01_StatusText = M01_String; // LCD_01_StatusText = menu_state[uint].ptext_01; // LCD_02_
PROGMEM MENU_STATE flash_menu_state[] = { //STATE STATE_TEXT_Display_1 STATE_TEXT_Display_2 STATE_FUNKTION {ST_01, MT01_01, MT02_01, LCD_01}, {ST_02, MT01_02,
-
Thread
Problem mit loop_until_bit_is_clear
&menu_rom_data[lcd_menu_aktiv].menu_up); displayDirty = TRUE; } if(get_key_short(1<<KEY_DOWN)) { // Runter Modus lcd_menu_aktiv = pgm_read_byte(&menu_rom_data[lcd_menu_aktiv
{ lcd_menu_aktiv = pgm_read_byte(&menu_rom_data[lcd_menu_aktiv].menu_up); displayDirty = TRUE; } } }while(lcd_menu_aktiv >= 0); [/C] Jetzt wird das Display neu gezeichnet. Aber
-
Thread
LCD Menü Struktur Navigation
if(get_key_short(1<<KEY0) && Summe == 0) // kurzer Tastendruck (PinB.6) { MenuOnScreen = 1 - MenuOnScreen; // LCD-Hauptmenü anzeigen lcd_clrscr(); lcd_puts ((const char*) pgm_read_word(&menu_text[0])); } if(MenuOnScreen) {
der lcd_puts_p Funktion. Wenn ich hier mit Variablen arbeiten möchte funktioniert das nicht so richtig: [c] lcd_puts_p (menu_text[menu_index]); [/c] AVR Studio zeigt mir zwar keinen Fehler, allerdings
-
Thread
[C++] Klassen aus anderer Datei
()) { // check the type off a menu element if(tmp->checkType_menu() == true) { // display normal content LCDML_getContent(content_text, tmp->getID()); lcd.setCursor(1, n);
https://github.com/Jomelo/LCDMenuLib2 #include <Wire.h> #include <LiquidCrystal_I2C.h> #include "display_utils.h" displayUtils dpUtils(); LCDMenuLib2_menu LCDML_0 (255, 0, 0, NULL, NULL); // root menu element (do not change) LCDMenuLib2 LCDML(LCDML_0, _LCDML_DISP_rows, _LCDML_DISP_cols, lcdml_menu_display
-
Thread
ATmega 8 hängt sich auf
btn_up = 0; btn_down = 0; btn_menue_key = 0; // Anzeigen des Menüpunktes lcd_bg(1); // Displaybeleuchtung an lcd_clear(); // Display löschen lcd_home(); lcd_string(tmp -> name);
dir dafür ein paar #define und lesbare Namen. [C] // Funktionen für die Menünavigation void menue() { struct menueP *tmp = start; while( tmp ) { keybrd = 0x00; lcd_bg( 1 ); // Displaybeleuchtung an lcd_clear(); lcd_home(); lcd_string( tmp->name );
-
Thread
Array vom PROGMEM aufs Display
eigentliches Problem bereits gelöst. Ich möchte aus einem Array im PROGMEM einen String auf einem LCD ausgeben, unter Zuhilfenahme der HD44780 Library hier aus dem Board. So funktioniert es: [c] const char mainmenu[] [8] PROGMEM = {"Menue 1","Menue 2","Menue 3"}; lcd_string_P(mainmenu[1]);
read_string(buffer, 1); Damit landen die Daten im RAM ab Adresse NULL. Das willst du sicher nicht. >lcd_string(buffer); Eher so. [c] const char mainmenu[] [8] PROGMEM = {"Menue 1","Menue 2","Menue 3"}; char buffer[8]; strcpy_P (buf, mainmenu[i], 8); lcd_string(buffer); [/c]
-
Thread
Menüstruktur für Grafikdisplay
was geschrieben: [c] uint8_t state = MAIN; uint8_t back = MAIN; void (*statemachine[])() = {menueMain, contrast,...}; void menueMain(void) { uint16_t txpos, typos; loadBitmapSD("main.bmp", 0, 0, LCD_WIDTH, LCD_HEIGHT); while(state == MAIN) { printTime();
dieser einen Verarbeitungsmenüfunktion aufgerufen. Die Funktion button[i].action() zeichnet ein neues Menü auf das Display (Bild von der SD Karte), und aktiviert ein neues Menü; [c] struct Button *active; void handleABC(void) { active = ABC; loadBitmapSD("imageABC.bmp", 0, 0, LCD_WIDTH,
-
Thread
Display Menü LCD 4x20
Hallo an alle! Hat irgendjemand von euch schon mal ein Menu für ein LCD realisiert? Über drei Tasten steuerbar über 2 tasten (gleichzeitig) ins Menu. 1 Taste hoch. 1 Taste runter. 1 bestätigen. Mir geht eigentlich nicht darum wie man es tun sollte sondern
) { if (!('0' <= a[c] && a[c] <= '9')) return false; } return true; } int menu::run(menu *last) { string choice; int start = 0; int end = 2; // LCD-Display-Height minus 2 int t; do { do { cout << name << endl; for(int
-
Thread
grafische Benutzeroberfläche mit einem AVR?
gehts aber auch auf kleineren in Asm. Die nächste schwierigere Stufe wäre dann ein Textbasiertes Display. Deinen 1. Versuch mit der Konsole kann man dann entsprechend ausbauen. Für ein vollgraphisches Menü mit Bitmaps und so weiter wirst du dir neben einer etwas komplizierteren Displayansteuerung
das Menü im unsichtbaren Bereich des LCDs unterbringen und im sichtbaren Bereich Messwerte anzeigen. Auf Anforderung hin schreibt man nicht langsam erst das Menü zusammen, sondern setzt einfach das virtuelle
-
Thread
LCD-Programmierung/Tastatur-Programmierung
Wie gesagt, für LCDs gibt's diverse Librarys im Netz und bei den Controllerherstellern. Denke mal bei deiner Anwendung hast es mit einem Standard 1x16 oder 2x16 Textdisplay zu tun. Und ein Menü zur Anzeige diverser Funktionen
belegt werden. Damit wàre das Problem eig gelöst, allerdings verstehe ich immer noch nicht wie die LCD funktionieren soll, also das mit dem Menü.
-
Thread
Menü mit Sprungtabelle funktioniert nicht
zusammen, ich habe in Assembler für den ATMEGA 8 testweise mal ein Programm entworfen, das auf einem LCD Display ein Menü darstellen soll. Leider funktiniert das ganze noch nicht wie es soll. Wie es aussieht wird das Programm immer wieder durchlaufen, ich sehe auf dem LCD nur filmmerndes Schwarz. Kann
*2) rcall lcd_clear rProg2: lpm temp1, Z+ cpi temp1,0 breq warte rcall lcd_data rjmp rProg2 Prog3: ; Menüname 3 ausgeben ldi ZL, low(menu3*2) ldi ZH, high(menu3*2) rcall lcd_clear rProg3: lpm temp1
-
Thread
C-Struktur, unklares Verständniss - ben. Hilfe!
lcd_i; lcd_i--) { Lcd_Chr_Cp(*lcd_zeichen); lcd_zeichen++; } } [/c] Diese wird dann aufgerufen in der MAIN mit: [c] LCDWriteStringROM(0,0,*menu[1].text,0); [/c] ..... SOOOOOO
, Es muss an dem Aufruf der Routine liegen. Diese sieht zu Test so aus: void start (void) { Lcd_Cmd(_LCD_CLEAR); // Clear display Lcd_Out(1,1,"Aufgehts !!"); DELAY_MS(500); } Mit der Bitte um Hilfe. Das wäre dann das letzte was ich jetzt noch benötige. Gruß und schönen
-
Thread
PIC18F2550 hängt sich nach längerer Dauer auf
feststellen kann. Also denke ich nicht dass immer mein PIC sich aufgehängt hat, sondern nur dass das LCD-Display zu spinnen begonnen hat. Deswegen mal als erste Frage: Wie überprüft man richtig im 4-Bit Mode das LCD-Busy-Flag?? Zweitens falls das nicht das einzige war, kommt noch eine kurze Zeichnung
Ja das ist schon richtig! er hat noch einen zweiten :-) Aber das hat jetzt nix mit dem LCD Display zu tun und ich hab ihn schon angehängt.
-
Thread
AVR LCD Display Menü (Pfeil)
Hallo Leute!! Ich hab ein Problem mit dem programmieren eines atmega8 LCD Displays 4x16. Ich schaffe es Texte per Tasten druck erscheinen zu lassen^^. Ich habe 4 Taster und möchte ein Menü erstellen. 2 Tasten sollen RAUF und RUNTER fahren. Auf der ersten Spalte hab ich Platz
lcd_move_cursor(LCD_LINE_2,0); LOG_str(" "); LCD_LINE_2++; lcd_move_cursor(LCD_LINE_2,0); LOG_str(">"); ich habs so hingeschrieben aber es zeigt mir einen ERROR bei der 3 Zeile ^^ ERROR:
-
Thread
Dannegger-Entprellung anpassen
Danke für deine Antwort! Hier mal ein kurzer Auszug vom Menü: [c] case 11: // Menuepunkt 1.1 { if (disp_done == FALSE) // Gibt einmal neuen Inhalt auf Display aus { lcd_clear_display (); // Loesche Display lcd_jump_to (2,1); // Untere Zeile, 1. Stelle lcd_send_string ("MENUE"); // Sende String "Menue" lcd_jump_to (1,3); // Obere Zeile, 3. Stelle lcd_send_num (1, TRUE); //
-
Thread
Seltsames uC-Verhalten: Bugsuche
{ if (m_CurrentAction == 0) { // Hier wird die Menüstruktur auf dem LCD-Display ausgegeben DisplayMenu(); if (currentNode.Parent == -1) { LCD_Set_Position(0, 5); // Hier wird der aktuelle Status der SD-Karte ausgegeben /
) { DisplayTempAndHumi(); } else if (m_CurrentAction >= 10 && m_CurrentAction < 30) { LCD_Clear_Memory(); LCD_Set_Position(0, 0); LCD_Write(m_Menu[m_CurrentNodeIndex].Text, 14); LCD_Set_Position
-
Thread
Honeywell Rondostat HR20E per AVR steuern und konfigurieren
zum Display: http://carluccio.de/img/hr20/segments_numbered.png http://carluccio.de/img/hr20/segments_numbered_seg.png Die Analyse[2] ist auch aktualisiert. @Karim: Du kannst dann ja mal die LCD-Routine
serial protocol (incomplete, but possible to use) - timers is not implemented (I am working on it) - LCD menu+keys is working, but without timer programing, service menu allow setup internal parameters (hold all fronend buttons) What you can to do? 1) test it, or try to tune PID controler P constant
-
Thread
Wechsel von ATmega8 auf ATmega32 - Codeanpassung
lcd_puts("Uhr-Einst."); lcd_gotoxy(1,1); lcd_puts("Uhr stellen"); state = UHR_STELLEN1; menuLeiste(); break; case VENTIL_MENU: lcd_clrscr();
; menuLeiste(); lcd_gotoxy(9,3); lcd_puts(" "); state = LICHT_MENU1; break; case LICHT_MENU1: if(get_key_short( 1<<KEY0 )){ state = FUTTER_MENU
-
Thread
Tasterabfragen Problem
Ab hier funktioniert es nicht mehr int b = 0; int a = 0; int main(void) { //LCD Config lcd_initialisieren(); lcd_led(1); DDRC |= (1<<LED); DDRC &= ~(1<<Menu_Taster); PORTC |= (1<<Menu_Taster); lcd_zahl(1,1, a, 2); lcd_zahl(1,4, b, 2); while(1)
> Ab hier funktioniert es nicht mehr > > int b = 0; > int a = 0; > > int main(void) > { //LCD Config > lcd_initialisieren(); > lcd_led(1); > > DDRC |= (1<<LED); > DDRC &= ~(1<<Menu_Taster); > PORTC |= (1<<Menu_Taster); > lcd_zahl(1,1, a, 2); > lcd_zahl(1,4, b, 2); >
-
Thread
Mega32 schaltet, ohne ein Signal zu bekommen
// verschwunden sein lcd_init(); // Text des ersten Mneu-Eintrags auf Display schreiben lcd_string(current->line1); lcd_setcursor(0,2); lcd_string(current->line2); // wenn navigiert wurde, dann Display
{ // leere Anweisung, kein Event ; } if (redraw) { // aktueller Menue-Eintrag (current) veraendert -> Display neu beschreiben lcd_clear(); lcd_setcursor(0,1); lcd_string(current->line1); lcd_setcursor(0,2); lcd_string(current->line2
-
Thread
Probleme mit LCD-Menü
Hallo, ich bin seit geraumer Zeit damit beschäftigt, einen Fehler in meinem Programm zu finden. Jedoch leider erfolglos. Das Display zeigt immer den Startmenüeintrag an. Auf eine Eingabe reagiert das Display überhaupt nicht. Da ich mich erst seit kurzem mit Strukturen und Zeigern beschäftige fällt mir die Fehlersuche entsprechend schwer. Es würde mich freuen, wenn sich von euch mal jemand das angehängte Listing anschauen und mir einen Tipp geben könnte. Tobias
-
Thread
LCD Menue AvrButterfly
Hallo zusammen Bin gerade dabei mir eine "schöne" Menue Struktur zu zimmern. Nun hab ich mir den AVRButterfly als vorlage genommen. DIeser wird in vielen LCD Threads hier als vorlage verwendet. Nun hab ich da noch eine frage: Was bedeutet dieses __flash
ST_OPTIONS_AUTO_POWER_SAVE, KEY_PREV, ST_OPTIONS}, {ST_OPTIONS_AUTO_POWER_SAVE, KEY_MINUS, ST_OPTIONS_DISPLAY}, {0, 0, 0} }; MENU_STATE menu_state[] = { // STATE STATE TEXT STATE_FUNC {ST_AVRBF,
-
Thread
Atmega16 Speicher bald voll Program / Data Unterschied ?
Ich habe die ganze Zeit den alten Hexfile geladen ;) Die Texte aus dem Flash werden nicht im Display ausgegeben. Wenn ich ein Array der Strings anlege kann ich mit der lcd_puts_p() Funktion die Einträge auf das Display schreiben. [c] //Array von Menutexten zusammenbauen > const char *MainMenuStrArray
technikus schrieb im Beitrag #2273141: > Wenn ich ein Array der Strings anlege kann ich mit der lcd_puts_p() > Funktion die Einträge auf das Display schreiben. > [c] > //Array von Menutexten zusammenbauen >> const char *MainMenuStrArray[] PROGMEM = { >> MainMenu100, >> MainMenu101, >>
-
Thread
Philips 46PFL9706K/02 defekt
diesem FPGA Board ein LVDS Signal. Bei einem typischen TCON Board geht LVDS rein und raus gehen LCD-spezifische Signale, die direkt ins Display gehen. Daher wäre mal interessant, was sich unter der Abdeckung unterhalb des mittleren FPGA Board befindet.
Ok, aus dem Blockdiagramm geht hervor, dass das eingesetzte Display schon direkt einen LVDS Eingang hat. Das eigentliche TCON ist hier also nicht Bestandteil der Service-Unterlagen, es gehört sozusagen zum Bauteil Display. Das gehört zwar immer zum Display, ist aber