Tworzenie prostego menu na lcd

Elvis · Grudzień 27, 2021

Funkcja rysowania menu jest gotowa - wypadałoby oczywiście pomyśleć nad jej optymalizacją, usunąć kasowanie tła przy każdym rysowaniu itd. Ale jako pierwsza wersja chyba wystarczy.

Zanim przejdziemy do menu, najpierw trochę nudnego kodu, czyli dodajmy coś do funkcji wybieranych z menu:

static void show_message(const char *msg)
{
    mkr_iot.display.fillScreen(ST77XX_RED);
    mkr_iot.display.setTextColor(ST77XX_WHITE);
    mkr_iot.display.setTextSize(2);
    mkr_iot.display.setCursor(32, 120);
    mkr_iot.display.println(msg);

    delay(1000);
}

static void RTC_Event(void)
{
    show_message("RTC_Event");
}

static void display_menu2(void)
{
    show_message("display_menu2");
}

static void display_menu(void)
{
    show_message("display_menu");
}

static void zapisano_czas(void)
{
    show_message("zapisano_czas");
}

static const menu_t menu1[] = {
    { "RTC event(?)", RTC_Event },
    { "Ustaw date", display_menu2 },
    { "Ustaw czas", display_menu },
    { "Zapisz zmiany", zapisano_czas },
};

Mamy funkcję pomocniczą "show_message", która zmieni kolor tła na czerwony, a następnie wyświetli na nim komunikat. Każda funkcja wybierana z menu będzie używała jej do prezentacji działania. Na koniec oczywiście niezbędny delay, bez niego żaden program nie byłby kompletny.

Nasz program oraz struktura menu są gotowe, czas napisać funkcję obsługi menu:

void use_menu(const menu_t *menu, int menu_size)
{
    int sel = 0;

    draw_menu(menu, menu_size, sel);

    while (1) {
        mkr_iot.Buttons.update();

        if (mkr_iot.Buttons.onTouchDown(TOUCH1)) {
            if (sel < menu_size - 1)
                sel++;
            else
                sel = 0;
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH0)) {
            if (sel > 0)
                sel--;
            else
                sel = menu_size - 1;
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH2)) {
            menu[sel].func();
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH4))
            break;
    }
}

Jej wywołanie jest bardzo proste:

void loop()
{
    use_menu(menu1, 4);
}

Sam kod wykorzystuje bibliotekę dla używanej płytki, metody onTouchDown(<przycisk>) zwracają wartość niezerową, gdy użytkownik "wciśnie" wybrany przycisk. Jak widać kod jest banalnie prosty:

TOUCH1 zwiększa wartość zmiennej "sel" i rysuje menu od nowa
TOUCH0 zmniejsza wartość zmiennej "sel" i rysuje menu od nowa
TOUCH2 wywołuje funkcję przypisaną do wybranej pozycji menu
TOUCH4 powoduje wyjście z pętli

Niestety nie udało mi się uzyskać filmu w lepszej jakości, ale mam nadzieję, że łatwiej będzie uwierzyć że program faktycznie działa:

https://youtu.be/piHDJy8qaSs

Na koniec jeszcze cały kod programu:

#include <Arduino_MKRIoTCarrier.h>

MKRIoTCarrier mkr_iot;

typedef void (*menu_func)(void);

typedef struct {
    const char *text;
    menu_func func;
}menu_t;

void draw_menu(const menu_t *menu, int menu_size, int sel)
{
    int i;

    mkr_iot.display.fillScreen(ST77XX_BLACK);
    mkr_iot.display.setTextSize(2);

    for (i = 0; i < menu_size; i++) {
        if (i == sel)
            mkr_iot.display.setTextColor(ST77XX_BLACK, ST77XX_YELLOW);
        else
            mkr_iot.display.setTextColor(ST77XX_YELLOW);
        mkr_iot.display.setCursor(32, 60 + i * 24);
        mkr_iot.display.println(menu[i].text);
    }
}

void use_menu(const menu_t *menu, int menu_size)
{
    int sel = 0;

    draw_menu(menu, menu_size, sel);

    while (1) {
        mkr_iot.Buttons.update();

        if (mkr_iot.Buttons.onTouchDown(TOUCH1)) {
            if (sel < menu_size - 1)
                sel++;
            else
                sel = 0;
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH0)) {
            if (sel > 0)
                sel--;
            else
                sel = menu_size - 1;
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH2)) {
            menu[sel].func();
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH4))
            break;
    }
}

static void show_message(const char *msg)
{
    mkr_iot.display.fillScreen(ST77XX_RED);
    mkr_iot.display.setTextColor(ST77XX_WHITE);
    mkr_iot.display.setTextSize(2);
    mkr_iot.display.setCursor(32, 120);
    mkr_iot.display.println(msg);

    delay(1000);
}

static void RTC_Event(void)
{
    show_message("RTC_Event");
}

static void display_menu2(void)
{
    show_message("display_menu2");
}

static void display_menu(void)
{
    show_message("display_menu");
}

static void zapisano_czas(void)
{
    show_message("zapisano_czas");
}

static const menu_t menu1[] = {
    { "RTC event(?)", RTC_Event },
    { "Ustaw date", display_menu2 },
    { "Ustaw czas", display_menu },
    { "Zapisz zmiany", zapisano_czas },
};

void setup()
{
    mkr_iot.begin();
}

void loop()
{
    use_menu(menu1, 4);
}

Krawi92 · Grudzień 27, 2021

Jeja, dzięki za włożoną prace w kod. Postaram się go trochę przeanalizować, niestety nie używam arduino, ale koncepcje postaram się jakoś do avr-gcc przerzucić. 😉

Elvis · Grudzień 27, 2021

Jak widać program jest bardzo krótki i prosty, funkcja use_menu() ma raptem ~30 linijek, cała reszta to właściwie dodatki. Niestety wyświetlanie prostego menu może wydawać się mało interesujące - pewnie każdy wolałby rozbudowane, hierarchiczne menu. Okazuje się, że możemy to uzyskać bez zmiany kodu samego menu.

Załóżmy, że chcemy mieć 3 opcje menu głównym, czyli: RTC event(?), "Ustawienia", "Zapisz zmiany". Po wybraniu opcji "Ustawienia" chcemy mieć pod-menu z dwoma opcjami: "Ustaw date" oraz "Ustaw czas".

Zacznijmy od zdefiniowania struktury dla podmenu:

static const menu_t menu2[] = {
    { "Ustaw date", display_menu2 },
    { "Ustaw czas", display_menu },
};

Funkcje display_menu i display_menu2 mamy już napisane, wcześniej było wywoływane z menu głównego.

Teraz możemy zmienić samo menu główne:

static const menu_t menu1[] = {
    { "RTC event(?)", RTC_Event },
    { "Ustawienia", settings_menu },
    { "Zapisz zmiany", zapisano_czas },
};

Dodaliśmy opcję "Ustawienia" i chcemy, żeby pozwalała ona na otwieranie "pod-menu", czyli menu2. Rozwiązań takiego problemu jest wiele, można napisać bardzo skomplikowany kod, który będzie rozróżniał dwa (lub więcej) typy pozycji w menu, mielibyśmy więc opcje do wybory działające jak dotychczas oraz opcje otwierania kolejnego menu.

Chcieliśmy jednak mieć bardzo prosty kod - więc nie komplikujmy naszego menu, tylko napiszmy funkcję "settings_menu", która... po prostu wywoła kolejne menu:

void settings_menu(void)
{
    use_menu(menu2, 2);
}

Nic więcej nie musimy robić - nie ma potrzeby definiowania dodatkowych zmiennych na aktualnie wybraną pozycję, poziom zagnieżdżenia itd. itp.

Cały kod programu:

#include <Arduino_MKRIoTCarrier.h>

MKRIoTCarrier mkr_iot;

typedef void (*menu_func)(void);

typedef struct {
    const char *text;
    menu_func func;
}menu_t;

void draw_menu(const menu_t *menu, int menu_size, int sel)
{
    int i;

    mkr_iot.display.fillScreen(ST77XX_BLACK);
    mkr_iot.display.setTextSize(2);

    for (i = 0; i < menu_size; i++) {
        if (i == sel)
            mkr_iot.display.setTextColor(ST77XX_BLACK, ST77XX_YELLOW);
        else
            mkr_iot.display.setTextColor(ST77XX_YELLOW);
        mkr_iot.display.setCursor(32, 60 + i * 24);
        mkr_iot.display.println(menu[i].text);
    }
}

void use_menu(const menu_t *menu, int menu_size)
{
    int sel = 0;

    draw_menu(menu, menu_size, sel);

    while (1) {
        mkr_iot.Buttons.update();

        if (mkr_iot.Buttons.onTouchDown(TOUCH1)) {
            if (sel < menu_size - 1)
                sel++;
            else
                sel = 0;
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH0)) {
            if (sel > 0)
                sel--;
            else
                sel = menu_size - 1;
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH2)) {
            menu[sel].func();
            draw_menu(menu, menu_size, sel);
        }

        if (mkr_iot.Buttons.onTouchDown(TOUCH4))
            break;
    }
}

static void show_message(const char *msg)
{
    mkr_iot.display.fillScreen(ST77XX_RED);
    mkr_iot.display.setTextColor(ST77XX_WHITE);
    mkr_iot.display.setTextSize(2);
    mkr_iot.display.setCursor(32, 120);
    mkr_iot.display.println(msg);

    delay(1000);
}

static void RTC_Event(void)
{
    show_message("RTC_Event");
}

static void display_menu2(void)
{
    show_message("display_menu2");
}

void display_menu(void)
{
    show_message("display_menu");
}

void zapisano_czas(void)
{
    show_message("zapisano_czas");
}

static const menu_t menu2[] = {
    { "Ustaw date", display_menu2 },
    { "Ustaw czas", display_menu },
};

void settings_menu(void)
{
    use_menu(menu2, 2);
}

static const menu_t menu1[] = {
    { "RTC event(?)", RTC_Event },
    { "Ustawienia", settings_menu },
    { "Zapisz zmiany", zapisano_czas },
};

void setup()
{
    mkr_iot.begin();
}

void loop()
{
    use_menu(menu1, 3);
}

Mamy więc 119 linijek kodu, 2 menu oraz graficzny interfejs 🙂

Oczywiście kod jest bardzo uproszczony, wypadałoby go dalej poprawiać, udoskonalać, optymalizować itd. Jednak moim zdaniem warto zacząć od czegoś co działa, a w miarę potrzeb dodawać kolejne funkcje.

Elvis · Grudzień 27, 2021

@Krawi92 Arduino Uno używa avr-gcc, kompilator jest ten sam, inne są tylko biblioteki. Jako przykład używałem Arduino MKR Zero, czyli moduł oparty o ARM Cortex-M0+ https://botland.com.pl/arduino-seria-mkr-oryginalne-plytki/10051-arduino-mkr-zero-abx00012-samd21-ze-zlaczami-7630049200470.html

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

Krawi92 · Czerwiec 5, 2022

Troszkę odświeżę temat, ponieważ znalazłem fajny art nt. tworzenia menu na listach dwukierunkowych. Mniej więcej rozumiem temat, chociaż jeszcze przyda się kilka razy przeczytać, przeanalizować funkcje itp... Tylko problem polega na tym, że nie wiem jak z tego skorzystać 😄 Jak to wg wyświetlić na LCD ? Trochę to może głupio brzmi, ale jakoś nie mogę tego ogarnąć 😛

Plik .h

/*
 * Author: £ukasz £aguna
 * E-mail: kontakt@embeddedev.pl
 * Blog:   www.EmbeddedDev.pl
 *
 * LCD HD44780 MENU
 * Tutorial(in polish): http://www.embeddeddev.pl/menu-lcd-implementacja/
 *
 * MCU: STM32F103
 *
 */

#ifndef MENU_H_
#define MENU_H_

typedef struct menu_struct menu_t;

struct menu_struct {

	const char * name;
	menu_t * next;
	menu_t * prev;
	menu_t * child;
	menu_t * parent;
	void (*menu_function)(void);

};

menu_t menu1;
	menu_t sub_menu1_1;
		menu_t sub_menu1_1_1;
	menu_t sub_menu1_2;
menu_t menu2;
	menu_t sub_menu2_1;
	menu_t sub_menu2_2;
		menu_t sub_menu2_2_1, sub_menu2_2_2, sub_menu2_2_3, sub_menu2_2_4, sub_menu2_2_5;
	menu_t sub_menu2_3;
	menu_t sub_menu2_4;
	menu_t sub_menu2_5;
menu_t menu3;
menu_t menu4;
menu_t menu5;
menu_t menu6;

void menu_refresh(void);
void menu_next(void);
void menu_prev(void);
void menu_enter(void);
void menu_back(void);

#endif /* MENU_H_ */

plik.c

/*
 * Author: £ukasz £aguna
 * E-mail: kontakt@embeddedev.pl
 * Blog:   www.EmbeddedDev.pl
 *
 * LCD HD44780 MENU
 * Tutorial(in polish): http://www.embeddeddev.pl/menu-lcd-implementacja/
 *
 * MCU: STM32F103
 *
 */

#include <string.h>

#include "../LCD/lcd.h"
#include "../LCD/lcd_buf.h"

#include "menu.h"

// definition of menu's components: (*name, *next, *prev, *child, *parent, (*menu_function))
menu_t menu1 = { "ELEMENT 1", &menu2, &menu6, &sub_menu1_1, NULL, NULL };
	menu_t sub_menu1_1 = { "ELEMENT 1_1", &sub_menu1_2, &sub_menu1_2, &sub_menu1_1_1, &menu1, NULL };
		menu_t sub_menu1_1_1 = { "ELEMENT 1_1_1", NULL, &sub_menu1_1_1, NULL, &sub_menu1_1, NULL };
	menu_t sub_menu1_2 = { "ELEMENT 1_2", NULL, &sub_menu1_1, NULL, &menu1, NULL };
menu_t menu2 = { "ELEMENT 2", &menu3, &menu1, &sub_menu2_1, NULL, NULL };
	menu_t sub_menu2_1 = { "ELEMENT 2_1", &sub_menu2_2, &sub_menu2_4, NULL, &menu2, NULL };
	menu_t sub_menu2_2 = { "ELEMENT 2_2", &sub_menu2_3, &sub_menu2_1, &sub_menu2_2_1, &menu2, NULL };
		menu_t sub_menu2_2_1 = { "ELEMENT 2_2_1", &sub_menu2_2_2, &sub_menu2_2_5, NULL, &sub_menu2_2, NULL };
		menu_t sub_menu2_2_2 = { "ELEMENT 2_2_2", &sub_menu2_2_3, &sub_menu2_2_1, NULL, &sub_menu2_2, NULL };
		menu_t sub_menu2_2_3 = { "ELEMENT 2_2_3", &sub_menu2_2_4, &sub_menu2_2_2, NULL, &sub_menu2_2, NULL };
		menu_t sub_menu2_2_4 = { "ELEMENT 2_2_4", &sub_menu2_2_5, &sub_menu2_2_3, NULL, &sub_menu2_2, NULL };
		menu_t sub_menu2_2_5 = { "ELEMENT 2_2_5", NULL, &sub_menu2_2_4, NULL, &sub_menu2_2, NULL };
	menu_t sub_menu2_3 = { "ELEMENT 2_3", &sub_menu2_4, &sub_menu2_2, NULL, &menu2, NULL };
	menu_t sub_menu2_4 = { "ELEMENT 2_4", NULL, &sub_menu2_3, NULL, &menu2, NULL };
menu_t menu3 = { "ELEMENT 3", &menu4, &menu2, NULL, NULL, NULL };
menu_t menu4 = { "ELEMENT 4", &menu5, &menu3, NULL, NULL, NULL };
menu_t menu5 = { "ELEMENT 5", &menu6, &menu4, NULL, NULL, NULL };
menu_t menu6 = { "ELEMENT 6", NULL, &menu5, NULL, NULL, NULL };

menu_t *currentPointer = &menu1;

uint8_t menu_index;
uint8_t lcd_row_pos;
uint8_t lcd_row_pos_level_1, lcd_row_pos_level_2;

void menu_refresh(void) {

	menu_t *temp;
	uint8_t i;

	if (currentPointer->parent) temp = (currentPointer->parent)->child;
	else temp = &menu1;

	for (i = 0; i != menu_index - lcd_row_pos; i++) {
		temp = temp->next;
	}

	buf_clear();
	for (i = 0; i < LCD_ROWS; i++) {

		buf_locate(0, i);
		if (temp == currentPointer) buf_char(62);
		else buf_char(' ');

		buf_locate(2, i);
		buf_str(temp->name);

		temp = temp->next;
		if (!temp) break;

	}

	// lcd_refresh();
}

uint8_t menu_get_index(menu_t *q) {

	menu_t *temp;
	uint8_t i = 0;

	if (q->parent) temp = (q->parent)->child;
	else temp = &menu1;

	while (temp != q) {
		temp = temp->next;
		i++;
	}

	return i;
}

uint8_t menu_get_level(menu_t *q) {

	menu_t *temp = q;
	uint8_t i = 0;

	if (!q->parent) return 0;

	while (temp->parent != NULL) {
		temp = temp->parent;
		i++;
	}

	return i;
}

void menu_next(void) {

	if (currentPointer->next)
	{

		currentPointer = (*currentPointer).next;
		menu_index++;
		if (++lcd_row_pos > LCD_ROWS - 1) lcd_row_pos = LCD_ROWS - 1;
	}
	else
	{
		menu_index = 0;
		lcd_row_pos = 0;

		if (currentPointer->parent) currentPointer = (currentPointer->parent)->child;
		else currentPointer = &menu1;
	}

	menu_refresh();

}

void menu_prev(void) {

	currentPointer = currentPointer->prev;

	if (menu_index)
	{
		menu_index--;
		if (lcd_row_pos > 0) lcd_row_pos--;
	}
	else
	{
		menu_index = menu_get_index(currentPointer);

		if (menu_index >= LCD_ROWS - 1) lcd_row_pos = LCD_ROWS - 1;
		else lcd_row_pos = menu_index;
	}

	menu_refresh();
}

void menu_enter(void) {

	if (currentPointer->menu_function) currentPointer->menu_function();

	if (currentPointer->child)
	{

		switch (menu_get_level(currentPointer)) {
			case 0:
				lcd_row_pos_level_1 = lcd_row_pos;
				break;

			case 1:
				lcd_row_pos_level_2 = lcd_row_pos;
				break;
		}

		// switch...case can be replaced by:
		// lcd_row_pos_level[ menu_get_level(currentPointer) ] = lcd_row_pos;

		menu_index = 0;
		lcd_row_pos = 0;

		currentPointer = currentPointer->child;

		menu_refresh();
	}
}

void menu_back(void) {

	if (currentPointer->parent) {

		switch (menu_get_level(currentPointer)) {
			case 1:
				lcd_row_pos = lcd_row_pos_level_1;
				break;

			case 2:
				lcd_row_pos = lcd_row_pos_level_2;
				break;
			}

		currentPointer = currentPointer->parent;
		menu_index = menu_get_index(currentPointer);

		menu_refresh();

	}
}

źródło : http://www.embeddeddev.pl/menu-lcd-implementacja/

Krawi92 · Czerwiec 5, 2022

Odświeżając wątek, staram się analizować kod elvisa, który w sumie wydaję się prosty, ale przerzucenie tego na LCD sprawia mi trochę problemów. Na razie posklejałem trochę kodu, udało mi się wyświetlić 4 elementy powiedzmy menu, no i znacznik, którym mogę sterować za pomocą przycisków góra/dół.

#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

#define PREV PD0
#define OK PD6
#define UP PD5
#define DOWN PD7

void Rs232_fun(void);
void PWM_fun(void);
void Motor_fun(void);
void Network_fun(void);


typedef void (*menu_func)(void);

typedef struct {
	char *tekst;
	menu_func func;
}menu_t;

menu_t menu1[] = {
		{"RS232", Rs232_fun},
		{"PWM", PWM_fun},
		{"Motor",Motor_fun},
		{"Network",Network_fun},
};
void draw_menu (menu_t *menu, int menu_size,int sel);


uint8_t keylock[4];
int sel=0;


int main(){

	PORTD |= (1<<PREV)|(1<<OK)|(1<<UP)|(1<<DOWN);
	lcd_init();

	while(1){

	draw_menu(menu1,4,sel);

	if(!keylock[0] && !(PIND & (1<<DOWN))){
		keylock[0]=220;
		sel++;
		if(sel>3)sel=0;
	}else if (keylock[0] && (PIND & (1<<DOWN)))keylock[0]++;

	if(!keylock[1] && !(PIND & (1<<UP))){
		keylock[1]=220;
		sel--;
		if(sel<0)sel=3;
	}else if (keylock[1] && (PIND & (1<<UP)))keylock[1]++;
   }
}

void draw_menu (menu_t *menu, int menu_size,int sel){
	int i;
	for (i=0;i<menu_size;i++){
		if (i == sel){
			lcd_locate(i,0);
			lcd_char('>');
		}
		else{
			lcd_locate(i,0);
			lcd_char(' ');
		}
		lcd_locate(i,1);
		lcd_str(menu1[i].tekst);
	}
}

void Rs232_fun(void){

}
void PWM_fun(void){

}
void Motor_fun(void){

}
void Network_fun(void){

}

Największe wątpliwości mam co do tej funkcji, w której wyświetlam menu i wyświetlam ">" lub spacje.

for (i=0;i<menu_size;i++){
		if (i == sel){
			lcd_locate(i,0);
			lcd_char('>');
		}
		else{
			lcd_locate(i,0);
			lcd_char(' ');
		}
		lcd_locate(i,1);
		lcd_str(menu1[i].tekst);
	}

Kolejnym krokiem, którym bym się chciał zająć jest funkcja menu_enter/ok, za pomocą której bym przechodził powiedzmy do sub_menu lub wywoływał daną funkcje. Tylko zastanawiam się jak tu powiązać zmienną sel z odpowiednimi elementami menu.

Krawi92 · Czerwiec 19, 2022

Hejka, męczę się z pewnym problemem i potrzebowałbym porady bo myślę, że czegoś tu mocno nie rozumiem. Rozwijam kod prostego menu, który @Elvis napisał jakiś czas temu. Wszystko ładnie działa, rysowanie nowego menu, wywoływanie funkcji itp. Jednak chcę teraz dodać jakieś ustawienia, wyświetlać obok nazwy jakąś powiedzmy wartość i według potrzeb ją zmieniać. Zacząłem tak:

typedef struct {
	char *tekst;
	int properties;
	menu_func func;
}menu_t;

Dodałem nowy element do struktury "properties", które chcę wyświetlać jeśli zajdzie taka potrzeba.

 menu_t menu1[] = {
		{"RS232",9600,Rs232_fun},
		{"PWM",0 ,PWM_fun},
		{"Motor",0,motor_setting},
		{"Network",0,Network_fun},
};

Gdy na sztywno wpiszę wartość properties, wszystko jest OK, wyświetla się dobrze. Jednak ja chciałbym mieć możliwość zmiany wartości, zwiększyć lub zmniejszyć, więc musiałaby tam być jakaś zmienna i tu zaczynają się schody.

int frame=9600;

 menu_t menu1[] = {
		{"RS232",frame,Rs232_fun},
		{"PWM",0 ,PWM_fun},
		{"Motor",0,motor_setting},
		{"Network",0,Network_fun},
};

Dostaje error : main.c:33:12: error: initializer element is not constant

więc dodaje operator &

{"RS232",&frame,Rs232_fun},

i dostaje warning : warning: initialization makes integer from pointer without a cast [-Wint-conversion]

więc robię jawne rzutowanie

{"RS232",(int)&frame,Rs232_fun},

Wtedy kompilacja przechodzi bez błędów, ale na LCD dostaje wartość 298, zamiast 9600. Gdy zmienna frame będzie miała wartość 0, to wyświetla mi wartość 348. 😕 Kompletnie nie wiem, o co tu chodzi.

Pełny kod:

#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <stdio.h>
#include "lcd.h"


#define PREV PD0
#define OK PD6
#define UP PD5
#define DOWN PD7
int frame;
int baud;
void Rs232_fun(void);
void PWM_fun(void);
void Motor_fun(void);
void Network_fun(void);
void motor_setting(void);
void main_menu(void);

typedef void (*menu_func)(void);

typedef struct {
	char *tekst;
	int properties;
	menu_func func;
}menu_t;

 menu_t menu1[] = {
		{"RS232",(int)&frame,Rs232_fun},
		{"PWM",0 ,PWM_fun},
		{"Motor",0,motor_setting},
		{"Network",0,Network_fun},
};
 menu_t menu2[] = {
		{"FRAME",0 ,Motor_fun},
		{"BAUD",0,Network_fun},
		{"BACK",0, main_menu},
};

void draw_menu (menu_t *menu, int menu_size,int sel);
void use_menu( menu_t *menu, int menu_size);
uint8_t keylock[4];
int sel=0;


int main(){

	DDRD |= (1<<PD1);
	PORTD |= (1<<PREV)|(1<<OK)|(1<<UP)|(1<<DOWN);
	lcd_init();

	while(1){

	use_menu(menu1,4);
   }
}
void draw_menu (menu_t *menu, int menu_size,int sel){
	int i;
	for (i=0;i<menu_size;i++){
		if (i == sel){
			lcd_locate(i,0);
			lcd_char('>');
		}
		else{
			lcd_locate(i,0);
			lcd_char(' ');
		}
		lcd_locate(i,1);
		lcd_str(menu[i].tekst);
		if(menu[i].properties>0){
			lcd_locate(i,10);
			lcd_int(menu[i].properties);
		}

	}
}
void use_menu( menu_t *menu, int menu_size){

		while(1){
		draw_menu(menu,menu_size,sel);
		if(!keylock[0] && !(PIND & (1<<DOWN))){
			keylock[0]=220;
			sel++;
			if(sel>menu_size-1)sel=0;
		}else if (keylock[0] && (PIND & (1<<DOWN)))keylock[0]++;

		if(!keylock[1] && !(PIND & (1<<UP))){
			keylock[1]=220;
			sel--;
			if(sel<0)sel=menu_size-1;
		}else if (keylock[1] && (PIND & (1<<UP)))keylock[1]++;


		if(!keylock[2] && !(PIND & (1<<OK))){
			keylock[2]=220;
			menu[sel].func();
		}else if (keylock[2] && (PIND & (1<<OK)))keylock[2]++;

		if(!keylock[3] && !(PIND & (1<<PREV))){
			keylock[3]=220;

		}else if (keylock[3] && (PIND & (1<<PREV)))keylock[3]++;
	}
}

void main_menu(void){
	lcd_cls();
	use_menu(menu1,4);
}
void motor_setting(void){
lcd_cls();
	use_menu(menu2,3);
}
void Rs232_fun(void){
	PORTD |= (1<<PD1);
}
void PWM_fun(void){
	PORTD &=~ (1<<PD1);
}
void Motor_fun(void){
}
void Network_fun(void){
}

Edytowano Czerwiec 19, 2022 przez Krawi92

_LM_ · Czerwiec 20, 2022

lepiej dla properites podstawić wskaźnik do edytowanej zmiennej

typedef struct {
	char *tekst;
	int  * properties;
	menu_func func;
}menu_t;

lub jeszcze lepiej zrobić z niej void * ptr; ale jak już mamy taki zapis to wypełnienie powinno wyglądać:

int frame=9600,pwm = 120,motor = 44,network = 8888;

 menu_t menu1[] = {
		{"RS232",&frame,Rs232_fun},
		{"PWM",&pwm ,PWM_fun},
		{"Motor",&motor,motor_setting},
		{"Network",&network,Network_fun},
};

wyświetlenie i zmiana wartości:

lcd_int(*menu[0].properites);
 *menu[0].properites = 115200;
lcd_int(*menu[0].properites);

Bradley · Sierpień 31, 2022

Kolega @_LM_ rozwiązał problem z którym @Krawi92 się zetknął ale nie wytłumaczył skąd się wziął błąd.


int frame;

typedef void (*menu_func)(void);

typedef struct {
	char *tekst;
	int properties;
	menu_func func;
}menu_t;

 menu_t menu1[] = {
		{"RS232",(int)&frame,Rs232_fun},
		{"PWM",0 ,PWM_fun},
		{"Motor",0,motor_setting},
		{"Network",0,Network_fun},
};

Zadeklarowałeś zmienną frame typu int. W definicji struktury masz pole properties typu int. W tablicy menu1[] do pola int properties przypisujesz (int)&frame czyli adres zmiennej frame rzutowany na typ int. W efekcie wyświetlać będziesz adres zmiennej frame, a nie jej wartość. Kolega @_LM_ rozwiązał problem ponieważ zmienił definicję struktury:

typedef struct {
	char *tekst;
	int  * properties;
	menu_func func;
}menu_t;

Zmienił pole int properties na wskaźnik do zmiennej typu int, a następnie przypisał do tego pola adres zmiennej frame.

int frame=9600,pwm = 120,motor = 44,network = 8888;

 menu_t menu1[] = {
		{"RS232",&frame,Rs232_fun},
		{"PWM",&pwm ,PWM_fun},
		{"Motor",&motor,motor_setting},
		{"Network",&network,Network_fun},
};

W ten sposób prawidłowo udało się wyświetlić lub zmodyfikować wartość pola z użyciem operatora wyłuskania *

*menu[0].properites = 115200;
lcd_int(*menu[0].properites);

Post uzupełniony w celach dydaktycznych dla potomnych 🙂

Tworzenie prostego menu na lcd

Pomocna odpowiedź

Elvis

Link do komentarza

Share on other sites

Krawi92

Link do komentarza

Share on other sites

Elvis

Link do komentarza

Share on other sites

Elvis

Link do komentarza

Share on other sites

Polecacz 101

Krawi92

Link do komentarza

Share on other sites

Krawi92

Link do komentarza

Share on other sites

Krawi92

Link do komentarza

Share on other sites

_LM_

Link do komentarza

Share on other sites

Bradley

Link do komentarza

Share on other sites

Dołącz do dyskusji, napisz odpowiedź!

Quizy

Najnowsze posty w innych tematach

Wyświetlacz SAA1064- zrozumiały opis sterowania 1 2

Kurs elektroniki II - #5 - czujniki analogowe 1 2 3 4 8

upalony kondensator - jaki wstawić?

Zgrzewarka do ogniw z akumulatora. 1 2

Problem z wydrukiem pod skosem

Inne