Build a DIY Oscilloscope using Arduino Nano and OLED Display

//-----------------------------------------------------------------------------

// Copyright 2018 Peter Balch

// subject to the GNU General Public License

//   displays samples on SH1106 screen as an oscilloscope

//-----------------------------------------------------------------------------

#include <Wire.h>

#include <limits.h>

#include "SimpleSH1106.h"

#include <math.h>

//-----------------------------------------------------------------------------

// Defines and Typedefs

//-----------------------------------------------------------------------------

// get register bit - faster: doesn't turn it into 0/1

#ifndef getBit

#define getBit(sfr, bit) (_SFR_BYTE(sfr) & _BV(bit))

#endif

enum Tmode {DC5V, AC500mV, AC100mV, AC20mV,

            mLogic,

            mVoltmeter,

            maxMode1

           };

const Tmode maxMode = maxMode1 - 1;

enum TmenuSel {sTime, sMode, sTrigger, sTestSig, sSigGen};

//-----------------------------------------------------------------------------

// Global Constants

//-----------------------------------------------------------------------------

bool bHasLogic = true;

bool bHasFreq = true;

bool bHasVoltmeter = true;

bool bHasTestSignal = true;

bool bHasSigGen = false;

const long BAUDRATE  = 115200;  // Baud rate of UART in bps

const int COMMANDDELAY  = 10;  // ms to wait for the filling of Serial buffer

const int COMBUFFERSIZE = 4; // Size of buffer for incoming numbers

const int testSignalPin = 3;

const char ack = '@'; // acknowledge for comms command

const byte SampPerA = 5 + 6; // 6 nops

#define LoopNops __asm__("nop\n nop\n nop\n nop\n nop\n nop\n")

const int SampPerB = 20;

const int BtnHorz = 4; // pushbutton

const int BtnVert = 7; // pushbutton

const int FreeRunTimeout = 0x10; // 0.5 sec for free run

//-----------------------------------------------------------------------------

// Global Variables

//-----------------------------------------------------------------------------

Tmode curMode = DC5V;

uint8_t curVref = 1;

uint8_t curPeriod = 200;

uint8_t curPrescaler = 7;

char commandBuffer[COMBUFFERSIZE + 1];

bool TrigFalling = true;

uint8_t curSweep = 0;

byte yGraticulePage0, yGraticuleByte0, yGraticulePage1, yGraticuleByte1, yGraticulePage2, yGraticuleByte2;

byte* pxGratLabel;

byte* pyGratLabel;

byte xGratLabelLen, yGratLabelLen;

byte yGraticule0, yGraticule1, yGraticule2, xGraticule1, xGraticule2;

TmenuSel sel = sTime; // for main menu

byte adj[4] = {0, 0, 0, 0}; // for main menu

bool SendingSerial = false;

int curPwmMode = 0;

const int ADCBUFFERSIZE = 128;

uint8_t ADCBuffer[ADCBUFFERSIZE];

int ButtonsTimer1 = 0;

long Vin = 0; // used to display Voltmeter

//-----------------------------------------------------------------------------

// globals used in SigGen

//-----------------------------------------------------------------------------

const byte numberOfDigits = 6; // number of digits in the frequency

byte freqSGLo[numberOfDigits] = {0, 0, 0, 1, 0, 0}; // 1000Hz SelSG = 0..numberOfDigits-1

byte freqSGHi[numberOfDigits] = {0, 0, 0, 0, 2, 0}; // 20kHz  SelSG = numberOfDigits..2*numberOfDigits-1

byte SelSG = numberOfDigits-1;

const byte SelSGSweep = 2*numberOfDigits;

const byte SelSGSine = 2*numberOfDigits+1;

const int wSine     = 0b0000000000000000;

const int wTriangle = 0b0000000000000010;

const int wSquare   = 0b0000000000101000;

enum TsweepType {swOff,sw20Frames,sw100Frames,sw500Frames,sw1Sec,sw5Sec,sw20Sec};

int waveType = wSine;

TsweepType sweepType = swOff;

const int SG_fsyncPin = 2;

const int SG_CLK = 13;

const int SG_DATA = 12;

int SG_iSweep,SG_nSweep;

//-----------------------------------------------------------------------------

// globals used in frequency counter

//-----------------------------------------------------------------------------

volatile boolean FC_OneSec;

volatile boolean FC_firstAC;

volatile unsigned long FC_overflowCount;

volatile unsigned long FC_MaxPeriodAC;

unsigned long FC_Timeout = 0;

unsigned long FC_freq;

const int ACfreqAdcPin = 3;

const int FC_LogicPeriod = 1006; // mS   slightly longer than 1 Sec for calibration

//-----------------------------------------------------------------------------

// labels for graticule

//-----------------------------------------------------------------------------

const int R1 = 100;

const int R2 = 27;

const byte ax2V[] = {98, 81, 73, 70, 0, 3, 28, 96, 28, 3};

const byte ax4V[] = {24, 22, 127, 16, 0, 3, 28, 96, 28, 3};

const byte ax0_1[] = {62, 65, 65, 62, 0, 64, 0, 2, 127 };

const byte ax0_2[] = {62, 65, 65, 62, 0, 64, 0, 98, 81, 73, 70 };

const byte ax0_4[] = {62, 65, 65, 62, 0, 64, 0, 24, 22, 127, 16 };

const byte ax0_5[] = {62, 65, 65, 62, 0, 64, 0, 47, 69, 69, 57};

const byte ax1[] = {2, 127 };

const byte ax2[] = {98, 81, 73, 70 };

const byte ax4[] = {24, 22, 127, 16 };

const byte ax5[] = {47, 69, 69, 57};

const byte ax10[] = {2, 127, 0, 62, 65, 65, 62 };

const byte ax20[] = {98, 81, 73, 70, 0, 62, 65, 65, 62 };

//-----------------------------------------------------------------------------

// images for main menu

//-----------------------------------------------------------------------------

const byte imgMainMenuTop[] PROGMEM = {

  128, // width

  2, // pages

  1, 224, 147, 32, 130, 0, 3, 248, 252, 6, 130, 2, 3, 6, 252, 248, 130, 0, 2, 96, 240, 130, 144, 2, 176, 32, 130, 0, 2, 224, 240, 130,

  16, 3, 48, 32, 0, 130, 246, 130, 0, 130, 254, 130, 0, 130, 254, 130, 0, 2, 224, 240, 130, 16, 2, 240, 224, 130, 0, 2, 96, 240, 130,

  144, 2, 176, 32, 130, 0, 2, 224, 240, 130, 16, 5, 48, 32, 0, 224, 240, 130, 16, 2, 240, 224, 130, 0, 130, 240, 130, 16, 2, 240, 224,

  130, 0, 2, 224, 240, 130, 80, 2, 112, 96, 130, 0, 149, 32, 2, 224, 255, 149, 0, 3, 1, 3, 6, 130, 4, 3, 6, 3, 1, 130, 0, 2, 2, 6, 130,

  4, 2, 7, 3, 130, 0, 2, 3, 7, 130, 4, 3, 6, 2, 0, 130, 7, 130, 0, 130, 7, 130, 0, 130, 7, 130, 0, 2, 3, 7, 130, 4, 2, 7, 3, 130, 0, 2, 2, 6,

  130, 4, 2, 7, 3, 130, 0, 2, 3, 7, 130, 4, 5, 6, 2, 0, 3, 7, 130, 4, 2, 7, 3, 130, 0, 130, 63, 130, 4, 2, 7, 3, 130, 0, 2, 3, 7, 130, 4, 2,

  6, 2, 151, 0, 1, 255

};

const byte imgMainMenuMid[] PROGMEM = {

  128, // width

  1, // pages

  1, 255, 254, 0, 1, 255

};

const byte imgMainMenuBot[] PROGMEM = {

  128, // width

  1, // pages

  1, 255, 254, 128, 1, 255

};

const byte imgBoxTop[] PROGMEM = {

  128, // width

  1, // pages

  1, 248, 254, 8, 1, 248

};

const byte imgCaret1[] PROGMEM = {

  4, // width

  1, // pages

  4, 255, 126, 60, 24

};

const byte imgCaret2[] PROGMEM = {

  7, // width

  1, // pages

  7, 32, 48, 56, 60, 56, 48, 32

};

const byte imgTrian[] PROGMEM = {

  14, // width

  2, // pages

  28, 3,12,48,192,0,0,0,0,0,0,192,48,12,3,128,128,128,128,131,140,176,176,140,131,128,128,128,128};

const byte imgSine[] PROGMEM = {

  14, // width

  2, // pages

  28, 1,2,28,224,0,0,0,0,0,0,224,28,2,1,128,128,128,129,142,144,160,160,144,142,129,128,128,128};

const byte imgSquare[] PROGMEM = {

  14, // width

  2, // pages

  28, 0,0,0,255,1,1,1,1,1,1,255,0,0,0,160,160,160,191,128,128,128,128,128,128,191,160,160,160};

//-----------------------------------------------------------------------------

// FillBar

//   fills the bits of a screen column from bit y1 to bit y2

//   makes a bar that must be part of 'page'

//   returns the bar

//-----------------------------------------------------------------------------

byte FillBar(byte y1, byte y2, byte page) {

  static byte lob[] = {0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};

  byte bar;

  if (page == y1 / 8) {

    if (page == y2 / 8)

      bar = lob[(y2 & 7) + 1];

    else

      bar = 0xFF;

    return bar - lob[y1 & 7];

  }

  else if (page == y2 / 8)

    return lob[(y2 & 7) + 1];

  else if ((page > y1 / 8) & (page < y2 / 8))

    return 0xFF;

  else

    return 0;

}

//-----------------------------------------------------------------------------

// drawBox

//   draws a box around the screen with s written aat top-left

//-----------------------------------------------------------------------------

void drawBox(char* s) {

  //      clearSH1106();

  DrawImageSH1106(0, 0, imgBoxTop);

  for (int i = 1; i < 7; i++)

    DrawImageSH1106(0, i, imgMainMenuMid);

  DrawImageSH1106(0, 7, imgMainMenuBot);

  DrawCharSH1106(' ',  6, 0, SmallFont);

  DrawStringSH1106(s,  7, 0, SmallFont);

}

//-----------------------------------------------------------------------------

// drawScreen

//   draws a graph like an oscilloscope

//   takes about 40mS

//-----------------------------------------------------------------------------

void drawScreen(void) {

  byte i, j, k, y, yPrev, bar, page, lastDrawn;

  byte* pxbz;

  byte* pybz;

  byte pxlenz, pylenz;

  switch (curMode) {

    case mVoltmeter:

      drawBox("Voltmeter");

      i = 20;

      if (Vin == LONG_MAX)

        DrawStringSH1106("++++",  i, 3, LargeDigitsFont);

      else if (Vin == -LONG_MAX)

        DrawStringSH1106("----",  i, 3, LargeDigitsFont);

      else {

        i += DrawIntDP2(Vin / 10,  i, 3, LargeDigitsFont);

        DrawStringSH1106("Volts",  i, 4, SmallFont);

      }

      return;

    case AC100mV:

      for ( i = 0; i < ADCBUFFERSIZE; i++ )

        ADCBuffer[i] = ADCBuffer[i] / 4;

      break;

    default:

      for ( i = 0; i < ADCBUFFERSIZE; i++ )

        ADCBuffer[i] = 63 - ADCBuffer[i] / 4;

  }

  if ((curPeriod == 0) && (curMode <= AC20mV)) {

    yPrev = ADCBuffer[0];

    y = ADCBuffer[1];

    for ( i = 1; i < ADCBUFFERSIZE - 1; i++ ) {

      ADCBuffer[i] = (yPrev + y + ADCBuffer[i + 1]) / 3;

      yPrev = y;

      y = ADCBuffer[i + 1];

    }

  }

  pxbz = pxGratLabel;

  pxlenz = xGratLabelLen;

  pybz = pyGratLabel;

  pylenz = yGratLabelLen;

  for (page = 0; page <= 7; page++) {

    yPrev = ADCBuffer[0];

    lastDrawn = 255;

    setupPage(page);

    setupCol(0);

    Wire.beginTransmission(addr);

    Wire.write(0x40); // the following bytes are data

    for (i = 0; i < ADCBUFFERSIZE; i++) {

      if (i % 26 == 0) {

        Wire.endTransmission();

        Wire.beginTransmission(addr);

        Wire.write(0x40); // the following bytes are data

      }

      y = ADCBuffer[i];

        if (yPrev > y + 1) {

          if (yPrev == lastDrawn)

            yPrev--;

          bar = FillBar(y + 1, yPrev, page);

          lastDrawn = yPrev + 1;

        } else {

          bar = FillBar(yPrev, yPrev, page);

          lastDrawn = yPrev;

        }

     // }

      if ((page == 0) && (bar == 0x01) && (i & 1))

        bar = 0;

      if ((page == 7) && (bar == 0x80) && (i & 1))

        bar = 0;

      if (page == yGraticulePage0) {

        if (i & 8)

          bar = bar | yGraticuleByte0;

      }

      else if (page == yGraticulePage1) {

        if (i < pylenz)

        {

          bar |= *pybz;

          pybz++;

        }

        else if (i % 4 == 0)

          bar |= yGraticuleByte1;

      }

      else if (page == yGraticulePage2) {

        if (i % 4 == 0)

          bar |= yGraticuleByte2;

      }

      if ((i == xGraticule1) | (i == xGraticule2))

        bar = bar | 0x22;

      if ((page == 7) && (i > xGraticule2 - pxlenz - 2) && (i < xGraticule2 - 1)) {

        bar |= *pxbz;

        pxbz++;

      }

      Wire.write(bar);

      yPrev = y;

    }

    Wire.endTransmission();

  }

}

//-----------------------------------------------------------------------------

// initADC()

//-----------------------------------------------------------------------------

void initADC(void) {

  if (curMode > AC20mV)

    return;

  ACSR = 0x10;

  ADCSRA = 0x97;

  ADCSRB = 0x0 ; //ADC Control and Status Register B

  // 0 Bit 6 – ACME: Analog Comparator Multiplexer Enable

  // 000 Bits 2:0 – ADTSn: ADC Auto Trigger Source [n = 2:0] Free Running mode

  ADMUX = 0x20 + (curVref << 6) + curMode; // ADC Multiplexer Selection Register

  // rr    Bits 7:6 – REFSn: Reference Selection = Vcc

  // 1     Bit 5 – ADLAR: ADC Left Adjust Result

  // aaaa  Bits 3:0 – MUXn: Analog Channel Selection

  DIDR0 = 0x3F; // Digital Input Disable Register 0

  // ADC0D=1, ADC1D=1, ADC2D=1, ADC3D=1, ADC4D=1, ADC5D=1, ADC6D=0, ADC7D=0

}

//-----------------------------------------------------------------------------

// printStatus

//   print various register values

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// setPwmFrequency

//        timer  mode=1     mode=2     mode=3      mode=4       mode=5        mode=6       mode=7

// pin=5    0    f=62500/1  f=62500/8  f=62500/64  f=62500/256  f=62500/1024

// pin=6    0    f=62500/1  f=62500/8  f=62500/64  f=62500/256  f=62500/1024

// pin=9    1    f=31250/1  f=31250/8  f=31250/64  f=31250/256  f=31250/1024

// pin=10   1    f=31250/1  f=31250/8  f=31250/64  f=31250/256  f=31250/1024

// pin=3    2    f=31250/1  f=31250/8  f=31250/32  f=31250/64   f=31250/128   f=31250/256  f=31250/1024

// pin=11   2    f=31250/1  f=31250/8  f=31250/32  f=31250/64   f=31250/128   f=31250/256  f=31250/1024

//-----------------------------------------------------------------------------

void setPwmFrequency(int pin, byte mode) {

  SendAck();

  curPwmMode = mode;

  if (mode == 0) {

    analogWrite(pin, 0);

  } else {

    analogWrite(pin, 128);

    if (pin == 5 || pin == 6 || pin == 9 || pin == 10) {

      if (pin == 5 || pin == 6) {

        TCCR0B = TCCR0B & 0b11111000 | mode;

      } else {

        TCCR1B = TCCR1B & 0b11111000 | mode;

      }

    } else if (pin == 3 || pin == 11) {

      TCCR2B = TCCR2B & 0b11111000 | mode;

    }

  }

}

//-----------------------------------------------------------------------------

// StartTimer1

// TIFR1 becomes non-zero after

//    overflow*1024/16000000 sec

//-----------------------------------------------------------------------------

void StartTimer1(word overflow) {

  TCCR1A = 0xC0; // Set OC1A on Compare Match

  TCCR1B = 0x05; // prescaler = 1024

  TCCR1C = 0x00; // no pwm output

  OCR1AH = highByte(overflow);

  OCR1AL = lowByte(overflow);

  OCR1BH = 0;

  OCR1BL = 0;

  TIMSK1 = 0x00; // no interrupts

  TCNT1H = 0; // must be written first

  TCNT1L = 0; // clear the counter

  TIFR1 = 0xFF; // clear all flags

}

//-----------------------------------------------------------------------------

// SendAck

//   if sending serial then send @

//-----------------------------------------------------------------------------

void SendAck(void) {

  if (SendingSerial)

    Serial.print(ack);

}

//-----------------------------------------------------------------------------

// readVcc

//    result in mV

//-----------------------------------------------------------------------------

long readVcc(void) {

  long result;

  ACSR = 0x10;

  ADCSRA = 0x97;

  ADCSRB = 0x0;

  // Read 1.1V reference against AVcc

  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);

  myDelay(2);

  ADCSRA |= _BV(ADSC); // Convert

  while (bit_is_set(ADCSRA, ADSC));

  result = ADCL;

  result |= ADCH << 8;

  result = 1125300L / result; // Back-calculate AVcc in mV

  initADC(); // to set up for next sweep

  return result;

}

void GetADCSamples(void) {

  uint8_t d;

  uint8_t* p;

  const int hysteresis = 2;

  bool Trig;

  Trig = TrigFalling ^ (curMode != AC100mV);

  initADC();

  ADCSRA = 0x80 + (curPrescaler & 7); // ADC Control and Status Register A

  // 1   Bit 7 – ADEN: ADC Enable

  // 0   Bit 6 – ADSC: ADC Start Conversion

  // 0   Bit 5 – ADATE: ADC Auto Trigger Enable

  // 0   Bit 4 – ADIF: ADC Interrupt Flag

  // 0   Bit 3 – ADIE: ADC Interrupt Enable

  // nnn Bits 2:0 – ADPSn: ADC Prescaler Select [n = 2:0]

  StartTimer1(0); // no timeout

  for (d = 0; d < 10; d++ ) { // make sure ADC is running

    bitSet(ADCSRA, ADSC); // start ADC conversion

    while (!getBit(ADCSRA, ADIF)) ; // wait for ADC

    bitSet(ADCSRA, ADIF); // clear the flag

  }

  if (curPeriod == 0) { // 1Msps

    while (Trig ? (ADCH >= 0x80 - hysteresis) : (ADCH < 0x80 + hysteresis)) {

      d = TCNT1L; // to force read of TCNT1H

      if (TCNT1H > FreeRunTimeout) goto freeRunFast;

      bitSet(ADCSRA, ADSC);

    }

    while (Trig ? (ADCH < 0x80 + hysteresis) : (ADCH >= 0x80 - hysteresis)) {

      d = TCNT1L; // to force read of TCNT1H

      if (TCNT1H > FreeRunTimeout) goto freeRunFast;

      bitSet(ADCSRA, ADSC);

    }

freeRunFast:

    for (p = ADCBuffer; p < ADCBuffer + ADCBUFFERSIZE; p++ ) {

      *p = ADCH;

      __asm__("nop"); // pad it to 16 instructions

      __asm__("nop"); // pad it to 16 instructions

      bitSet(ADCSRA, ADSC);

    }

  } else { // slower than 1Msps

    do { // wait for comparator low

      bitSet(ADCSRA, ADSC); // start ADC conversion

      for (d = 0; d < curPeriod; d++ )

        LoopNops;

      d = TCNT1L; // to force read of TCNT1H

      if (TCNT1H > FreeRunTimeout) goto freeRunSlow;

    } while (Trig ? (ADCH >= 0x80 - hysteresis) : (ADCH < 0x80 + hysteresis));

    do { // wait for comparator high

      bitSet(ADCSRA, ADSC); // start ADC conversion

      for (d = 0; d < curPeriod; d++ )

        LoopNops;

      d = TCNT1L; // to force read of TCNT1H

      if (TCNT1H > FreeRunTimeout) goto freeRunSlow;

    } while (Trig ? (ADCH < 0x80 + hysteresis) : (ADCH >= 0x80 - hysteresis));

freeRunSlow:

    bitSet(ADCSRA, ADSC); // start ADC conversion

    for ( p = ADCBuffer; p < ADCBuffer + ADCBUFFERSIZE; p++ ) {

      for (d = 0; d < curPeriod; d++ )

        LoopNops;

      *p = ADCH;

      bitSet(ADCSRA, ADSC); // start ADC conversion

    }

  }

}

//-----------------------------------------------------------------------------

// SendADC

//   uses curPrescaler,curPeriod,curMode,curVref

//

//   read and Tx a buffer-full of samples

//   prescaler

//     7 128

//     6 64

//     5 32

//     4 16

//     3 8

//     2 4

//     1 2

//     0 2

//   period: sample period

//     0:  16 clocks

//     n:  n*SampPerA+SampPerB clocks

//-----------------------------------------------------------------------------

void SendADC() {

  memset( (void *)ADCBuffer, 0, sizeof(ADCBuffer) );

  noInterrupts();

//  if (curMode == mLogic)

//    GetLogicSamples();

//  else

GetADCSamples();

  interrupts();

  digitalWrite(LED_BUILTIN, HIGH);

  if (SendingSerial) {

    Serial.write((uint8_t)0xAA);

    Serial.write((uint8_t)0xBB);

    Serial.write((uint8_t)0xCC);

    Serial.write((uint8_t *)ADCBuffer, ADCBUFFERSIZE);

  }

  drawScreen();

  digitalWrite(LED_BUILTIN, LOW);

  int t = TCNT1L; // to force read of TCNT1H

  ButtonsTimer1 += TCNT1H;

}

//-----------------------------------------------------------------------------

// setSweep

// set period and ADC prescaler

//-----------------------------------------------------------------------------

void setSweep(byte Sweep) {

  int x;

  long t;

  if (Sweep == 255) {

    if (curSweep == 0)

      curSweep = 6;

    else

      curSweep--;

  } else

    curSweep = Sweep;

  switch (curSweep) {

    case 0: curPeriod = 0;   curPrescaler = 2; t = 100;   pxGratLabel = &ax0_1[0]; xGratLabelLen = sizeof(ax0_1); break;

    case 1: curPeriod = 4;   curPrescaler = 2; t = 400;   pxGratLabel = &ax0_4[0]; xGratLabelLen = sizeof(ax0_4); break;

    case 2: curPeriod = 11;  curPrescaler = 3; t = 1000;  pxGratLabel = &ax1[0];   xGratLabelLen = sizeof(ax1);   break;

    case 3: curPeriod = 24;  curPrescaler = 3; t = 2000;  pxGratLabel = &ax2[0];   xGratLabelLen = sizeof(ax2);   break;

    case 4: curPeriod = 62;  curPrescaler = 4; t = 5000;  pxGratLabel = &ax5[0];   xGratLabelLen = sizeof(ax5);   break;

    case 5: curPeriod = 125; curPrescaler = 4; t = 10000; pxGratLabel = &ax10[0];  xGratLabelLen = sizeof(ax10);  break;

    case 6: curPeriod = 255; curPrescaler = 5; t = 20000; pxGratLabel = &ax20[0];  xGratLabelLen = sizeof(ax20);  break;

  }

  if (curSweep == 0)

    x = t;

  else

    x = 16 * t / (curPeriod * SampPerA + SampPerB);

  xGraticule1 = x / 2;

  xGraticule2 = x;

  SendAck();

}

//-----------------------------------------------------------------------------

// incMode

//   increment Mode

//   wrap around from max

//   skip over modes that are not allowed

//-----------------------------------------------------------------------------

int incMode(int mode) {

  mode++;

//if ((mode == mLogic)     && (!bHasLogic)) mode++;

//  if ((mode == mFreqLogic) && ((!bHasFreq) || (!bHasLogic))) mode++;

//  if ((mode == mFreqAC)    && (!bHasFreq)) mode++;

  if ((mode == mVoltmeter) && (!bHasVoltmeter)) mode++;

  if (mode > maxMode)

    return DC5V;

  else

    return mode;

}

//-----------------------------------------------------------------------------

// setMode

// set mode and Vref

//-----------------------------------------------------------------------------

void setMode(int mode) {

  int i;

  if (mode == 255) {

    curMode = incMode(curMode);

  } else

    curMode = mode;

  switch (curMode) {

    case DC5V:

      curVref = 1;

      i = (long)4000 * 64 / readVcc();

      if (i <= 63) {

        yGraticule1 = 63 - i;

        yGraticule2 = 63 - i / 2;

        yGraticule0 = 255;

        pyGratLabel = &ax4V[0];

        yGratLabelLen = sizeof(ax4V);

      } else {

        yGraticule2 = 63 - i;

        yGraticule1 = 63 - i / 2;

        yGraticule0 = 255;

        pyGratLabel = &ax2V[0];

        yGratLabelLen = sizeof(ax2V);

      }

      break;

    case AC500mV:

      curVref = 3;

      i = (byte)(0.5 / 1.1 * 256 / 4);

      yGraticule1 = 32 - i;

      yGraticule2 = 32 + i;

      yGraticule0 = 32;

      pyGratLabel = &ax0_5[0];

      yGratLabelLen = sizeof(ax0_5);

      break;

    case AC100mV:

      curVref = 3;

      i = (byte)(0.1 / 1.1 * (R1 + R2) / R2 * 256 / 4);

      yGraticule1 = 32 - i;

      yGraticule2 = 32 + i;

      yGraticule0 = 32;

      pyGratLabel = &ax0_1[0];

      yGratLabelLen = sizeof(ax0_1);

      break;

    case AC20mV:

      curVref = 3;

      i = (byte)(0.02 / 1.1 * (R1 + R2) / R2 * (R1 + R2) / R2 * 256 / 4);

      yGraticule1 = 32 - i;

      yGraticule2 = 32 + i;

      yGraticule0 = 32;

      pyGratLabel = &ax20[0];

      yGratLabelLen = sizeof(ax20);

      break;

    default:

      curVref = 1;

      yGraticule1 = 255;

      yGraticule2 = 255;

      yGraticule0 = 255;

      pyGratLabel = &ax20[0];

      yGratLabelLen = sizeof(ax20);

      break;

  }

  switch (curMode) {

    case mVoltmeter:

      Vin = 0;

      drawScreen();

      break;

    default: FC_disable();

  }

  yGraticulePage0 = yGraticule0 / 8;

  yGraticuleByte0 = 1 << (yGraticule0 % 8);

  yGraticulePage1 = yGraticule1 / 8;

  yGraticuleByte1 = 1 << (yGraticule1 % 8);

  yGraticulePage2 = yGraticule2 / 8;

  yGraticuleByte2 = 1 << (yGraticule2 % 8);

  SendAck();

}

//-----------------------------------------------------------------------------

// drawMainMenu

//   draw the main menu for values of sel and adj

//-----------------------------------------------------------------------------

void drawMainMenu(void) {

  int ofs, x, yVcc, pg;

  switch (sel) {

    case sMode:    ofs = -1; break;

    case sTrigger: ofs = -2; break;

    case sTestSig: ofs = -5; break;

    case sSigGen:  ofs = bHasTestSignal ? -7 : -5; break;

    default:       ofs = 0;

  }

  //  DrawImageSH1106(0,ofs,imgMainMenu);

  DrawImageSH1106(0, ofs + 0, imgMainMenuTop);

  for (x = 2; x < 14; x++)

    DrawImageSH1106(0, ofs + x, imgMainMenuMid);

  DrawImageSH1106(0, ofs + 10 + bHasTestSignal * 2 + bHasSigGen * 2, imgMainMenuBot);

  DrawImageSH1106(6, 3 + sel * 2 + ofs, imgCaret1);

  BoldSH1106 = true;

  pg = 3 + ofs;

  DrawStringSH1106("Time:",                                12, pg, SmallFont); pg += 2;

  DrawStringSH1106((adj[1] <= AC20mV ? "Gain:" : "Mode:"), 12, pg, SmallFont); pg += 2;

  DrawStringSH1106("Trigger:",                             12, pg, SmallFont); pg += 2;

  if (bHasTestSignal) {

    DrawStringSH1106("Test sig:",                          12, pg, SmallFont); pg += 2;

    if (bHasSigGen) {

      DrawStringSH1106("Signal Generator",                 12, pg, SmallFont); pg += 2;

    }

    DrawStringSH1106("Vcc:",                               12, pg, SmallFont); yVcc = pg; pg += 2;

  } else {

    if (bHasSigGen) {

      DrawStringSH1106("Vcc:",                             12, pg, SmallFont); yVcc = pg; pg += 2;

      DrawStringSH1106("Signal Generator",                 12, pg, SmallFont); pg += 2;

    } else {

      DrawStringSH1106("Vcc:",                             12, pg, SmallFont); yVcc = pg; pg += 2;

    }

  }

  BoldSH1106 = false;

  x = 62;

  pg = 3 + ofs;

  switch (adj[0]) {

    case 0:  DrawStringSH1106("1mS",   x, pg, SmallFont); break;

    case 1:  DrawStringSH1106("2mS",   x, pg, SmallFont); break;

    case 2:  DrawStringSH1106("5mS",   x, pg, SmallFont); break;

    case 3:  DrawStringSH1106("10mS",  x, pg, SmallFont); break;

    case 4:  DrawStringSH1106("20mS",  x, pg, SmallFont); break;

    case 5:  DrawStringSH1106("50mS",  x, pg, SmallFont); break;

    case 6:  DrawStringSH1106("100mS", x, pg, SmallFont); break;

  }

  pg += 2;

  switch (adj[1]) {

    case DC5V:       DrawStringSH1106("5V DC",      x, pg, SmallFont); break;

    case AC500mV:    DrawStringSH1106("0.5V AC",    x, pg, SmallFont); break;

    case AC100mV:    DrawStringSH1106("0.1V AC",    x, pg, SmallFont); break;

    case AC20mV:     DrawStringSH1106("20mV AC",    x, pg, SmallFont); break;

    //case mLogic:     DrawStringSH1106("Logic",      x, pg, SmallFont); break;

    //case mFreqLogic: DrawStringSH1106("Freq Logic", x, pg, SmallFont); break;

    //case mFreqAC:    DrawStringSH1106("Freq AC",    x, pg, SmallFont); break;

    case mVoltmeter: DrawStringSH1106("Voltmeter",  x, pg, SmallFont); break;

  }

  pg += 2;

  switch (adj[2]) {

    case 1:  DrawStringSH1106("Fall", x, pg, SmallFont); break;

    default: DrawStringSH1106("Rise", x, pg, SmallFont);

  }

  pg += 2;

  if (bHasTestSignal) {

    switch (adj[3]) {

      case 1:  DrawStringSH1106("31250Hz 32uS", x, pg, SmallFont); break;

      case 2:  DrawStringSH1106("3906Hz 256uS", x, pg, SmallFont); break;

      case 3:  DrawStringSH1106("977Hz 1024uS", x, pg, SmallFont); break;

      case 4:  DrawStringSH1106("488Hz 2048uS", x, pg, SmallFont); break;

      case 5:  DrawStringSH1106("244Hz 4096uS", x, pg, SmallFont); break;

      case 6:  DrawStringSH1106("122Hz 8192uS", x, pg, SmallFont); break;

      case 7:  DrawStringSH1106("31Hz 32768uS", x, pg, SmallFont); break;

      default: DrawStringSH1106("Off",          x, pg, SmallFont);

    }

    pg += 2;

  }

  if (bHasSigGen)

    pg += 2;

  if (yVcc <= 7) {

    x += DrawIntDP2(readVcc() / 10, x, yVcc, SmallFont);

    DrawCharSH1106('V', x, yVcc, SmallFont);

  }

}

//-----------------------------------------------------------------------------

// incAdj

//   increment the value of adj

//-----------------------------------------------------------------------------

void incAdj(void) {

  if (sel == sSigGen)

    return;

  if (sel == sMode) {

    adj[1] = incMode(adj[1]);

  } else {

    adj[sel]++;

    if (adj[0] > 6) adj[0] = 0;

    if (adj[2] > 1) adj[2] = 0;

    if (adj[3] > 7) adj[3] = 0;

  }

  drawMainMenu;

}

//-----------------------------------------------------------------------------

// incSel

//   increment the value of sel

//-----------------------------------------------------------------------------

void incSel(void) {

  if (bHasTestSignal) {

    if (bHasSigGen) {

      if (sel == sSigGen)

        sel = sTime - 1;

    } else {

      if (sel == sTestSig)

        sel = sTime - 1;

    }

  } else {

    if (bHasSigGen) {

      if (sel == sSigGen)

        sel = sTime - 1;

      if (sel == sTrigger)

        sel = sSigGen - 1;

    } else {

      if (sel == sTrigger)

        sel = sTime - 1;

    }

  }

  sel = sel + 1;

  drawMainMenu;

}

//-----------------------------------------------------------------------------

// DrawIntDP2

//   draws the int 1234 with format 12.34

//   at x,page

//   returns width drawn

//-----------------------------------------------------------------------------

int DrawIntDP2(int i, byte x, byte page, word Font) {

  int start;

  start = x;

  if (i < 0) {

    i = -i;

    x += DrawCharSH1106('-', x, page, Font);

  }

  x += DrawIntSH1106(i / 100, x, page, Font);

  x += DrawCharSH1106('.', x, page, Font);

  x += DrawIntSH1106((i / 10) % 10, x, page, Font);

  x += DrawIntSH1106(i % 10, x, page, Font);

  return x - start;

}

//-----------------------------------------------------------------------------

// drawSigGenMenu

//-----------------------------------------------------------------------------

void drawSigGenMenu(void) {

  byte x,y,i;

  drawBox("Signal Generator");

  if (sweepType == swOff) {

    x = 20;

    y = 3;

    for (i = numberOfDigits - 1; i < numberOfDigits; i--) {

      if (i == SelSG)

        DrawImageSH1106(x+2, y+2, imgCaret2);

      x += DrawIntSH1106(freqSGLo[i],  x, y, LargeDigitsFont);

    }

  } else {

    x = 60;

    y = 2;

    DrawStringSH1106("Max Freq:",     12, y, SmallFont);

    for (i = numberOfDigits - 1; i < numberOfDigits; i--) {

      if (i == SelSG-numberOfDigits)

        DrawImageSH1106(x-2, y+1, imgCaret2);

      x += DrawIntSH1106(freqSGHi[i],  x, y, SmallFont);

    }

    DrawStringSH1106(" Hz",  x, y, SmallFont);

    x = 60;

    y = 4;

    DrawStringSH1106("Min Freq:",     12, y, SmallFont);

    for (i = numberOfDigits - 1; i < numberOfDigits; i--) {

      if (i == SelSG)

        DrawImageSH1106(x-2, y+1, imgCaret2);

      x += DrawIntSH1106(freqSGLo[i],  x, y, SmallFont);

    }

    DrawStringSH1106(" Hz",  x, y, SmallFont);

  }

  x = 12;

  y = 6;

  if (SelSG == SelSGSine)

    DrawImageSH1106(x-6, y, imgCaret1);

//  switch (waveType) {

//    case wSine:      DrawStringSH1106("Sine",     x, y, SmallFont); break;

//    case wTriangle:  DrawStringSH1106("Triangle", x, y, SmallFont); break;

//    case wSquare:    DrawStringSH1106("Square",   x, y, SmallFont); break;

//  }

  for (x=12;x<40;x+=14)

  switch (waveType) {

    case wSine:      DrawImageSH1106(x, y, imgSine); break;

    case wTriangle:  DrawImageSH1106(x, y, imgTrian); break;

    case wSquare:    DrawImageSH1106(x, y, imgSquare); break;

  }

  x = 54;

  y = 6;

  switch (sweepType) {

    case swOff:       DrawStringSH1106("Constant",       x, y, SmallFont); break;

    case sw1Sec:      DrawStringSH1106("Sweep 1 Sec",    x, y, SmallFont); break;

    case sw5Sec:      DrawStringSH1106("Sweep 5 Sec",    x, y, SmallFont); break;

    case sw20Sec:     DrawStringSH1106("Sweep 20 Sec",   x, y, SmallFont); break;

    case sw20Frames:  DrawStringSH1106("Swp 20 frames",  x, y, SmallFont); break;

    case sw100Frames: DrawStringSH1106("Swp 100 frames", x, y, SmallFont); break;

    case sw500Frames: DrawStringSH1106("Swp 500 frames", x, y, SmallFont); break;

  }

  if (SelSG == SelSGSweep)

    DrawImageSH1106(x-6, y, imgCaret1);

}

//-----------------------------------------------------------------------------

//returns 10^y

//-----------------------------------------------------------------------------

unsigned long Power(int y) {

  unsigned long t = 1;

  for (byte i = 0; i < y; i++)

    t = t * 10;

  return t;

}

//-----------------------------------------------------------------------------

//calculate the frequency from the array.

//-----------------------------------------------------------------------------

unsigned long calcFreq(byte* freqSG) {

  unsigned long i = 0;

  for (byte x = 0; x < numberOfDigits; x++)

    i = i + freqSG[x] * Power(x);

  return i;

}

//-----------------------------------------------------------------------------

// SG_WriteRegister

//-----------------------------------------------------------------------------

void SG_WriteRegister(word dat) {

  digitalWrite(SG_CLK, LOW);

  digitalWrite(SG_CLK, HIGH);

  digitalWrite(SG_fsyncPin, LOW);

  for (byte i = 0; i < 16; i++) {

    if (dat & 0x8000)

      digitalWrite(SG_DATA, HIGH);

    else

      digitalWrite(SG_DATA, LOW);

    dat = dat << 1;

    digitalWrite(SG_CLK, HIGH);

    digitalWrite(SG_CLK, LOW);

  }

  digitalWrite(SG_CLK, HIGH);

  digitalWrite(SG_fsyncPin, HIGH);

}

//-----------------------------------------------------------------------------

// SG_Reset

//-----------------------------------------------------------------------------

void SG_Reset() {

  delay(100);

  SG_WriteRegister(0x100);

  delay(100);

}

//-----------------------------------------------------------------------------

// SG_freqReset

//    reset the SG regs then set the frequency and wave type

//-----------------------------------------------------------------------------

void SG_freqReset(long frequency, int wave) {

  long fl = frequency * (0x10000000 / 25000000.0);

  SG_WriteRegister(0x2100);

  SG_WriteRegister((int)(fl & 0x3FFF) | 0x4000);

  SG_WriteRegister((int)((fl & 0xFFFC000) >> 14) | 0x4000);

  SG_WriteRegister(0xC000);

  SG_WriteRegister(wave);

  waveType = wave;

}

//-----------------------------------------------------------------------------

// SG_freqSet

//    set the SG frequency regs

//-----------------------------------------------------------------------------

void SG_freqSet(long frequency, int wave) {

  long fl = frequency * (0x10000000 / 25000000.0);

  SG_WriteRegister(0x2000 | wave);

  SG_WriteRegister((int)(fl & 0x3FFF) | 0x4000);

  SG_WriteRegister((int)((fl & 0xFFFC000) >> 14) | 0x4000);

}

//-----------------------------------------------------------------------------

// SG_StepSweep

//    increment the FG frequency

//-----------------------------------------------------------------------------

void SG_StepSweep(void) {

  if (SG_iSweep > SG_nSweep) SG_iSweep = 0;

  long f = exp((log(calcFreq(freqSGHi)) - log(calcFreq(freqSGLo)))*SG_iSweep/SG_nSweep + log(calcFreq(freqSGLo))) +0.5;

  SG_freqSet(f, waveType);

  SG_iSweep++;

}

//-----------------------------------------------------------------------------

// Sweep

//   sweeps siggen freq continuously

//   takes n mS for whole sweep

//   SDC regs are saved and restored

//   stops when receives a serial char

//-----------------------------------------------------------------------------

void Sweep(int n) {

  byte oldACSR = ACSR;

  byte oldADCSRA = ADCSRA;

  byte oldADCSRB = ADCSRB;

  byte oldADMUX = ADMUX;

  byte oldDIDR0 = DIDR0;

  byte oldDIDR1 = DIDR1;

  int fmin,fmax;

  fmin = calcFreq(freqSGLo);

  fmax = calcFreq(freqSGHi);

  int i=0;

  do {

    long f = exp((log(fmax) - log(fmin))*i/(n-1) + log(fmin)) +0.5;

    SG_freqSet(f, waveType);

    delay(1);

    i++;

    if (i >= n) i = 0;

  } while (!Serial.available());

  SG_freqSet(calcFreq(freqSGLo), waveType);

  ACSR = oldACSR;

  ADCSRA = oldADCSRA;

  ADCSRB = oldADCSRB;

  ADMUX = oldADMUX;

  DIDR0 = oldDIDR0;

  DIDR1 = oldDIDR1;

}

//-----------------------------------------------------------------------------

// incSelSG

//   increment digit for SigGen Menu

//-----------------------------------------------------------------------------

void incSelSG(void) {

  if (SelSG == SelSGSine) {

    switch (waveType) {

      case wSine:      waveType = wTriangle; break;

      case wTriangle:  waveType = wSquare; break;

      case wSquare:    waveType = wSine; break;

    }

  } else

  if (SelSG == SelSGSweep) {

    if (sweepType == sw20Sec)

      sweepType = swOff;

    else

      sweepType = sweepType+1;

  } else

  if (SelSG < numberOfDigits) {

    if (freqSGLo[SelSG] >= 9)

      freqSGLo[SelSG] = 0;

    else

      freqSGLo[SelSG]++;

  } else

  if (sweepType != swOff) {

    if (freqSGHi[SelSG-numberOfDigits] >= 9)

      freqSGHi[SelSG-numberOfDigits] = 0;

    else

      freqSGHi[SelSG-numberOfDigits]++;

  }

  drawSigGenMenu();

}

//-----------------------------------------------------------------------------

// incAdjSG

//   increment caret position for SigGen Menu

//-----------------------------------------------------------------------------

void incAdjSG(void) {

  if (SelSG == 0)

    SelSG = SelSGSine;

  else

    SelSG--;

  if ((SelSG >= numberOfDigits) && (SelSG < 2*numberOfDigits) && (sweepType == swOff))

    SelSG = numberOfDigits-1;

  drawSigGenMenu();

}

//-----------------------------------------------------------------------------

// ExecSigGenMenu

//   SigGen menu

//   user presses sel or Adj buttons

//   return if no button for 2 sec

//-----------------------------------------------------------------------------

void ExecSigGenMenu(void) {

  static int prevHorz = 0;

  static int prevVert = 0;

  int i;

  const byte timeout = 0xC0; // 3 sec to exit

  FC_disable();

  drawSigGenMenu();

  while ((digitalRead(BtnHorz) == LOW) || (digitalRead(BtnVert) == LOW))

    ; // wait until buttons off

  StartTimer1(0);

  SG_iSweep = 0;

  do {

    i = digitalRead(BtnVert);

    if (i != prevVert) {

      prevVert = i;

      if (i == LOW) {

        incSelSG();

        drawSigGenMenu();

        SG_freqReset(calcFreq(freqSGLo), waveType);

      }

      myDelay(100);

      StartTimer1(0);

    }

    i = digitalRead(BtnHorz);

    if (i != prevHorz) {

      prevHorz = i;

      if (i == LOW) {

        incAdjSG();

        drawSigGenMenu();

      }

      myDelay(100);

      StartTimer1(0);

    }

    if (sweepType != swOff) {

      switch (sweepType) {

        case sw1Sec:  SG_nSweep = (long) 1000*65/100; break;

        case sw5Sec:  SG_nSweep = (long) 5000*65/100; break;

        case sw20Sec: SG_nSweep = (long)20000*65/100; break;

        case sw20Frames:  SG_nSweep = 20; break;

        case sw100Frames: SG_nSweep = 100; break;

        case sw500Frames: SG_nSweep = 500; break;

      }

      SG_StepSweep();

    }

    i = TCNT1L; // to force read of TCNT1H

  } while ((TCNT1H < timeout) || (sweepType >= sw1Sec));

}

//-----------------------------------------------------------------------------

// ExecMenu

//   show main menu

//   user presses sel or Adj buttons

//   return if no button for 2 sec

//-----------------------------------------------------------------------------

void ExecMenu(void) {

  static int prevHorz = 0;

  static int prevVert = 0;

  int i;

  const byte timeout = 0x80; // 2 sec to exit

  adj[0] = curSweep;

  adj[1] = curMode;

  adj[2] = TrigFalling;

  adj[3] = curPwmMode;

  FC_disable();

  drawMainMenu();

  while ((digitalRead(BtnHorz) == LOW) || (digitalRead(BtnVert) == LOW))

    ; // wait until buttons off

  StartTimer1(0);

  do {

    i = digitalRead(BtnVert);

    if (i != prevVert) {

      prevVert = i;

      if (i == LOW) {

        incSel();

        drawMainMenu();

      }

      myDelay(100);

      StartTimer1(0);

    }

    i = digitalRead(BtnHorz);

    if (i != prevHorz) {

      prevHorz = i;

      if (i == LOW) {

        if (sel == sSigGen)

          break;

        incAdj();

        if (sel == sTestSig)

          setPwmFrequency(testSignalPin, adj[3]);

        drawMainMenu();

      }

      myDelay(100);

      StartTimer1(0);

    }

    i = TCNT1L; // to force read of TCNT1H

  } while (TCNT1H < timeout);

  if (sel == sSigGen) {

    sel = sTime;

    ExecSigGenMenu();

  }

  setSweep(adj[0]);

  setMode(adj[1]);

  TrigFalling = adj[2] != 0;

  clearSH1106();

}

//-----------------------------------------------------------------------------

// CheckButtons

//   if BtnVert button pressed, change gain

//   if BtnHorz button pressed, change sweep

//   if button held for 2 sec, show menu

//-----------------------------------------------------------------------------

void CheckButtons(void) {

  const byte timeout = 70; // 1 sec to show menu

  static int prevHorz = HIGH;

  static int prevVert = HIGH;

  int i;

  if (digitalRead(BtnHorz) == LOW) {

    if (prevHorz == HIGH) {

      switch (curMode) {

        //case mFreqLogic:

       // case mFreqAC:

        case mVoltmeter:

          ExecMenu();

          return;

      }

      ButtonsTimer1 = 0;

      myDelay(15);

      setSweep(255);

      prevHorz = LOW;

    } else {

      if (ButtonsTimer1 > timeout) {

        ExecMenu();

        return;

      }

    }

  } else {

    prevHorz = HIGH;

  }

  if (digitalRead(BtnVert) == LOW) {

    if (prevVert == HIGH) {

      ButtonsTimer1 = 0;

      myDelay(15);

      setMode(255);

      prevVert = LOW;

    } else {

      if (ButtonsTimer1 > timeout) {

        ExecMenu();

        return;

      }

    }

  } else {

    prevVert = HIGH;

  }

}

//=========================================================================

// Timer1 overflows every 65536 counts

//    used in freq meter

//=========================================================================

ISR (TIMER1_OVF_vect)

{

  FC_overflowCount++;

}

//=========================================================================

// Timer1 Capture interrupt

//    invoked by comparator

//    read the current timer1 capture value

//    used in freq meter

//=========================================================================

ISR (TIMER1_CAPT_vect) {

  // grab counter value before it changes any more

  unsigned int timer1CounterValue = ICR1;  // see datasheet, page 117 (accessing 16-bit registers)

  unsigned long overflowCopy = FC_overflowCount;

  unsigned long t;

  static unsigned long prevT;

  // if just missed an overflow

  if ((TIFR1 & bit(TOV1)) && timer1CounterValue < 0x7FFF)

    overflowCopy++;

  t = (overflowCopy << 16) + timer1CounterValue;

  if ((!FC_firstAC) && (t-prevT > 100) && (t-prevT > FC_MaxPeriodAC))

    FC_MaxPeriodAC = t-prevT;

  prevT = t;

  FC_firstAC = false;

}

//=========================================================================

//  Timer0 Interrupt Service is invoked by hardware Timer0 every 1ms = 1000 Hz

//  used by frequancy counter

//  called every 1mS

//=========================================================================

ISR(TIMER0_COMPA_vect) {

  if (FC_Timeout >= FC_LogicPeriod) {           // end of gate time, measurement ready

    TCCR1B &= ~7;         // Gate Off  / Counter T1 stopped

    bitClear(TIMSK0, OCIE0A);        // disable Timer0 Interrupt

    FC_OneSec = true;           // set global flag for end count period

    // calculate now frequeny value

    FC_freq = 0x10000 * FC_overflowCount; // mult #overflows by 65636

    FC_freq += TCNT1;       // add counter1 value

  }

  FC_Timeout++;              // count number of interrupt events

  if (TIFR1 & 1) {                // if Timer/Counter 1 overflow flag

    FC_overflowCount++;               // count number of Counter1 overflows

    bitSet(TIFR1, TOV1);            // clear Timer/Counter 1 overflow flag

  }

}

//=========================================================================

// FC_InitLogic

//   count number of rising edges at D5 over mS period

//=========================================================================

void FC_InitLogic() {

  noInterrupts ();

  TIMSK0 = 0x00;

  delayMicroseconds(50);      // wait if any ints are pending

  FC_OneSec = false;                  // reset period measure flag

  FC_Timeout = 0;                 // reset interrupt counter

  TCCR1A = 0x00; // timer output off

  TCCR1B = 0x07; // External clock source on T1 pin. Clock on rising edge.

  TCNT1 = 0x00; // counter = 0

  TCCR0A = 0x02; // compare output off; max count = OCRA

  TCCR0B = 0x03; // input clk is 16M/64

  TCNT0 = 0x16; // counter = 0 - why is this not 0? cos of set-up time?

  TIMSK0 = 0x00;

  OCR0A = 248; // max count value = CTC divider by 250 = 1mS

  GTCCR = 0x02; // reset prescaler

  FC_overflowCount = 0;

  bitSet(TIMSK0, OCIE0A);      // enable Timer0 Interrupt

  interrupts ();

}

//=========================================================================

// FC_InitAC

//   ACfreqAdcPin = 0..5 - use that ADC mux and measure period with Timer1

//=========================================================================

void FC_InitAC() {

  noInterrupts ();

  FC_disable();

  TCCR1A = 0; // reset Timer 1

  TCCR1B =  bit(CS10) | bit(ICES1);  // no prescaler, Input Capture Edge Select

  TIFR1 = bit(ICF1) | bit(TOV1);  // clear flags so we don't get a bogus interrupt

  TCNT1 = 0;          // Timer1 to zero

  FC_overflowCount = 0;  // for Timer1 overflows

  TIMSK1 = bit(TOIE1) | bit(ICIE1);   // interrupt on Timer 1 overflow and input capture

  ADCSRA = 0;

  DIDR1 = 1; // digital input of D6 is off

  ADMUX = ACfreqAdcPin;

  ACSR = bit(ACI)  | bit(ACIC) | (B10 << ACIS0); // "clear" interrupt flag; timer capture from comparator; falling edge

  ADCSRB = bit(ACME); // Comparator connected to ADC mux

  FC_firstAC = true;

  FC_Timeout = 0;

  FC_MaxPeriodAC = 0;

  interrupts ();

}

//=========================================================================

// FC_disable

//   turn off freq counter interrupts

//=========================================================================

void FC_disable() {

  TCCR0A = 0x03; // no compare output; Fast PWM up to 0xFF

  TCCR0B = 0x03; // no Output Compare; prescaler = 16MHz/64; overflow approx every 1mS

  TIMSK0 = 0x00; // Interrupt Mask Register = none

  GTCCR = 0x00; // Control Register = none

  OCR0A = 0x00; // Output Compare Register A = none

  OCR0B = 0x00; // Output Compare Register B = none

  TCCR1A = 0xC0;

  TCCR1B = 0x05;

  TCCR1C = 0x00;

  TIMSK1 = 0x00;

}

//=========================================================================

// FC_OneSecPassed

//   has 1 second passed?

//=========================================================================

bool FC_OneSecPassed() {

  static byte prevTimer1 = 0;

  byte i;

  static unsigned long t = 0;

  if (bitRead(TIFR0, TOV0)) // overflow every 1mS

    FC_Timeout++;

  bitSet(TIFR0, TOV0);

  return FC_Timeout > 1000;

}

//=========================================================================

// FC_CheckLogic

//   frequency measurer

//   call repeatedly

//   returns true when has timed out

//   result in FC_freq

//=========================================================================

bool FC_CheckLogic() {

  return FC_OneSec;

}

//=========================================================================

// FC_CheckAC

//   frequency measurer

//   call repeatedly

//   returns true when has timed out

//   result in FC_freq

//=========================================================================

bool FC_CheckAC() {

  unsigned long FC_elapsedTime;

  if (FC_OneSecPassed()) {

    if (FC_MaxPeriodAC > 0)

      FC_freq = 100 * F_CPU*1.004 / FC_MaxPeriodAC; // mult by 100 so can display 2 d.p.

    else

      FC_freq = 0;

    FC_InitAC();

    return true;

  }

  return false;

}

//-----------------------------------------------------------------------------

// myDelay

//   delays for approx mS milliSeconds

//   doesn't use any timers

//   doesn't affect interrupts

//-----------------------------------------------------------------------------

void myDelay(int mS) {

  for (int j = 0; j < mS; j++)

    delayMicroseconds(1000);

}

//-----------------------------------------------------------------------------

// MeasureVoltmeter

//   measures Voltmeter at Vin in mV

//   assumes resistors have been connected to pin:

//     Ra from pin to 5V

//     Rb from pin to 0V

//     Rc from pin to Vin

//-----------------------------------------------------------------------------

long MeasureVoltmeter(int pin) {

  const long Ra = 120; // from pin to 5V

  const long Rb = 150; // from pin to 0V

  const long Rc = 470; // from pin to Vin

  const int calibrateZero = +20; // Calibrate so 0V = "0V"

  const int calibrateVolts = 1024; // Calibrate so 10V = "10V"

  long Aa, Vb;

  byte oldACSR = ACSR;

  byte oldADCSRA = ADCSRA;

  byte oldADCSRB = ADCSRB;

  byte oldADMUX = ADMUX;

  byte oldDIDR0 = DIDR0;

  byte oldDIDR1 = DIDR1;

  Vb = readVcc();

  Aa = analogRead(pin); // set up the ADC

  myDelay(1); // high input impedance so allow to settle

  Aa = analogRead(pin); // read ADC

  ACSR = oldACSR;

  ADCSRA = oldADCSRA;

  ADCSRB = oldADCSRB;

  ADMUX = oldADMUX;

  DIDR0 = oldDIDR0;

  DIDR1 = oldDIDR1;

  if (Aa > 1023 - 10)

    return LONG_MAX;

  if (Aa < 10)

    return -LONG_MAX;

  return (Aa * Vb - Rc * ((Vb * 1024 - Aa * Vb) / Ra - Aa * Vb / Rb)) / calibrateVolts + calibrateZero;

}

//=========================================================================

// CheckVoltmeter

//   Voltmeter measurer

//=========================================================================

bool CheckVoltmeter() {

  const byte n = 50;

  static byte i = 0;

  static long sum = 0;

  long v;

  myDelay(5);

  v = MeasureVoltmeter(6);

  i++;

  if ((v | sum) & 0x40000000) {

    sum = v;

    Vin = v;

  } else {

    sum += v;

    Vin = sum / i;

  }

  if (i >= n) {

    sum = 0;

    i = 0;

    return true;

  }

  return false;

}

//-----------------------------------------------------------------------------

// InitSigGen

//-----------------------------------------------------------------------------

void InitSigGen(void) {

  pinMode(SG_DATA, OUTPUT);

  pinMode(SG_CLK, OUTPUT);

  pinMode(SG_fsyncPin, OUTPUT);

  digitalWrite(SG_fsyncPin, HIGH);

  digitalWrite(SG_CLK, HIGH);

  SG_Reset();

  SG_freqReset(calcFreq(freqSGLo), waveType);

}

//-----------------------------------------------------------------------------

// Main routines

// The setup function

//-----------------------------------------------------------------------------

void setup (void) {

  // Open serial port with a baud rate of BAUDRATE b/s

  Serial.begin(BAUDRATE);

  // Clear buffers

  memset( (void *)commandBuffer, 0, sizeof(commandBuffer) );

  // Activate interrupts

  sei();

  initADC();

  Serial.println("ArdOsc " __DATE__); // compilation date

  Serial.println("OK");

  setMode(0); // y-gain 5V

  setSweep(5);

  setPwmFrequency(testSignalPin, 3); // test signal 976Hz 1024uS

  pinMode(BtnHorz, INPUT_PULLUP);

  pinMode(BtnVert, INPUT_PULLUP);

  pinMode(LED_BUILTIN, OUTPUT);

  Wire.begin(); // join i2c bus as master

    TWBR = 1; // freq=888kHz period=1.125uS

  initSH1106();

}

//-----------------------------------------------------------------------------

// Main routines

// loop

//-----------------------------------------------------------------------------

void loop (void) {

  static int ButtonsTimer2 = 0;

  switch (curMode) {

    case mVoltmeter:

      if (CheckVoltmeter())

        drawScreen();

      break;

    default:

      if (!SendingSerial) {

        SendADC();

        switch (sweepType) {

          case sw20Frames: case sw100Frames: case sw500Frames:

            SG_StepSweep();

        }

      }

  }

  CheckButtons();

}