Software Radio Clock for Windows

//**************************************************************************************************
// Serial MSF Test Clock (C) Copyright 2014 Phil Morris              

// a "Proof of Concept" sketch for the Arduino Uno Rev 3 and an MSF Clock module      
// No apologies given for the messy code as this is a sketch simply to show       
// some ideas around decoding MSF time signals. The code takes account of Leep        
// seconds and performs full parity checking. A simple output is provided to the      
// Serial port at 9600 baud. BST/GMT is decoded along with UTC & DUT difference.      
// even partial data reception can produce a valid output as long as seconds 17 thru 59     
// are received correctly.                    
//                                              
// For diagnostic purposes, the minimum and maximum pulse lengths are also displayed in ms  
//                          
// You may use, modify and/or distribute this sketch as long as you leave this text intact. 

//****************************************************************************************************
   // MSF 60KHz Interrupt driven decode program to feed Lazarus/Delphi(Pascal) high level decode program.
   // John Garrett 2020.
   // Modified from a part of sketch copyright of Phil Morris.

   // the msf transmitter is switched off for brief intervals (on-off keying) near the beginning of each second
   // to encode the current time and date. When carrier is low data is active. Every second the 
   // carrier goes low to signify data. Apart from the first second every second consists
   // of a 100ms pulse. This is followed by no data when the carrier is high for 900ms or
   // another 100ms pulse giving 200ms all together signifying an A data. Or an extra 100ms
   // pulse making 300ms in all, giving an A and B data. For B data only the second pulse
   // consists of the statuary 100ms low followed by 100ms high followed by another 100ms low
   // beginning of every minute the first second consists of 500ms low followed by 500ms high.
   // each second pulse apart from the minute marker should be up to 300ms low and up to 900ms high.
   // the data during the current minute is for the following minute of time.

const  int CARRIER_OFF = LOW;  // this constant is set for non-inverted MSF receiver output ie Carrier_Off equals a low. 
                               // invert it if your output = HIGH for carrier off.

const int MSFPIN = 3;            // the Arduino pin for the MSF device (2 or 3).

volatile long pulseStart = 0;        // milliseconds when start of pulse occurred.                      
volatile long pulseEnd = 0;          // milliseconds when pulse ended.
volatile long lastPulseStart = 0;    // the previous pulse start value.  
volatile int pulseLength = 0;        // length of pulse/100 as an integer.
volatile bool bitBonly = false;      // set if a 'B' only pulse detected.
volatile bool printTime = false;
volatile bool sync = false;           //true if valid start pulse.
volatile int counter = 0;               // seconds counter.
volatile int LED_PIN = 13;          // pin LED is attached (optional).
volatile int minMaxPulse = 0;       // actual length in millis.

void setup() {
  Serial.begin(9600);               // start the Serial port
  attachInterrupt(MSFPIN - 2, MsfPulse, CHANGE);  // set the interrupt
  pinMode(LED_PIN,OUTPUT);              // configue the LED pin 
}

void loop()
{
}

void MsfPulse()  // interrupt routine which is called every time the MSF receiver output changes state
{
// This routine is called every time the selected Interrupt pin changes state. If it is the start of
// a pulse, the millis count is stored in "pulseStart". If it is the end of a pulse the millis count
// is stored in "pulseEnd". "pulseLength" is the result in millis/100. The data is processed to produce an
// integer 1 - 5 representing 100 - 500 ms pulses (no "4" is decoded).If pulselength = 5 then the sync flag becomes true
// counter is then = '0'. Once counter reaches == '59' the sync flag becomes false. 
// If the sequence was 100ms off + 100ms on + 100ms off, this is a 'B' only bit.So if this start pulse is less than 300ms 
// after the last start pulse it must be a double 100ms pulse second resulting a bitBonly flag being true.

  
  bitBonly = false;            // clear the bitOnly flag
  bool pinState = digitalRead(MSFPIN);  // get the state of the interrupt pin
  
  // is this a pulse start?

 if (pinState == CARRIER_OFF) // pulse or sub-pulse has started, carrier going low
  {    
    pulseStart = millis();    // pulseStart = current millis everytime the MSFPIN goes low (carrier going low)   
    digitalWrite(LED_PIN,HIGH); // turn on LED
    counter = counter +1;       
    if (printTime == true && counter == 60)       
      {
        Serial.print('6');       // signify to Lazarus to display time scenario
          if (counter <= 9) Serial.print('0');   //too satisfy Lazarus program
          Serial.print(counter);                      
          Serial.print(".");           
      }  
    return;            // until there's a another interrupt change
  }    
  

 // is it a pulse end?

 if(pinState != CARRIER_OFF)               // pulse end, MSFPIN goes high (carrier going high)
  {        
    pulseEnd = millis();                   // set the pulse end ms,the MSFPIN goes high   
    minMaxPulse = pulseEnd - pulseStart;   // actual length in millis    
    pulseLength = abs((minMaxPulse) / 100);       // get the pulse length in ms/100        
    pulseStart = millis();                // set the pulseStart to current millis
    if (minMaxPulse < 90) return;             // the pulse is too short ("noise"), return    
    if (counter == 59 && sync) pulseLength = 4;      // 59th second    
    
// if the sequence was 100ms off + 100ms on + 100ms off, this is a 'B' only bit
// so, if this start pulse is less than 300ms after the last start pulse it must be
// a double 100ms pulse second

    if(pulseStart - lastPulseStart < 300) bitBonly = true;  // this is a 'B' bit
    lastPulseStart = pulseStart;        // keep the last pulse start ms count
    digitalWrite(LED_PIN,LOW);          // turn off the LED    
  }

 switch(pulseLength) // start processing the valid pulse
  {
    case 5: // check for start pulse i.e. 500ms  (11111)
      {
        if(minMaxPulse > 490 && minMaxPulse < 550)
        {
          sync = true;
          printTime = false;
          counter = 0;
          Serial.print('5');       // signify to Lazarus a sync scenario
          if (counter <= 9) Serial.print('0');   //too satisfy Lazarus program
          Serial.print(counter);                      
          Serial.print(".");
        }       
        break;
      }

    case 4:  // 59th second tell Lazarus to compute time (100)
      {        
        sync = false;
        Serial.print('4');       // signify to Lazarus to compute time
        if (counter <= 9) Serial.print('0');   //too satisfy Lazarus program
        Serial.print(counter);                      
        Serial.print(".");
        printTime = true;                
        break;
      }

    case 3:  // check for 300ms pulse, this is an 'A' + 'B' bit case   (111)  
     {
        if(minMaxPulse > 290 && minMaxPulse < 350 && sync)                      
         {           
           Serial.print('3');       // signify to Lazarus a 'A + B' data scenario
           if (counter <= 9) Serial.print('0');   //too satisfy Lazarus program
           Serial.print(counter);                      
           Serial.print(".");
         }
      break;    
     }

    case 2:  // check for 200ms pulse, this is an 'A' bit case   (110)
      {
        if(minMaxPulse > 190 && minMaxPulse < 250 && sync)                
         {           
           Serial.print('2');       // signify to Lazarus a 'A' data scenario
           if (counter <= 9) Serial.print('0');   //too satisfy Lazarus program
           Serial.print(counter);                      
           Serial.print(".");
         }
        break;              
      }

    case 1:  // check for 100ms pulse   (101 or  100)
      {
        if(minMaxPulse > 90 && minMaxPulse < 150 && sync)        
          {                        
            if(bitBonly)
              {
               counter = counter-1;   // to prevent a double count 'B' data only
               Serial.print('1');       // signify to Lazarus a 'B' data scenario
               if (counter <= 9) Serial.print('0');   //too satisfy Lazarus program
               Serial.print(counter);                      
               Serial.print(".");
              }
            else
              {               
               Serial.print('0');       // signify to Lazarus a 'No' data scenario
               if (counter <= 9) Serial.print('0');   //too satisfy Lazarus program
               Serial.print(counter);                      
               Serial.print('.');
              }
          }   
        break;
      }
  
  }
 
}