morgan/OMOTE
1
0
Fork 0
Code Issues 2 Pull requests Projects Releases Packages Wiki Activity

Added new interface abstract classes

Browse source
This commit is contained in:
Thomas Bittner 2023-08-10 20:41:55 +02:00 • committed by MatthewColvin
parent b31f7e04bd
commit e2138764ac
9 changed files with 711 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
Platformio/HAL/Interface/BatteryInterface.h Normal file
View file

@ -0,0 +1,9 @@
class BatteryInterface {
public:
virtual void setup(DisplayInterface& display, int adc_pin, int charging_pin) = 0;
virtual int getPercentage() = 0;
virtual bool isCharging() = 0;
virtual bool isConnected() = 0;
virtual void update() = 0;
};

18
Platformio/HAL/Interface/DisplayInterface.h Normal file
View file

@ -0,0 +1,18 @@
#pragma once
class DisplayInterface
{
public:
virtual void setup() = 0;
virtual void setup_ui() = 0;
virtual void flush() = 0;
virtual void wifi_scan_complete(unsigned int size) = 0;
virtual void clear_wifi_networks() = 0;
virtual void update_wifi(bool connected) = 0;
virtual void hide_keyboard() = 0;
virtual void show_keyboard() = 0;
virtual void updated() = 0;
virtual void reset_settings_menu() = 0;
virtual void update_battery(int percentage, bool isCharging, bool isConnected) = 0;
virtual void turnOff() = 0;
}

15
Platformio/HAL/Interface/wifiHandlerInterface.h Normal file
View file

@ -0,0 +1,15 @@
#pragma once
#include <Arduino.h>
#include "DisplayInterface.h"
class wifiHandlerInterface{
public:
virtual void begin(DisplayInterface& display) = 0;
virtual void connect(const char* SSID, const char* password) = 0;
virtual void disconnect() = 0;
virtual bool isConnected() = 0;
virtual void turnOff() = 0;
virtual void scan() = 0;
virtual char* getSSID() = 0;
virtual String getIP() = 0;
};

38
Platformio/HAL/Targets/ESP32/battery/battery.cpp Normal file
View file

@ -0,0 +1,38 @@
#include "battery.hpp"
#include <Arduino.h>
void Battery::setup(DisplayInterface& display, int adc_pin, int charging_pin)
{
this->display = display;
this->adc_pin = adc_pin;
this->charging_pin = charging_pin;
// Power Pin Definition
pinMode(this->charging_pin, INPUT_PULLUP);
pinMode(this->adc_pin, INPUT);
}
int Battery::getPercentage()
{
return constrain(map(this->getVoltage(), 3700, 4200, 0, 100), 0, 100);
}
bool Battery::isCharging()
{
return !digitalRead(this->charging_pin);
}
bool Battery::isConnected()
{
return ((!this->isCharging()) && (this->getVoltage() < 4350));
}
int Battery::getVoltage()
{
return analogRead(this->adc_pin)*2*3300/4095 + 350;
}
void Battery::update()
{
display.update_battery(this->getPercentage(), this->isCharging(), this->isConnected());
}

62
Platformio/HAL/Targets/ESP32/battery/battery.hpp Normal file
View file

@ -0,0 +1,62 @@
#pragma once
#include "BatteryInterface.h"
#include "DisplayInterface.h"
class Battery: public BatteryInterface {
public:
void setup(DisplayInterface& display, int adc_pin, int charging_pin);
/**
* @brief Get the Percentage of the battery
*
* @return int Percentage of the battery
*/
int getPercentage();
/**
* @brief Function to determine if the battery is charging or not
*
* @return true Battery is currently charging
* @return false Battery is currently not charging
*/
bool isCharging();
/**
* @brief Function to determine if the battery is connected
*
* @return true Battery is connected
* @return false Battery is not connected
*/
bool isConnected();
/**
* @brief Function to update the battery status. This should be called on a regular basis
*
*/
void update();
private:
Battery();
/**
* @brief Function to get the current voltage of the battery
*
* @return int Voltage of the battery in mV
*/
int getVoltage();
/**
* @brief Variable to store which pin should be used for ADC
*
*/
int adc_pin;
/**
* @brief Variable to store which pin is used to inidicate if the battery is currently charging or not
*
*/
int charging_pin;
DisplayInterface& display;
};

0
Platformio/HAL/Targets/ESP32/display/display.cpp Normal file
View file

305
Platformio/HAL/Targets/ESP32/display/display.hpp Normal file
View file

@ -0,0 +1,305 @@
#pragma once
#include "DisplayInterface.h"
#include <lvgl.h>
#include <TFT_eSPI.h>
#include <Adafruit_FT6206.h>
#include "driver/ledc.h"
class Display:public DisplayInterface
{
public:
static Display* getInstance();
/**
* @brief Function to setup the display.
*
*/
void setup();
/**
* @brief Function to setup the user interface. This function has to be called after setup.
*
*/
void setup_ui();
/**
* @brief Function to flush the display (update what is shown on the LCD). This function is called within
* the LVGL callback function
*
* @param disp
* @param area
* @param color_p
*/
void flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p );
/**
* @brief API function to inform display that wifi scan is completed
*
* @param size number of wifi networks found
*/
void wifi_scan_complete(unsigned int size);
/**
* @brief Clear the wifi networks listed in the wifi selection page. This function is called before new wifi
* networks are added to the list to avoid double listing
*
*/
void clear_wifi_networks();
/**
* @brief Update the wifi status. This function will update the wifi label in the status bar according to the
* parameter.
*
* @param connected Boolean parameter to indicate if a wifi connection is established or not.
*/
void update_wifi(bool connected);
/**
* @brief API function which needs to be called regularly to update the display
*
*/
void update();
/**
* @brief Function to update the battery indicator on the display
*
* @param percentage Battery percentage
* @param isCharging True if the battery is charging. False otherwise
* @param isConnected True if a battery is connected, false otherwise
*/
void update_battery(int percentage, bool isCharging, bool isConnected);
void turnOff();
private:
/**
* @brief Function to change the settings menu to main page again.
*
*/
void reset_settings_menu();
/**
* @brief Function to hide the keyboard. If the keyboard is attached to a text area, it will be hidden when the
* text area is defocused. This function can be used if the keyboard need to be hidden due to some script event.
*
*/
void hide_keyboard();
/**
* @brief Function to show the keyboard. If a text area needs the keybaord, it should be attached to the text area
* using the approbiate function. The keyboard will then show up when the text area is focused. This function is
* needed if the keyboard should be shown due to some script or other trigger.
*
*/
void show_keyboard();
Display();
/**
* @brief Pin used for LCD backlight control
*
*/
int backlight_pin;
/**
* @brief Pin used to enable the LCD
*
*/
int enable_pin;
/**
* @brief Width of the display in pixel
*
*/
int width;
/**
* @brief Height of the display in pixel
*
*/
int height;
/**
* @brief Pointer to the buffer used for drawing on the screen
*
*/
lv_color_t *bufA;
/**
* @brief Pointer to the buffer used for drawing on the screen
*
*/
lv_color_t *bufB;
/**
* @brief Object of the touch input driver
*
*/
Adafruit_FT6206 touch;
/**
* @brief Keyboard object used whenever a keyboard is needed.
*
*/
lv_obj_t* kb;
/**
* @brief Variable to store the primary color
*
*/
lv_color_t primary_color;
/**
* @brief Object of the TFT driver
*
*/
TFT_eSPI tft;
/**
* @brief Set the up settings object
*
* @param parent
*/
void setup_settings(lv_obj_t* parent);
/**
* @brief Function to create the keyboard object which can then be attached to different text areas.
*
*/
void create_keyboard();
/**
* @brief Function to attach the keyboard to a text area. If the text area is selected, the keyboard
* is shown and if the textarea is defocused, the keyboard will be hidden again.
*
* @param textarea Textarea where the keyboard should be attached to.
*/
void attach_keyboard(lv_obj_t* textarea);
/**
* @brief LVGL Menu for settings pages as needed.
*
*/
lv_obj_t* settingsMenu;
/**
* @brief Main page of the settings menu
*
*/
lv_obj_t* settingsMainPage;
/**
* @brief Battery percentage label
*
*/
lv_obj_t* objBattPercentage;
/**
* @brief Battery icon object in the status bar
*
*/
lv_obj_t* objBattIcon;
/************************************** WIFI Settings Menu *******************************************************/
/**
* @brief Container within the wifi selection page
*/
lv_obj_t* wifi_setting_cont;
/**
* @brief Wifi settings entry point on the settings tab
*
*/
lv_obj_t* wifiOverview;
/**
* @brief Label in the wifi password page. This label is updated with the selected SSID when the credentials for
* a wifi network is entered.
*
*/
lv_obj_t* wifi_password_label;
/**
* @brief Menu Subpage for the wifi password
*/
lv_obj_t* wifi_password_page;
/**
* @brief Menu Subpage for wifi selection
*/
lv_obj_t* wifi_selection_page;
/**
* @brief Wifi Label shown in the top status bar
*/
lv_obj_t* WifiLabel;
/**
* @brief Number of wifi subpage needed to display the found wifi networks
*
*/
unsigned int no_subpages;
/**
* @brief number of wifi networks found
*
*/
unsigned int no_wifi_networks;
/**
* @brief callback function to get next wifi subpage. This callback can be used to get the next or previous page
*
* @param e lvgl event object
*/
void next_wifi_selection_subpage(lv_event_t* e);
/**
* @brief Create a wifi selection sub page object
*
* @param menu LVGL Menu where the sub page should be added to
* @return lv_obj_t* Menu sub page object pointer
*/
lv_obj_t* create_wifi_selection_page(lv_obj_t* menu);
/**
* @brief Method to create the wifi password sub page
*
* @param menu Menu where the sub page should be created
* @return lv_obj_t* menu sub page object pointer
*/
lv_obj_t* create_wifi_password_page(lv_obj_t* menu);
/**
* @brief Method to create the wifi settings on the main page
*
* @param parent lv object parent where the main settings page should be added to
*/
void create_wifi_main_page(lv_obj_t* parent);
/**
* @brief Method to create wifi settings. This method will call the create_wifi_selection_page,
* the create_wifi_password_page, and the create_wifi_main_page
*
* @param menu Settings menu where the sub pages should be added to
* @param parent lv object parent where the main settings page should be added to
*/
void create_wifi_settings(lv_obj_t* menu, lv_obj_t* parent);
/**
* @brief Function to update the wifi selection sub page
*
* @param page index of the page to display
*/
void update_wifi_selection_subpage(int page);
/************************************** Display settings menu ********************************************************/
/**
* Variable to store the current backlight brightness level
*/
unsigned int backlight_brightness;
/**
* @brief Function to create the display settings page.
*
* @param parent LVGL object acting as a parent for the display settings page
*/
void display_settings(lv_obj_t* parent);
};

150
Platformio/HAL/Targets/ESP32/wifiHandler/wifihandler.cpp Normal file
View file

@ -0,0 +1,150 @@
#include "wifihandler.hpp"
#include <Arduino.h>
#include <Preferences.h>
wifiHandler* mInstance;
// WiFi status event
void wifiHandler::WiFiEvent(WiFiEvent_t event){
int no_networks = 0;
switch (event)
{
case ARDUINO_EVENT_WIFI_SCAN_DONE:
Serial.println("WIFI scan done\n");
no_networks = WiFi.scanComplete();
if (no_networks < 0)
{
Serial.println("Scan failed");
}
else
{
this->display.clear_wifi_networks();
Serial.print(no_networks);
Serial.print(" found\n");
this->display.wifi_scan_complete( no_networks);
}
break;
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
case ARDUINO_EVENT_WIFI_STA_GOT_IP6:
display.update_wifi(true);
this->update_credentials(temporary_ssid, temporary_password);
break;
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
case ARDUINO_EVENT_WIFI_STA_LOST_IP:
case ARDUINO_EVENT_WIFI_STA_STOP:
display.update_wifi(false);
default:
break;
}
}
wifiHandler* wifiHandler::getInstance()
{
if(instance == nullptr)
{
instance = new wifiHandler();
}
return instance;
}
String wifiHandler::getFoundSSID(unsigned int index)
{
return WiFi.SSID(index);
}
int wifiHandler::getFoundRSSI(unsigned int index)
{
return WiFi.RSSI(index);
}
wifiHandler::wifiHandler()
{
this->password[0] = '\0';
this->SSID[0] = '\0';
}
void wifiHandler::update_credentials(const char* temporary_ssid, const char* temporary_password)
{
if (strcmp(temporary_password, wifiHandler::password) != 0 || strcmp(temporary_ssid, wifiHandler::SSID) != 0)
{
strcpy(wifiHandler::password, temporary_password);
strcpy(wifiHandler::SSID, temporary_ssid);
Preferences preferences;
preferences.begin("wifiSettings", false);
String tempString = wifiHandler::password;
preferences.putString("password", tempString);
tempString = wifiHandler::SSID;
preferences.putString("SSID", tempString);
preferences.end();
}
}
void wifiHandler::scan()
{
WiFi.scanNetworks(true);
}
void wifiHandler::begin(DisplayInterface& display)
{
this->display = display;
mInstance = wifiHandler::getInstance();
WiFi.setHostname("OMOTE");
WiFi.mode(WIFI_STA);
WiFi.onEvent([] (WiFiEvent_t event) {mInstance->WiFiEvent(event);});
Preferences preferences;
preferences.begin("wifiSettings",false);
String ssid = preferences.getString("SSID");
String password = preferences.getString("password");
preferences.end();
/* If the SSID is not empty, there was a value stored in the preferences and we try to use it.*/
if (!ssid.isEmpty())
{
Serial.print("Connecting to wifi ");
Serial.println(ssid);
strcpy(this->SSID, ssid.c_str());
strcpy(this->password, password.c_str());
this->connect(this->SSID, this->password);
}
else
{
Serial.println("no SSID or password stored");
/*Set first character to \0 indicates an empty string*/
this->SSID[0] = '\0';
this->password[0] = '\0';
WiFi.disconnect();
}
WiFi.setSleep(true);
}
void wifiHandler::connect(const char* SSID, const char* password)
{
strncpy(this->temporary_password, password, STRING_SIZE);
strncpy(this->temporary_ssid, SSID, STRING_SIZE);
WiFi.begin(SSID, password);
}
void wifiHandler::turnOff()
{
WiFi.disconnect();
WiFi.mode(WIFI_OFF);
}
bool wifiHandler::isConnected()
{
return WiFi.isConnected();
}
char* wifiHandler::getSSID()
{
return this->SSID;
}
String wifiHandler::getIP()
{
return WiFi.localIP().toString();
}

114
Platformio/HAL/Targets/ESP32/wifiHandler/wifihandler.hpp Normal file
View file

@ -0,0 +1,114 @@
#pragma once
#include "wifiHandlerInterface.h"
#include <WiFi.h>
#define STRING_SIZE 50
class wifiHandler: public wifiHandlerInterface {
public:
static wifiHandler* getInstance();
/**
* @brief Function to initialize the wifi handler
*
*/
void begin(DisplayInterface& display);
/**
* @brief Connect to the wifi using the provided credetials
*
* @param SSID
* @param password
*/
void connect(const char* SSID, const char* password);
/**
* @brief Function to disconnect from the network
*
*/
void disconnect();
/**
* @brief Get the SSID of the found wifi
*
* @param index index of the found wifi
* @return String SSID of the wifi
*/
String getFoundSSID(unsigned int index);
/**
* @brief Get the RSSI of the found wifi
*
* @param index index of the found wifi
* @return int RSSI value of the found wifi
*/
int getFoundRSSI(unsigned int index);
/**
* @brief Function to determine wether or not we are connected to a network
*
* @return true Device is connected to wifi network
* @return false Device is not connected to wifi network
*/
bool isConnected();
/**
* @brief Function to turn off wifi
*
*/
void turnOff();
/**
* @brief function to trigger asynchronous scan for wifi networks
*
*/
void scan();
/**
* @brief Function to get SSID of the currently connected wifi network
*
* @return char* SSID of the currently connected network
*/
char* getSSID();
/**
* @brief Function to update the wifi credentials. This function is called in the wifi event callback function
* after a connection is established. Only then is the new credentials stored and the old stored credentials
* overwritten.
*
* @param temporary_ssid
* @param temporary_password
*/
static void update_credentials(const char* temporary_ssid, const char* temporary_password);
void WiFiEvent(WiFiEvent_t event);
/**
* @brief Function to get the IP address of this device
*
* @return String IP Address of the device
*/
String getIP();
private:
static wifiHandler* instance;
static char temporary_password[STRING_SIZE];
static char temporary_ssid[STRING_SIZE];
DisplayInterface& display;
wifiHandler();
/**
* @brief Internal variable to store the wifi password
*
*/
static char password[STRING_SIZE];
/**
* @brief Internal variable to store the wifi SSID
*
*/
static char SSID[STRING_SIZE];
};