Published September 22, 2021 © GPL3+

A User-Friendly Interface in a Simple Timer

Make a user-friendly interface with an alphanumeric display, a rotary encoder and a finite state machine.

IntermediateFull instructions provided3,308

A User-Friendly Interface in a Simple Timer

Things used in this project

Hardware components

Arduino Nano Every

Adafruit Standard LCD - 16x2 White on Blue

Any standard 16x2 alphanumeric LCD with backlight and compatible with liquidCrystal library

Rotary Encoder with Push-Button

speaker 50 ohms

Logic Level FET N-Channel

Trimmer Potentiometer, 10 kohm

Through Hole Resistor, 10 ohm

Breadboard (generic)

Story

This project explains how a finite state machine may be useful to make a user-friendly interface with an alphanumeric display and a rotary encoder. As an example we will realize a simple timer, but you will be able to create your own machines easily.

History

I wanted to put several devices into the same box. In this box I connected an Arduino Nano Every with a 2 x 16 characters LCD (Liquid Crystal Display), a rotary encoder, a RTC (Real Time Clock), a beeper and a temperature and pressure measuring module. And now, by turning the rotary encoder, I can access a clock and calendar, a thermometer and barometer, a tide clock, a timer and so on... By pushing the rotary encoder, I can adjust many parameters: the temperature unit (°C, °F or °K), the pressure unit (mmHg or hPa), the altitude which is used to calculate the pressure at sea level, the brightness of the LCD...

The Arduino board is behind a hole of the box, so I can connect it to my PC and program it without opening the box. So I create and add new devices but I never open the box. Today I have opened it exceptionally just to photography it and show you what is inside.

1 / 3

I will not put this project into the project hub because it is not finished, and I think it will never be. Instead, I will explain how to do a simple device (a timer) using the same techniques, essentially the user interface based on the LCD, the rotary encoder and a finite state machine. Afterwards, you will be able to use the program as a frame to realize your own projects and to make very complex machines.

User manual of the timer

To use this timer, you program a delay by pressing the rotary knob during more than 3 seconds. You choose the number of hours, the number of minutes and the number of seconds by turning and pressing the rotary knob. Then the timer starts and you can see the delay decrease on the LCD. When the delay reaches 0, the timer beeps. You can stop the beeper by pressing the rotary knob.

This is very simple, so we can add some functions, just for the exercise. First, if you turn the rotary knob, you can see and adjust the brightness of the LCD. If you keep turning the rotary knob, you can see and adjust the tone of the beeper while hearing it. The last function is a pause in the timer countdown: if you press the rotary knob while the timer is running, the counting is suspended. It will restart when you press the rotary knob again.

The hardware

I programmed this timer in my box which contains all the necessary hardware, but you can use a breadboard to make your own timer. You will need an Arduino board (I have got a Nano Every, but any board can be used), a standard 2 x 16 alphanumeric LCD with a back-light, a 10 kΩ potentiometer to adjust the contrast of the LCD, a rotary encoder, a beeper, an N-channel FET (2N7000 or equivalent) and a resistor to drive the back-light of the LCD.

The LCD will be connected to the Arduino board in the same manner as in the examples of the LiquidCrystal library. The 10 kΩ potentiometer delivers an adjustable voltage to the V0 input.

The pins CLK, DT and SW of the rotary encoder will be connected respectively to pins 6, 7 and 8 of the Arduino. In my rotary encoder, the pins CLK and DT have an integrated pull-up resistor, while the SW pin does not. So, the pinMode of pins 6 and 7 is INPUT, and it is INPUT_PULLUP for pin 8.

As a beeper, any type of speaker may be suitable. I am using a 50 Ω miniature loudspeaker driven by an N-channel FET. If your loudspeaker has a smaller resistor, you may need to add a resistor in series with it.

The software

This project aims to show how we can use a Finite State Machine (fsm) to build a user-friendly interface with a rotary encoder and an alphanumeric LCD. So we will begin by some words about fsm.

In an fsm, there are a number of states, and at any time, the system is in one of these states, called the current state. Events can happen, and change the current state. These changes are called transitions. You can describe the system by a state diagram where all the states and all the transitions are represented. If you want to know more about fsm, you are encouraged to look at the very good project "Using Finite State Machines" by Gustavo. You can access this project by clicking here.

As we are creating a user interface, it is logical to imagine that the current state of the system will change when the user manipulates the rotary encoder. So the events that will make the current state change are issued from the rotary encoder and they can be:

clockwise rotation (cwRot),
counterclockwise rotation (ccwRot),
pushing the switch briefly (shortSwitchPress),
pushing the switch more than 3 seconds (longSwitchPress),
nothing happened since 30 seconds (timeOut)

In our timer, there are 8 states. They are represented in the following state diagram with the transitions between them:

Not easy to read? Let me help you.

Progressive construction of the state diagram

First, let's consider only the three states which display a parameter:

Each of these states displays a different parameter: the remaining time of the timer (timerDisplay), the brightness of the LCD (dimmingDisplay) and the frequency of the beeper (toneDisplay). The transitions between these states are activated by the events cwRot and ccwRot, i. e. the user changes the displayed parameter by turning the rotary encoder.

The timerDisplay state is represented in red to show that it is the initial state at power up.

You can imagine that these states are on a circle and that you travel on this circle when you turn the rotary encoder in one direction or the other:

In our timer we have only three states on the circle, but we could have any number of states. This is very important, because it is the way to expand your system. For each function or device you want to add to your system, you add a new state on the circle. And if there are too many states on the main circle, you can add other circles and put states on them to communicate between circles. (for example a state "System" on the main circle to give an access to a second circle whose states are used to adjust system parameters).

And now, from each state which displays a parameter, we will add a transition towards a state which allows the user to adjust this parameter. These transitions will be activated by a long press on the rotary encoder:

Once the user has adjusted a parameter, he returns to the corresponding display state by pressing briefly the rotary encoder. There is an exception: after setting the hours of the timer delay, he has to adjust the minutes then the seconds. So we will add two new states, and the transitions between them will also be activated by a short press on the rotary encoder:

A special transition

And now, we will add a special transition. When this transition is activated, the system goes from the timerDisplay state to the timerDisplay state. No, the current state does not change:

This transition is activated when the system is in the timerDisplay state, and the user presses the rotary encoder briefly. Its role is to call a function which positions a boolean. This boolean changes the behavior of some other functions. This way, the user can pause or restart the count when the timer is active, or stop the beeper when the timer has reached 0. Simple, but very powerful.

To terminate, we will add four transitions which are not mandatory, it is just the final touch. Imagine that you are adjusting the frequency of the beeper (the beeper beeps during this operation), and your phone rings. When you are back, the beeper is still beeping. That is not a good idea. So we will stop it automatically after 30 seconds. To do that, we add a transition which is activated by the timeOut event, and which returns from the setting state back to the display state of the beeper frequency. We will do that for all the setting states except one: the timerSecondSet state because if we stop this state automatically, the timer will start. When the user is setting the seconds, the timer waits for him to press the rotary encoder as long as necessary.

Now the state diagram is complete, and I wish you can read it:

Software implementation

To implement this fsm into the software of the timer, I used the arduino-fsm library. In this library, each transition may be associated with a function (which I used for pausing the count or stopping the beeper), and each state may be associated with three functions: the first one is activated once when the system enters the state, the second one is activated repetitively as long as the system is in this state, and the third one is activated once when the system leaves this state.

For example, in the dimmingSet state, the first function (dimmingSetEnter) makes the right characters of the display to blink. The second function (dimmingSet) adjusts the brightness of the display according to the rotations of the rotary encoder and displays its value. The third function (dimmingSetExit) stores the value of the brightness into the EEPROM. This is useful in order to retrieve the value after a power down. To encode these functions you do not need to know by which state of the fsm they are called and by which transitions it passed. To make your system evolve, you can modify the functions or the fsm independently.

Conclusion

Several other things could be said about this software, such as the usage of the EEPROM, but I think that the commentaries are sufficient to explain them and that the main subject was the use of a Finite State Machine.

I hope this project will make you want to build your own beautiful and complex machines.

Code

Timer

[code]
/****************************************/
/************ A simple timer ************/
/**** with a user-friendly interface ****/
/****************************************/ 

/* Libraries and their licence files */
#include <LiquidCrystal.h>

// arduino-fsm is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// arduino-fsm 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 Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with arduino-fsm.  If not, see <http://www.gnu.org/licenses/>.

#include <Fsm.h>

/*
  EEPROM.h - EEPROM library
  Original Copyright (c) 2006 David A. Mellis.  All right reserved.
  New version by Christopher Andrews 2015.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include <EEPROM.h>

/* Hardware connections */
#define LCDRs 12
#define LCDEn 11
#define LCDD4 5
#define LCDD5 4
#define LCDD6 3
#define LCDD7 2
#define backLightPin 10
#define rotaryAPin 6
#define rotaryBPin 7
#define rotarySwitchPin 8
#define beeperPin A0

/* Global variables */
unsigned long remainingTime=0; // seconds
bool timerRunning=false;
int dimming, toneFrequencyIndex;
String lines[2];

/* Frequencies of notes from C4 to B7 */
int toneFrequencies[48]=
{
  262, 277, 294, 311, 330, 349, 370, 392, 415,
  440, 466, 494, 523, 554, 587, 622, 659, 698,
  740, 784, 831, 880, 932, 988, 1047, 1109,
  1175, 1245, 1319, 1397, 1480, 1568, 1661,
  1760, 1865, 1976, 2093, 2217, 2349, 2489,
  2637, 2794, 2960, 3136, 3332, 3520, 3729,
  3951
};

/* Addresses in the EEPROM */
enum EEPROMAddresses
{
  EEPROMId0,
  EEPROMId1,
  EEPROMId2,
  EEPROMDimming,
  EEPROMTone
};

/* Events generated by the rotary switch */
enum potentialEvents
{
  noEvent,
  cwRot, // clockwise rotation
  ccwRot, // counterclockwise rotation
  shortSwitchPress, longSwitchPress,
  timeOut
} event;

#define maxTime 30000
#define longPressTime 2500

LiquidCrystal lcd(LCDRs, LCDEn, LCDD4, LCDD5,
                  LCDD6, LCDD7);


/* Display objects and functions */

/* An object of the class flash can make an
   area of contiguous characters on a line
   of the LCD blink at any frequency and
   any duty cycle 
*/
class flash
{  
public :
  bool on;
  int line, row, number, period, cycle;
  void setFlash(bool flashOn,
                int flashLine=0,
                int flashRow=0,
                int flashNumber=0,
                int flashPeriod=800,
                int flashCycle=60)
  {
    on=flashOn;
    line=flashLine;
    row=flashRow;
    number=flashNumber;
    period=flashPeriod;
    cycle=flashCycle;    
  }
  
  flash() // Constructor
  {
    on=false;
  }
};

#define flashingAreasNumber 2
flash displayFlash[flashingAreasNumber];

/* The text to be displayed on the LCD is
   stored in the variables lines[0] and
   lines[1]. This fonction displays it
   on the LCD while blinking the areas
   defined in the objects of class flash.
*/
void LCDShow(void)
{
  String line;
  for(int i=0; i<2; i++)
  {
    line=lines[i];
    for(int j=0; j<flashingAreasNumber; j++)
    {
      if(displayFlash[j].on && 
         displayFlash[j].line==i &&
         (millis()%displayFlash[j].period >
           ((long)displayFlash[j].period *
            (long)displayFlash[j].cycle)/100))
      {
        for(int k=0; k<displayFlash[j].number; k++)
          line.setCharAt
           (displayFlash[j].row+k, ' ');
      }
    }
    lcd.setCursor(0, i);
    lcd.print(line);
  }
}

void clearDisplay(void)
{
  for(int i=0; i<flashingAreasNumber; i++)
    displayFlash[i].setFlash(false);
  lines[0]="                ";
  lines[1]="                ";
  LCDShow();
}

/* Functions called by the finite state
   machine. They display and set the different
   values accessible to the user : delay of
   the timer, brightness of the LCD and
   frequency of the beeper. Some values are
   stored into the EEPROM after setting.
*/

void timerDisplay(void)
{
  int hour, minute, second;
  
  hour=remainingTime/3600;
  minute=(remainingTime-hour*3600L)/60;
  second=remainingTime%60;
  
  lines[0]="Timer           ";
  lines[1]="   ";
  if(hour<10) lines[1]+=" ";
  lines[1]+=String(hour);
  lines[1]+=":";
  if(minute<10) lines[1]+="0";
  lines[1]+=String(minute);
  lines[1]+=":";
  if(second<10) lines[1]+="0";
  lines[1]+=String(second);
  LCDShow();
}

void dimmingDisplay(void)
{
  lines[0]="Brightness      ";
  lines[1]="      "+String(dimming);
  LCDShow();
}

void toneDisplay(void)
{
  lines[0]="Tone            ";
  lines[1]="    ";
  if (toneFrequencies[toneFrequencyIndex]<1000)
    lines[1]+=" ";
  lines[1]+=String(toneFrequencies
                   [toneFrequencyIndex]);
  lines[1]+=" Hz      ";
  LCDShow();
}

void timerHourSetEnter(void)
{
  clearDisplay();
/*
  The two following lines just for showing
  that it is possible to program two areas
  blinking at different frequencies.
 */
  displayFlash[0].setFlash(true, 0, 0, 5, 1000,
                           50);
  displayFlash[1].setFlash(true, 1, 3, 2);
  timerDisplay();
  timerRunning=false;                          
}

void timerHourSet(void)
{
  int hour;
  hour=remainingTime/3600; 
  if (event==cwRot && hour<23) hour++;
  else
    if (event==ccwRot && hour>0) hour--;
  remainingTime=remainingTime%3600+hour*3600L;
  timerDisplay();
}

void timerMinuteSetEnter(void)
{
  clearDisplay();
  displayFlash[0].setFlash(true, 0, 0, 5, 1000,
                           50);
  displayFlash[1].setFlash(true, 1, 6, 2);
  timerDisplay();                          
}

void timerMinuteSet(void)
{
  int minute;
  minute=(remainingTime%3600)/60;
  if (event==cwRot && minute<59) minute++;
  else
    if (event==ccwRot && minute>0) minute--;
  remainingTime=(remainingTime/3600)*3600+
                remainingTime%60 +
                minute*60L;
  timerDisplay();
}

void timerSecondSetEnter(void)
{
  clearDisplay();
  displayFlash[0].setFlash(true, 0, 0, 5, 1000,
                           50);
  displayFlash[1].setFlash(true, 1, 9, 2);
  timerDisplay();                          
}

void timerSecondSet(void)
{
  int second;
  second=remainingTime%60;
  if (event==cwRot && second<59) second++;
  else
    if (event==ccwRot && second>0) second--;
  remainingTime=(remainingTime/60)*60+second;
  timerDisplay();
}

void timerSecondSetExit(void)
{
  if (remainingTime!=0) timerRunning=true;  
}

/* This function stops the beeper when it is
   beeping, and suspends or restarts the
   counting of the timer.
*/
void toggleTimerRunning(void)
{
  if (remainingTime==0)
  {
    timerRunning=false;
    noTone(beeperPin);
  }
  else timerRunning=!timerRunning;
}

void dimmingSetEnter(void)
{
  displayFlash[0].setFlash(true, 1, 6, 1);
  dimmingDisplay();
}

void dimmingSet(void)
{
  if(event==cwRot && dimming<9) dimming++;
  else
    if(event==ccwRot && dimming>0) dimming--;
  dimmingDisplay();
}

void dimmingSetExit(void)
{
  EEPROM.update(EEPROMDimming, dimming);
}

void toneSetEnter(void)
{
  displayFlash[0].setFlash(true, 1, 4, 4);
  toneDisplay();
  noTone(beeperPin);
  tone(beeperPin,
       toneFrequencies[toneFrequencyIndex]);
}

void toneSet(void)
{
  if(event==cwRot && toneFrequencyIndex<47)
    toneFrequencyIndex++;
  else
    if (event==ccwRot && toneFrequencyIndex>0)
      toneFrequencyIndex--;
  toneDisplay();
  if(event==cwRot || event==ccwRot)
  {
    noTone(beeperPin);
    tone(beeperPin,
       toneFrequencies[toneFrequencyIndex]);
  }
}

 void toneSetExit(void)
{
  noTone(beeperPin);
  EEPROM.update(EEPROMTone,
    toneFrequencyIndex);
}

/*
  States of the finite state machine
*/
State timerDisplayState(&clearDisplay,
                        &timerDisplay, NULL);
State dimmingDisplayState(&clearDisplay,
                          &dimmingDisplay,
                          NULL);
State toneDisplayState(&clearDisplay,
                       &toneDisplay,
                       NULL);
State timerHourSetState(&timerHourSetEnter,
                        &timerHourSet,
                        NULL);
State timerMinuteSetState(&timerMinuteSetEnter,
                          &timerMinuteSet,
                          NULL);
State timerSecondSetState(&timerSecondSetEnter,
                          &timerSecondSet,
                          &timerSecondSetExit);
State dimmingSetState(&dimmingSetEnter,
                      &dimmingSet,
                      &dimmingSetExit);
State toneSetState(&toneSetEnter,
                   &toneSet,
                   &toneSetExit);

Fsm UIFsm(&timerDisplayState);

/*
   This function defines all the transitions
   between the different states of the
   finite state machine.
 */
void setTransitions(void)
{
  UIFsm.add_transition(&timerDisplayState,
                       &dimmingDisplayState,
                       cwRot, NULL);
  UIFsm.add_transition(&dimmingDisplayState,
                       &toneDisplayState,
                       cwRot, NULL);
  UIFsm.add_transition(&toneDisplayState,
                       &timerDisplayState,
                       cwRot, NULL);

  UIFsm.add_transition(&timerDisplayState,
                       &toneDisplayState,
                       ccwRot, NULL);
  UIFsm.add_transition(&toneDisplayState,
                       &dimmingDisplayState,
                       ccwRot, NULL);
  UIFsm.add_transition(&dimmingDisplayState,
                       &timerDisplayState,
                       ccwRot, NULL);

  UIFsm.add_transition(&timerDisplayState,
                       &timerHourSetState,
                       longSwitchPress, NULL);
  UIFsm.add_transition(&timerHourSetState,
                       &timerMinuteSetState,
                       shortSwitchPress, NULL);
  UIFsm.add_transition(&timerHourSetState,
                       &timerDisplayState,
                       timeOut, NULL);
  UIFsm.add_transition(&timerMinuteSetState,
                       &timerSecondSetState,
                       shortSwitchPress, NULL);
  UIFsm.add_transition(&timerMinuteSetState,
                       &timerDisplayState,
                       timeOut, NULL);
  UIFsm.add_transition(&timerSecondSetState,
                       &timerDisplayState,
                       shortSwitchPress, NULL);

  UIFsm.add_transition(&dimmingDisplayState,
                       &dimmingSetState,
                       longSwitchPress, NULL);
  UIFsm.add_transition(&dimmingSetState,
                       &dimmingDisplayState,
                       shortSwitchPress, NULL);
  UIFsm.add_transition(&dimmingSetState,
                       &dimmingDisplayState,
                       timeOut, NULL);

  UIFsm.add_transition(&toneDisplayState,
                       &toneSetState,
                       longSwitchPress, NULL);
  UIFsm.add_transition(&toneSetState,
                       &toneDisplayState,
                       shortSwitchPress, NULL);
  UIFsm.add_transition(&toneSetState,
                       &toneDisplayState,
                       timeOut, NULL);
/*
  This is a special transition. It does not
  change the current state, but it calls the
  function toggleTimerRunning when the
  current state is timerDisplayState and the
  user shortly presses the rotary switch. This
  is done to suspend or restart the count 
  when the timer is counting, and to stop the
  beeper after the end of the count.
*/
  UIFsm.add_transition(&timerDisplayState,
                       &timerDisplayState,
                       shortSwitchPress,
                       &toggleTimerRunning);
}

/*
  This function manages the counting of the 
  timer and the beep when the count has
  reached zero.
*/
void timerManagement(void)
{
  static unsigned long memoTime, actualTime;
  static bool toneStarted=false;

  if (timerRunning)
  {
    if(remainingTime==0)
    {
      if((millis()%1000)>500)
      {
        if(toneStarted==false)
        {
          tone(beeperPin,
          toneFrequencies[toneFrequencyIndex]);
          toneStarted=true;
        }
      }
      else
      {
        if(toneStarted==true)
        {
          noTone(beeperPin);
          toneStarted=false;
        }
      }
    }
    else  // remaining time not zero
    {
      actualTime=millis();
      if(actualTime-memoTime>=1000)
      {
        memoTime=actualTime;
        remainingTime--;
      }
    }
  }
}

/*
  This function reads the actions of the user
  on the rotary switch and converts them into
  events.
 */
void rotaryEncoderRead(void)
{
  unsigned long pressedSwitchDelay=0;
  unsigned long pressedSwitchTime=0;
  static unsigned long lastEventTime;
  static bool longPressTreated=false;

  event=noEvent;
  if(digitalRead(rotaryAPin)==LOW)
  {
    if(digitalRead(rotaryBPin)==LOW)
      event=ccwRot;
    else
      event=cwRot;
    while(digitalRead(rotaryAPin)==LOW);
    lastEventTime=millis();
  }
  
  if(digitalRead(rotarySwitchPin)==LOW)
  {
    if (!longPressTreated)
    {
      pressedSwitchTime=millis();
      while(digitalRead(rotarySwitchPin)==LOW
            && (millis()-pressedSwitchTime)<
             longPressTime);
      lastEventTime=millis();
      pressedSwitchDelay=millis()-
                         pressedSwitchTime;
      if(pressedSwitchDelay>=longPressTime)
      {
        event=longSwitchPress;
        longPressTreated=true;
      }
      else if(pressedSwitchDelay>50)
        event=shortSwitchPress;
    }
  }
  else
    longPressTreated=false;
  if(millis()-lastEventTime>maxTime)
    event=timeOut;
}

/*
  The settings of brightness and tone frquency
  are stored into the EEPROM to be kept when
  the power is off. This function is called at
  power on to get these values back. To be sure
  that they are the right ones, the first
  three bytes of the EEPROM must contain "tim".
  If it is not the case, the values are
  replaced by the default values.  
*/
void readEEPROM(void)
{
  if(EEPROM.read(EEPROMId0)==short('t') &&
     EEPROM.read(EEPROMId1)==short('i') &&
     EEPROM.read(EEPROMId2)==short('m'))
  {
    dimming=EEPROM.read(EEPROMDimming);
    toneFrequencyIndex=EEPROM.read(EEPROMTone);
  }
  else
  {   
    EEPROM.update(EEPROMId0, 't');
    EEPROM.update(EEPROMId1, 'i');
    EEPROM.update(EEPROMId2, 'm');
    dimming=5;
    EEPROM.update(EEPROMDimming, dimming);
    toneFrequencyIndex=21;
    EEPROM.update(EEPROMTone,
                  toneFrequencyIndex);
  }
}

void setup()
{
  pinMode(rotaryAPin, INPUT);
  pinMode(rotaryBPin, INPUT);
  pinMode(rotarySwitchPin, INPUT_PULLUP);
  pinMode(beeperPin, OUTPUT);
  digitalWrite(beeperPin, LOW);
  lines[0].reserve(17);
  lines[1].reserve(17);
  lcd.begin(16, 2);
  lcd.clear();
/*
  If the rotary switch is pressed during power
  on, the values in the EEPROM are replaced
  by the default values. This is achived by
  deleting the chain "tim" in the first
  three bytes of the EEPROM.
*/
  if(digitalRead(rotarySwitchPin)==LOW)
  {
    EEPROM.update(EEPROMId0, 0xFF);
    EEPROM.update(EEPROMId1, 0xFF);
    EEPROM.update(EEPROMId2, 0xFF);
  }
  readEEPROM();
  setTransitions();
}

void loop()
{
  rotaryEncoderRead();
  timerManagement();
  UIFsm.run_machine();
  UIFsm.trigger(event);
  analogWrite(backLightPin, dimming*27);
}
[/code]

Credits

frenchy22

6 projects • 3 followers

A User-Friendly Interface in a Simple Timer

Things used in this project

Hardware components

Story

History

User manual of the timer

The hardware

The software

Progressive construction of the state diagram

A special transition

Software implementation

Conclusion

Schematics

Timer schematics

Code

Timer

Credits

frenchy22

Comments

Embed the widget on your own site

A User-Friendly Interface in a Simple Timer

A User-Friendly Interface in a Simple Timer

Things used in this project

Hardware components

Story

History

User manual of the timer

The hardware

The software

Progressive construction of the state diagram

A special transition

Software implementation

Conclusion

Schematics

Timer schematics

Code

Timer

Credits

frenchy22

Comments

Related channels and tags