mirror of https://github.com/probonopd/MiniDexed
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
400 lines
9.6 KiB
400 lines
9.6 KiB
//
|
|
// userinterface.cpp
|
|
//
|
|
// MiniDexed - Dexed FM synthesizer for bare metal Raspberry Pi
|
|
// Copyright (C) 2022 The MiniDexed Team
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
#include "userinterface.h"
|
|
#include "minidexed.h"
|
|
#include <circle/logger.h>
|
|
#include <circle/string.h>
|
|
#include <circle/startup.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
LOGMODULE ("ui");
|
|
|
|
CUserInterface::CUserInterface (CMiniDexed *pMiniDexed, CGPIOManager *pGPIOManager, CI2CMaster *pI2CMaster, CConfig *pConfig)
|
|
: m_pMiniDexed (pMiniDexed),
|
|
m_pGPIOManager (pGPIOManager),
|
|
m_pI2CMaster (pI2CMaster),
|
|
m_pConfig (pConfig),
|
|
m_pLCD (0),
|
|
m_pLCDBuffered (0),
|
|
m_pUIButtons (0),
|
|
m_pRotaryEncoder (0),
|
|
m_bSwitchPressed (false),
|
|
m_Menu (this, pMiniDexed)
|
|
{
|
|
}
|
|
|
|
CUserInterface::~CUserInterface (void)
|
|
{
|
|
delete m_pRotaryEncoder;
|
|
delete m_pUIButtons;
|
|
delete m_pLCDBuffered;
|
|
delete m_pLCD;
|
|
}
|
|
|
|
bool CUserInterface::Initialize (void)
|
|
{
|
|
assert (m_pConfig);
|
|
|
|
if (m_pConfig->GetLCDEnabled ())
|
|
{
|
|
unsigned i2caddr = m_pConfig->GetLCDI2CAddress ();
|
|
unsigned ssd1306addr = m_pConfig->GetSSD1306LCDI2CAddress ();
|
|
if (ssd1306addr != 0) {
|
|
m_pSSD1306 = new CSSD1306Device (m_pConfig->GetSSD1306LCDWidth (), m_pConfig->GetSSD1306LCDHeight (),
|
|
m_pI2CMaster, ssd1306addr,
|
|
m_pConfig->GetSSD1306LCDRotate (), m_pConfig->GetSSD1306LCDMirror ());
|
|
LOGDBG ("LCD: SSD1306");
|
|
if (!m_pSSD1306->Initialize ())
|
|
{
|
|
return false;
|
|
}
|
|
m_pLCD = m_pSSD1306;
|
|
} else if (i2caddr == 0)
|
|
{
|
|
m_pHD44780 = new CHD44780Device (m_pConfig->GetLCDColumns (), m_pConfig->GetLCDRows (),
|
|
m_pConfig->GetLCDPinData4 (),
|
|
m_pConfig->GetLCDPinData5 (),
|
|
m_pConfig->GetLCDPinData6 (),
|
|
m_pConfig->GetLCDPinData7 (),
|
|
m_pConfig->GetLCDPinEnable (),
|
|
m_pConfig->GetLCDPinRegisterSelect (),
|
|
m_pConfig->GetLCDPinReadWrite ());
|
|
LOGDBG ("LCD: HD44780");
|
|
if (!m_pHD44780->Initialize ())
|
|
{
|
|
return false;
|
|
}
|
|
m_pLCD = m_pHD44780;
|
|
}
|
|
else
|
|
{
|
|
m_pHD44780 = new CHD44780Device (m_pI2CMaster, i2caddr,
|
|
m_pConfig->GetLCDColumns (), m_pConfig->GetLCDRows ());
|
|
LOGDBG ("LCD: HD44780 I2C");
|
|
if (!m_pHD44780->Initialize ())
|
|
{
|
|
return false;
|
|
}
|
|
m_pLCD = m_pHD44780;
|
|
}
|
|
assert (m_pLCD);
|
|
|
|
m_pLCDBuffered = new CWriteBufferDevice (m_pLCD);
|
|
assert (m_pLCDBuffered);
|
|
|
|
LCDWrite ("\x1B[?25l\x1B""d+"); // cursor off, autopage mode
|
|
LCDWrite ("MiniDexed\nLoading...");
|
|
m_pLCDBuffered->Update ();
|
|
|
|
LOGDBG ("LCD initialized");
|
|
}
|
|
|
|
m_pUIButtons = new CUIButtons ( m_pConfig->GetButtonPinPrev (),
|
|
m_pConfig->GetButtonActionPrev (),
|
|
m_pConfig->GetButtonPinNext (),
|
|
m_pConfig->GetButtonActionNext (),
|
|
m_pConfig->GetButtonPinBack (),
|
|
m_pConfig->GetButtonActionBack (),
|
|
m_pConfig->GetButtonPinSelect (),
|
|
m_pConfig->GetButtonActionSelect (),
|
|
m_pConfig->GetButtonPinHome (),
|
|
m_pConfig->GetButtonActionHome (),
|
|
m_pConfig->GetButtonPinPgmUp (),
|
|
m_pConfig->GetButtonActionPgmUp (),
|
|
m_pConfig->GetButtonPinPgmDown (),
|
|
m_pConfig->GetButtonActionPgmDown (),
|
|
m_pConfig->GetButtonPinTGUp (),
|
|
m_pConfig->GetButtonActionTGUp (),
|
|
m_pConfig->GetButtonPinTGDown (),
|
|
m_pConfig->GetButtonActionTGDown (),
|
|
m_pConfig->GetDoubleClickTimeout (),
|
|
m_pConfig->GetLongPressTimeout (),
|
|
m_pConfig->GetMIDIButtonNotes (),
|
|
m_pConfig->GetMIDIButtonPrev (),
|
|
m_pConfig->GetMIDIButtonNext (),
|
|
m_pConfig->GetMIDIButtonBack (),
|
|
m_pConfig->GetMIDIButtonSelect (),
|
|
m_pConfig->GetMIDIButtonHome (),
|
|
m_pConfig->GetMIDIButtonPgmUp (),
|
|
m_pConfig->GetMIDIButtonPgmDown (),
|
|
m_pConfig->GetMIDIButtonTGUp (),
|
|
m_pConfig->GetMIDIButtonTGDown ()
|
|
);
|
|
assert (m_pUIButtons);
|
|
|
|
if (!m_pUIButtons->Initialize ())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_pUIButtons->RegisterEventHandler (UIButtonsEventStub, this);
|
|
UISetMIDIButtonChannel (m_pConfig->GetMIDIButtonCh ());
|
|
|
|
LOGDBG ("Button User Interface initialized");
|
|
|
|
if (m_pConfig->GetEncoderEnabled ())
|
|
{
|
|
m_pRotaryEncoder = new CKY040 (m_pConfig->GetEncoderPinClock (),
|
|
m_pConfig->GetEncoderPinData (),
|
|
m_pConfig->GetButtonPinShortcut (),
|
|
m_pGPIOManager);
|
|
assert (m_pRotaryEncoder);
|
|
|
|
if (!m_pRotaryEncoder->Initialize ())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_pRotaryEncoder->RegisterEventHandler (EncoderEventStub, this);
|
|
|
|
LOGDBG ("Rotary encoder initialized");
|
|
}
|
|
|
|
m_Menu.EventHandler (CUIMenu::MenuEventUpdate);
|
|
|
|
return true;
|
|
}
|
|
|
|
void CUserInterface::Process (void)
|
|
{
|
|
if (m_pLCDBuffered)
|
|
{
|
|
m_pLCDBuffered->Update ();
|
|
}
|
|
if (m_pUIButtons)
|
|
{
|
|
m_pUIButtons->Update();
|
|
}
|
|
}
|
|
|
|
void CUserInterface::ParameterChanged (void)
|
|
{
|
|
m_Menu.EventHandler (CUIMenu::MenuEventUpdate);
|
|
}
|
|
|
|
void CUserInterface::DisplayWrite (const char *pMenu, const char *pParam, const char *pValue,
|
|
bool bArrowDown, bool bArrowUp)
|
|
{
|
|
assert (pMenu);
|
|
assert (pParam);
|
|
assert (pValue);
|
|
|
|
CString Msg ("\x1B[H\E[?25l"); // cursor home and off
|
|
|
|
// first line
|
|
Msg.Append (pParam);
|
|
|
|
size_t nLen = strlen (pParam) + strlen (pMenu);
|
|
if (nLen < m_pConfig->GetLCDColumns ())
|
|
{
|
|
for (unsigned i = m_pConfig->GetLCDColumns ()-nLen; i > 0; i--)
|
|
{
|
|
Msg.Append (" ");
|
|
}
|
|
}
|
|
|
|
Msg.Append (pMenu);
|
|
|
|
// second line
|
|
CString Value (" ");
|
|
if (bArrowDown)
|
|
{
|
|
Value = "\x7F"; // arrow left character
|
|
}
|
|
|
|
Value.Append (pValue);
|
|
|
|
if (bArrowUp)
|
|
{
|
|
if (Value.GetLength () < m_pConfig->GetLCDColumns ()-1)
|
|
{
|
|
for (unsigned i = m_pConfig->GetLCDColumns ()-Value.GetLength ()-1; i > 0; i--)
|
|
{
|
|
Value.Append (" ");
|
|
}
|
|
}
|
|
|
|
Value.Append ("\x7E"); // arrow right character
|
|
}
|
|
|
|
Msg.Append (Value);
|
|
|
|
if (Value.GetLength () < m_pConfig->GetLCDColumns ())
|
|
{
|
|
Msg.Append ("\x1B[K"); // clear end of line
|
|
}
|
|
|
|
LCDWrite (Msg);
|
|
}
|
|
|
|
void CUserInterface::LCDWrite (const char *pString)
|
|
{
|
|
if (m_pLCDBuffered)
|
|
{
|
|
m_pLCDBuffered->Write (pString, strlen (pString));
|
|
}
|
|
}
|
|
|
|
void CUserInterface::EncoderEventHandler (CKY040::TEvent Event)
|
|
{
|
|
switch (Event)
|
|
{
|
|
case CKY040::EventSwitchDown:
|
|
m_bSwitchPressed = true;
|
|
break;
|
|
|
|
case CKY040::EventSwitchUp:
|
|
m_bSwitchPressed = false;
|
|
break;
|
|
|
|
case CKY040::EventClockwise:
|
|
if (m_bSwitchPressed) {
|
|
// We must reset the encoder switch button to prevent events from being
|
|
// triggered after the encoder is rotated
|
|
m_pUIButtons->ResetButton(m_pConfig->GetButtonPinShortcut());
|
|
m_Menu.EventHandler(CUIMenu::MenuEventPressAndStepUp);
|
|
|
|
}
|
|
else {
|
|
m_Menu.EventHandler(CUIMenu::MenuEventStepUp);
|
|
}
|
|
break;
|
|
|
|
case CKY040::EventCounterclockwise:
|
|
if (m_bSwitchPressed) {
|
|
m_pUIButtons->ResetButton(m_pConfig->GetButtonPinShortcut());
|
|
m_Menu.EventHandler(CUIMenu::MenuEventPressAndStepDown);
|
|
}
|
|
else {
|
|
m_Menu.EventHandler(CUIMenu::MenuEventStepDown);
|
|
}
|
|
break;
|
|
|
|
case CKY040::EventSwitchHold:
|
|
if (m_pRotaryEncoder->GetHoldSeconds () >= 120)
|
|
{
|
|
delete m_pLCD; // reset LCD
|
|
|
|
reboot ();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CUserInterface::EncoderEventStub (CKY040::TEvent Event, void *pParam)
|
|
{
|
|
CUserInterface *pThis = static_cast<CUserInterface *> (pParam);
|
|
assert (pThis != 0);
|
|
|
|
pThis->EncoderEventHandler (Event);
|
|
}
|
|
|
|
void CUserInterface::UIButtonsEventHandler (CUIButton::BtnEvent Event)
|
|
{
|
|
switch (Event)
|
|
{
|
|
case CUIButton::BtnEventPrev:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventStepDown);
|
|
break;
|
|
|
|
case CUIButton::BtnEventNext:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventStepUp);
|
|
break;
|
|
|
|
case CUIButton::BtnEventBack:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventBack);
|
|
break;
|
|
|
|
case CUIButton::BtnEventSelect:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventSelect);
|
|
break;
|
|
|
|
case CUIButton::BtnEventHome:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventHome);
|
|
break;
|
|
|
|
case CUIButton::BtnEventPgmUp:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventPgmUp);
|
|
break;
|
|
|
|
case CUIButton::BtnEventPgmDown:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventPgmDown);
|
|
break;
|
|
|
|
case CUIButton::BtnEventTGUp:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventTGUp);
|
|
break;
|
|
|
|
case CUIButton::BtnEventTGDown:
|
|
m_Menu.EventHandler (CUIMenu::MenuEventTGDown);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CUserInterface::UIButtonsEventStub (CUIButton::BtnEvent Event, void *pParam)
|
|
{
|
|
CUserInterface *pThis = static_cast<CUserInterface *> (pParam);
|
|
assert (pThis != 0);
|
|
|
|
pThis->UIButtonsEventHandler (Event);
|
|
}
|
|
|
|
void CUserInterface::UIMIDICmdHandler (unsigned nMidiCh, unsigned nMidiCmd, unsigned nMidiData1, unsigned nMidiData2)
|
|
{
|
|
if (m_nMIDIButtonCh == CMIDIDevice::Disabled)
|
|
{
|
|
// MIDI buttons are not enabled
|
|
return;
|
|
}
|
|
if ((m_nMIDIButtonCh != nMidiCh) && (m_nMIDIButtonCh != CMIDIDevice::OmniMode))
|
|
{
|
|
// Message not on the MIDI Button channel and MIDI buttons not in OMNI mode
|
|
return;
|
|
}
|
|
|
|
if (m_pUIButtons)
|
|
{
|
|
m_pUIButtons->BtnMIDICmdHandler (nMidiCmd, nMidiData1, nMidiData2);
|
|
}
|
|
}
|
|
|
|
void CUserInterface::UISetMIDIButtonChannel (unsigned uCh)
|
|
{
|
|
// Mirrors the logic in Performance Config for handling MIDI channel configuration
|
|
if (uCh == 0)
|
|
{
|
|
m_nMIDIButtonCh = CMIDIDevice::Disabled;
|
|
}
|
|
else if (uCh < CMIDIDevice::Channels)
|
|
{
|
|
m_nMIDIButtonCh = uCh - 1;
|
|
}
|
|
else
|
|
{
|
|
m_nMIDIButtonCh = CMIDIDevice::OmniMode;
|
|
}
|
|
} |