How to build a very cheap but full featured Sound Card Oscilloscope Build Better Electronics Projects By: Steve Garratt

Arduino Tachometer Software Sketch

<< Arduino Motion Detector

Sound Card Oscilloscope - Build Better Electronics Projects >>

<< Previous First Last

Arduino Tachometer Software Sketch

Click to get the full project details by subscribing free to HDE Magazine.

Copy the code sketch below, paste it into your Arduino programming software and load it into your Arduino to run the tachometer project.

If you haven't done already you may also also need to download the timerOne library from https://code.google.com/p/arduino-timerone/downloads/detail?name=TimerOne-v9.zip&can=2&q=

Install the library using the guide https://arduino.cc/en/Guide/Libraries

/*******************************************************

Arduino stroboscopic tachometer RPM meter
 
strobe_1
Arduino Uno + 2 x 16 LCD display

14th April 2014
********************************************************/
#include <LiquidCrystal.h>                            // LCD module
#include <TimerOne.h>                                 // Header file for TimerOne library
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);                  // select the pins used on the LCD panel
 
// define some values used by the panel and buttons
#define led1Pin 12                                    // Pin 12 LED 1

// Define constants for button presses
#define btnRIGHT  0                                   // Right
#define btnUP     1                                   // Up
#define btnDOWN   2                                   // Down
#define btnLEFT   3                                   // Left
#define btnSELECT 4                                   // Select
#define btnNONE   5                                   // None. No button pressed

#define TIMER_US 50                                   // 50 uS timer tick duration 
volatile int pulse_percent = 1;                       // Pulse as percentage of repetition duration
volatile int pulse_counts;                            // Ticks in each pulse
volatile int pulse_time_count = 0;                    // Pulse tick counter
volatile int repetition_counts;                       // Ticks between strobe pulses
volatile int rpm_demand;                              // Entered speed demand in RPM
volatile int repetition_time_count = 0;               // Pulse repetition tick counter
int display_mode = 0;                                 // Determine what the display does

// --------------------------
// setup() 
// Initialize i/o pins.
// Initialize the timer and attach interrupt.
// Initialize the LCD.
// Start initial display mode.
// --------------------------
void setup()
{
  int i, zone_diff;
  
  pinMode(led1Pin, OUTPUT);                           // LED 1 pin set to output
  
  Timer1.initialize(TIMER_US);                        // Initialise timer 1
  Timer1.attachInterrupt(timerIsr);                   // Attach interrupt to the timer service routine

lcd.begin(16, 2);                                   // start the LCD library
  
  setup_display_rpm_mode();                           // Initialise display mode
  set_rpm_demand();                                   // Initialise pulse variables
  clear_display();
  /* Debugging output to serial monitor port
  Serial.begin(9600);
  ******************** */
}

// --------------------------
// set_rpm_demand() 
//
// Compute the pulse and repetition parameters.
// --------------------------
int set_rpm_demand()
{
  repetition_counts = get_repetition_counts();        // Compute ticks per repetition
  repetition_time_count = repetition_counts;          // Load repetition timer ticks
  pulse_counts = get_pulse_counts();                  // Compute length of pulse in ticks
  pulse_time_count = pulse_counts;                    // Load pulse length timer
}

// --------------------------
// display_rpm_mode() 
//
// Refresh the display.
// --------------------------
int display_rpm_mode()
{
   lcd.setCursor(0, 0);                               // Set the cursor at the start of the top line
   lcd.print(" ");                                    // Display the strobe repetition rate in RPM
   display_5_digits(rpm_demand);
   lcd.print(" rpm ");
   //display_5_digits(repetition_counts);             // Debugging: Display the repetition tick value           
   lcd.setCursor(0, 1);                               // Set the cursor at the start of the bottom line
   
   switch(display_mode)                               // Show display mode as
   {                                                  
     case 0:                                          // 'P' - Potentiometer input mode
       lcd.print("P");
       break;
     case 1:                                          // 'K' - Keypad input mode
       lcd.print("K");
       break;
   }
   
   display_5_digits(pulse_percent);                   // Display pulse length as percentage of rate
   lcd.print(" % ");
   //display_5_digits(pulse_counts);                  // Debugging: Display pulse length in ticks
}

// --------------------------
// display_5_digits(val) 
//
// Print a +ve 5 digit value to the display.
// Printed right justified.
// --------------------------
void display_5_digits(int val)
{
  if (val < 10000) 
  {                                                  // Print appropriate number of
    lcd.print(" ");                                  // spaces depending on value
    if (val < 1000) 
    {
      lcd.print(" ");
    }
    if (val < 100) 
    {
      lcd.print(" ");
    }
    if (val < 10) 
    {
      lcd.print(" ");
    }
  }
 
  lcd.print(val);                                    // Print the value
}

// --------------------------
// setup_display_rpm_mode() 
//
// Initialise the display mode
// --------------------------
int setup_display_rpm_mode()
{
  display_mode = 0;                                   // Potentiometer mode 
}

// --------------------------
// get_pulse_counts() 
//
// Compute the timer counts for pulse duration.
// --------------------------
int get_pulse_counts()
{
  return int((float(pulse_percent) * float(repetition_counts)) / 100);  // Compute length of pulse
}

// --------------------------
// get_repetition_counts() 
// Compute the timer counts for pulse repetition.
// --------------------------
int get_repetition_counts()
{
  return int((60000000.0 / (float(rpm_demand) * float(TIMER_US))) );  // Compute pulse repetition rate ticks
}

// --------------------------
// loop() 
// Main loop. 
// Keypad buttons are serviced every 50mS.
// Display is updated every 500mS.
// --------------------------
void loop()
{
  static unsigned long print_timer = 0;               // For scheduling LCD updates
  static unsigned long button_timer = 0;              // For scheduling button polling

if ((millis() - button_timer) > 50)                 // Is it time to check the buttons?
  {
    button_timer = millis();                          // Reset the timer
    
    switch(display_mode)                              
    {                                                 
      case 0:
        do_button_input_p();                          // Hande user input from potentiometer
        break;
      case 1:
        do_button_input_k();                          // Handle user input on buttons
       break;
    }
  }
  
  if ((millis() - print_timer) > 500)                 // Is it time to update the display?
  {
    print_timer = millis();                           // Reset the timer

switch(display_mode)                              
    {                                                 
      case 0:
        do_speed_pot_input();                         // Handle speed demand pot
        break;
      case 1:
       break;
    }
        
    display_rpm_mode();                               // Show rpm and pulse values
  }
}

// --------------------------
// clear_display() 
//
// Clear the display.
// --------------------------
void clear_display()
{
  char* blank = "                ";
  lcd.setCursor(0, 0);                                // Clear the top row;
  lcd.print(blank);                      
  lcd.setCursor(0, 1);                                // Clear the bottom row;
  lcd.print(blank);                      
}
 
// --------------------------
// timerIsr() 50uS interrupt routine
// Called every time the hardware timer 1 times out.
// --------------------------
void timerIsr()
{
    pulse_manager();                                  // Handle the strobe pulses
}

// --------------------------
// pulse_manager() called every 50 uS to schedule and deliver pulses.
// --------------------------
void pulse_manager()
{
      static volatile int state = 0;                      // State machine variable
      
      --repetition_time_count;                            // Must decrement the repetition count every tick

switch(state)                                       // State machine handles delivery of
      {                                                   // a regularly repeating pulse
        case 0:                                           // Normal state does nothing
           if (repetition_time_count <= 0)                // Time to do a pulse?
           {                                              // Time out - Initiate pulse
             repetition_time_count = repetition_counts;   // Reload for the next pulse
             digitalWrite(led1Pin, HIGH);                 // Set the strobe output high
             pulse_time_count = pulse_counts;             // Load pulse length timer
             state = 1;                                   // Changing to state 1 initiates a pulse
           }
           break;
        
        case 1:                                           // Initiate pulse
           if (--pulse_time_count <= 0)                   // Time to end the pulse?
           {                                              // Time out - terminate the pulse
             digitalWrite(led1Pin, LOW);                  // Set the strobe output low
             state = 0;                                   // and set state to 0
           }
           break;
        
        default:      
            state = 0;                                    // Return state to normal 0
           break;
     }
}

// --------------------------
// read_LCD_buttons() 
// Read the buttons on the LCD mini keypad.
// The buttons are all wired through resistors to an
// analog input channel so which button has been pressed
// can be determined by the value read from the input.
// 
// Note: It may be neccessary to calibrate the keypad input as
//       voltages on your board may differ from those used here.
//       my buttons when read are centered at these valies: 0, 100, 250, 410, 640
//       we add approx 50 to those values and check to see if we are close
// --------------------------
int read_LCD_buttons()
{
  int adc_key_in;
 
  adc_key_in = analogRead(0);                          // read the value from the sensor
  
  // Debug code - Uncomment this to send the key value to the serial monitor for calibration.
  /* *******************************
  Serial.println(adc_key_in);
  Debug code End **************** */
  
                                                       // Each key will read a different value.
  if (adc_key_in > 1000) return btnNONE;               // 1st option for speed reasons since it will be the most likely result.
 
  if (adc_key_in < 50)   return btnRIGHT; 
  if (adc_key_in < 150)  return btnUP;
  if (adc_key_in < 300)  return btnDOWN;
  if (adc_key_in < 460)  return btnLEFT;
  if (adc_key_in < 690)  return btnSELECT; 
 
  return btnNONE;                                      // When all others fail, return this...
}

// --------------------------
// do_speed_pot_input() 
// Read the analog speed pot
// --------------------------
void do_speed_pot_input()
{
    static int last_speed_pot_in = 0;
    int speed_pot_in;
    
    speed_pot_in = analogRead(1);                     // Read the value from the control
    //Serial.println(speed_pot_in);
    
    if (speed_pot_in != last_speed_pot_in)            // Action only if the value changes
    {
      last_speed_pot_in = speed_pot_in;               // Save value for next reading
      rpm_demand = (speed_pot_in + 16) * 4;           // Roughly 64 - 4156 rpm
      set_rpm_demand();                               // Compute and set parameters
    }
}

// --------------------------
// do_button_input_k() 
// Read the buttons on the LCD mini keypad.
// Determine and take appropriate action.
// The buttons are debounced using a simple finite state
// machine which requires the routine to be called frequently.
//
// The debug code prints the state transitions to the serial monitor.
// --------------------------
void do_button_input_k()
{
  int button_down; 
  static int button_state = 0;                         // Initialise the state machine to state 0
  static unsigned long int auto_repeat;                // Repeat if button down
  static unsigned long down_timer;                     // For scheduling button polling

button_down = read_LCD_buttons();                    // Read the keypad
  
  switch(button_state)                                 // Begin the finite state machine key debouncer
  {
    case 0:                                            // 0 - idle state. No buttons being pressed.
      if (button_down != btnNONE)                      // Is a button down?
      {
        down_timer = millis();                         // Start the button down timer
        auto_repeat = millis();                        // Start the auto repeat timer
        button_state = 1;                              // Go to state 1 to begin the debounce
       }
      break;
      
    case 1:                                            // 1 A button was down
      if (button_down == btnSELECT)
      {                                                // Select changes mode
        button_state = 3;                              // Mode changes in state 3
        break;
      }

if (button_down == btnUP)
      {                                                // Nudge rpm demand up
        rpm_demand++;
      }

if(rpm_demand > 30000)
      {                                                // Limit the maximum value
        rpm_demand = 30000;
      }
      
      if (button_down == btnDOWN)
      {                                                // Nudge rpm demand down
        rpm_demand--;
      }

if(rpm_demand < 60)
      {                                                // Limit the minimum value
        rpm_demand = 60;
      }

if (button_down == btnRIGHT)
      {                                                // Nudge the duty cycle up
        pulse_percent++;
      }
      
      if (pulse_percent > 50)
      {                                               // Limit maximum duty cycle
        pulse_percent = 50;
      }
      
      if (button_down == btnLEFT)
      {                                                // Nudge the duty cycle down
        pulse_percent--;
      }

if (pulse_percent < 1)
      {                                               // Limit minimum duty cycle
        pulse_percent = 1;
      }

set_rpm_demand();                               // Set the new parameters

button_state = 2;                              // Go to state 2 to wait for no button down
      break;
      
    case 2:                                          // 2 Waiting for btnNONE ensures no further action
      if (button_down == btnNONE)                    // until the button is released and pushed again.
      {
        button_state = 0;
      }
      else
      {
        if ((millis() - auto_repeat) > 500)            // Auto repeat after timout
        {
           auto_repeat = millis();
           button_state = 1;
        }
      }
      break;
      
    case 3:
      if (button_down == btnNONE)                    // When button released
      {  
        display_mode = 0;                            // Set potentiometer mode
        button_state = 0;                            // Back to idle state
      }
      break;
        
  }
}

// --------------------------
// do_button_input_p() 
//
// Takes rpm input from the potentiometer
// --------------------------
void do_button_input_p()
{
  int button_down; 
  static int button_state = 0;                         // Initialise the state machine to state 0

button_down = read_LCD_buttons();                    // Read the keypad

switch(button_state)                                 // Begin the finite state machine key debouncer
  {
    case 0:                                            // 0 - Idle state. No buttons being pressed.
      if (button_down != btnNONE)
      {
        button_state = 1;                              // Go to state 1 to begin the debounce
      }
      break;
      
    case 1:                                            // 1 A button was down
      if (button_down == btnSELECT)                    // If it's the select button
      {
        button_state = 2;                              // Go to state 2 to wait for no button down
      }
      else
      {
        button_state = 0;                              // Back to idle
      }

break;

case 2:
      if (button_down == btnNONE)
      {
        display_mode = 1;                              // Change to keypad input mode
        button_state = 0;                              // Back to idle
      }
      break;
      
  }
}

Arduino Tachometer

<< Previous First Last

Now subscribe to our newsletter and don't miss a thing

Tagged: Arduino Arduino Tachometer Tachometer Arduino Uno Arduino Software Arduino Sketch Strobe