bcd_caliper.ino

/*

        Reading data from digital calipers with 6 digit BCD protocol

        Data format as it appears on the serial line.

        The first nibble holds 1/100mmm, the next 1/10mm, then 1mm and so on.

      If the unit is inches, it starts with 1/1000 inch.

        Nibble_1 Nibble_2 Nibble_3 Nibble_4 Nibble_5 Nibble_6 Nibble_7

        -------- -------- -------- -------- -------- -------- --------

        xxxx.xN  xxxx.Nx  xxxN.xx  xxxNx.xx  xNxx.xx Nxxx.xx  bitvalues  # mm

        xxx.xxN  xxx.xNx  xxx.Nxx  xxxN.xxx  xNx.xxx Nxx.xxx  bitvalues  # inches

        Nibble 1-6 : BCD (binary coded decimal)

        Timing:

          1 bit               ca.  12 µsec

          1 nibble with sync  ca. 100 µsec

            example 1, first nibble : 1010 = 5

                 _____   _   _   _   ______

            ____|     |_| |_| |_| |_|         clock (falling edge = data valid , rising edge = data change)

                      1   2   4   8           bit value

                 _______     ___ 

            ____|       |___|   |___N         data; N = set to value of first bit in NEXT nibble

            example 2, first nibble : 0010 = 4

                 _____   _   _   _   ______

            ____|     |_| |_| |_| |_|         clock (falling edge = data valid , rising edge = data change)

                      1   2   4   8           bit value

                             ___ 

            ________________|   |___N         data; N = set to value of first bit in NEXT nibble

        Nibble 7   : Bit 0: sign; 0=plus,1=minus

                     Bit 1: 5/10000-inch (if unit is inch), 0=off, 1=on

                     Bit 2: unit,  0=inch, 1=mm

                     Bit 3: (?, always 1)

        whole packet ca. 750 µsec, pause between packets ca. 300 ms

        references:

        http://www.mikrocontroller.net/articles/Me%C3%9Fschieber_auslesen

        http://www.mikrocontroller.net/topic/30219

        http://www.roboternetz.de/community/threads/45869-digitale-schieblehre-auslesen

      http://www.pcbheaven.com/exppages/Digital_Caliper_Protocol/

        http://code.google.com/p/digitalwritefast/

        BL, 2015-aug-14

*/

#include <LiquidCrystal.h>

// ------------- LCD pin declarations

// initialize the library with the interface pin numbers

//                RS  EN  D4 D5 D6 D7

LiquidCrystal lcd(12, 11, 7, 6, 5, 4);

// library from http://code.google.com/p/digitalwritefast/

#include <digitalWriteFast.h>

#define BITS 28         // data bits in one burst

#define STARTUP BITS+2  // value which is not reached during sync'ed transfer. used to identify startup

#define DATAIN 3        // data in pin number

// ------------- global variables

int           clockIn = 2;   // clockIn pin number

volatile int  bitVal[30];    // bit read buffer

volatile int  bitCount = STARTUP;

unsigned int  timer;         // used to detect pause between data bursts

// ------------- setup

void setup() {

  pinMode (DATAIN, INPUT);

  pinMode(clockIn, INPUT);

  attachInterrupt (0, getBit, FALLING);

  // Serial.begin(115200);

}

// ------------- interupt service routine

void getBit(){

  if ( bitCount <= BITS ){

  /*

   * read data bit

   * needs 'fast' variant, 'digitalRead' too slow

   */

  bitVal[bitCount] = digitalReadFast2(DATAIN);

  bitCount++;

  }

}

// ------------- loop

void loop(){

  int  bc;          // bit counter

  int  sc;          // shift counter

  int  dc;          // digit counter

  int  nibble;      // 4 bit buffer

  int  bcdDigit[7]; // BCD + bitmask in [6]

  // display data

  char sign;

  int ftt;           // 5/10000 inch

  char* units;       // mm or inch

  char* displayText = "1234567890123456";  // display buffer

  // ------------- sync with pause between data bursts

  if ( bitCount > BITS ){

    if ( bitCount < STARTUP){      // startup done, now synced

    // process data bits

    // Serial.println(bitCount);

    // bit decoding to BCD

    sc = 0;

    dc = 0;

    nibble=0;

    for ( bc = 0; bc < BITS; bc++ ){

      nibble |=  bitVal[bc] << sc;

      // Serial.print(bitVal[bc]);

      if ( bc %4 == 3 ){

        // Serial.print("(");

        // Serial.print(nibble,HEX);

        // Serial.print(") ");

        bcdDigit[dc] = nibble;

        nibble = 0;

        sc = 0;

        dc++;

      }else{

        sc++;

      }

    }

    // ------------- format output

    // check sign bit

    if ( bcdDigit[6] & 0x1 ){

      sign = '-';

    }else{

      sign = '+';

    }

    // check 5/10000 bit

    if ( bcdDigit[6] & 0x2 ){

      ftt = 5;

    }else{

      ftt = 0;

    }

    // check units bit

    if ( bcdDigit[6] & 0x4 ){

      units = "mm";

      sprintf(displayText, "%c%d%d%d.%d%d %s",

        sign,

        bcdDigit[4], bcdDigit[3], bcdDigit[2], bcdDigit[1], bcdDigit[0],

        units);

        // Serial.println(" ");

        // Serial.print(displayText);

        // Serial.println(" ");

    }else{

      units = "inch";

          sprintf(displayText, "%c %d%d.%d%d%d%d %s",

      sign,

      bcdDigit[4], bcdDigit[3], bcdDigit[2], bcdDigit[1], bcdDigit[0],ftt,

      units);

      // Serial.println(" ");

      // Serial.print(displayText);

      // Serial.println(" ");

      }

    }

    // display caliper value on LCD

    lcd.clear();

    //          col,row

    lcd.setCursor(0,0);

    lcd.print(displayText);

    // display done, now sync with next data burst

    // Serial.println("syncing");

    // wait for clock becoming low

    while ( digitalRead(clockIn) == 1 ){}

    // record time of falling edge

    timer = millis();

    // wait for clock becoming high

    while ( digitalRead(clockIn) == 0 ){}       

    // verify time of rising edge

    if ( millis() - timer > 200 ){

      // enable bit capture in ISR getBit

      bitCount = 0;

    }

  }

  delay(20);

}

/*

 serial debug output:

syncing

0100(2) 1001(9) 1010(5) 1110(7) 0000(0) 0000(0) 0011(C)  

+075.92 mm   

syncing

0100(2) 1001(9) 1010(5) 1110(7) 0000(0) 0000(0) 0011(C)  

+075.92 mm   

 */