Software Radio Clock for Windows

Decode and display the 60KHz time signal in MS windows.

Aug 2, 2020

•

806 views

•

0 respects

tracking

clocks

data collection

Devices & Components

Arduino Uno Rev3

Led fixing ring to fit 5mm led

Dual in Line Socket 6 pin

resistor 1k ohm 0.5watt

3 wire headphone lead 5metres

Reel of kynar wire 30awg

3 pin stereo socket 3.5mm

Red Led 5mm

PP3 battery

Canaduino Atomic clock receiver module

3pin streo plug 3.5mm

H11 L1M optoisolator

single pole single throw miniture on/off switch

Box 130x68x44 mm

PP3 connector with two tail

stripboard 9x25 holes 25x64 mm

Hardware & Tools

soldering iron miniture tip

solder flux

2mm drill tip (for isolating the necessary copper strips on the strip boards)

miniture electrical pliers

miniture electrical cutters

Project description

Code

Arduino-Lazarus_MSF Clock

c_cpp

Arduino interrupt sketch

1//**************************************************************************************************
2//   Serial MSF Test Clock (C) Copyright 2014 Phil Morris              
3
4// a "Proof   of Concept" sketch for the Arduino Uno Rev 3 and an MSF Clock module      
5//   No apologies given for the messy code as this is a sketch simply to show       
6//   some ideas around decoding MSF time signals. The code takes account of Leep        
7//   seconds and performs full parity checking. A simple output is provided to the      
8//   Serial port at 9600 baud. BST/GMT is decoded along with UTC & DUT difference.      
9//   even partial data reception can produce a valid output as long as seconds 17 thru   59     
10// are received correctly.                    
11//                                              
12//   For diagnostic purposes, the minimum and maximum pulse lengths are also displayed   in ms  
13//                          
14// You may use, modify and/or distribute   this sketch as long as you leave this text intact. 
15
16//****************************************************************************************************
17    // MSF 60KHz Interrupt driven decode program to feed Lazarus/Delphi(Pascal) high   level decode program.
18   // John Garrett 2020.
19   // Modified from a part   of sketch copyright of Phil Morris.
20
21   // the msf transmitter is switched   off for brief intervals (on-off keying) near the beginning of each second
22   //   to encode the current time and date. When carrier is low data is active. Every second   the 
23   // carrier goes low to signify data. Apart from the first second every   second consists
24   // of a 100ms pulse. This is followed by no data when the   carrier is high for 900ms or
25   // another 100ms pulse giving 200ms all together   signifying an A data. Or an extra 100ms
26   // pulse making 300ms in all, giving   an A and B data. For B data only the second pulse
27   // consists of the statuary   100ms low followed by 100ms high followed by another 100ms low
28   // beginning   of every minute the first second consists of 500ms low followed by 500ms high.
29    // each second pulse apart from the minute marker should be up to 300ms low and   up to 900ms high.
30   // the data during the current minute is for the following   minute of time.
31
32const  int CARRIER_OFF = LOW;  // this constant is set for   non-inverted MSF receiver output ie Carrier_Off equals a low. 
33                               //   invert it if your output = HIGH for carrier off.
34
35const int MSFPIN = 3;            //   the Arduino pin for the MSF device (2 or 3).
36
37volatile long pulseStart = 0;         // milliseconds when start of pulse occurred.                      
38volatile   long pulseEnd = 0;          // milliseconds when pulse ended.
39volatile long lastPulseStart   = 0;    // the previous pulse start value.  
40volatile int pulseLength = 0;        //   length of pulse/100 as an integer.
41volatile bool bitBonly = false;      // set   if a 'B' only pulse detected.
42volatile bool printTime = false;
43volatile bool   sync = false;           //true if valid start pulse.
44volatile int counter = 0;                // seconds counter.
45volatile int LED_PIN = 13;          // pin   LED is attached (optional).
46volatile int minMaxPulse = 0;       // actual length   in millis.
47
48void setup() {
49  Serial.begin(9600);               // start   the Serial port
50  attachInterrupt(MSFPIN - 2, MsfPulse, CHANGE);  // set the   interrupt
51  pinMode(LED_PIN,OUTPUT);              // configue the LED pin 
52}
53
54void   loop()
55{
56}
57
58void MsfPulse()  // interrupt routine which is called every   time the MSF receiver output changes state
59{
60// This routine is called every   time the selected Interrupt pin changes state. If it is the start of
61// a pulse,   the millis count is stored in "pulseStart". If it is the end of a pulse the millis   count
62// is stored in "pulseEnd". "pulseLength" is the result in millis/100.   The data is processed to produce an
63// integer 1 - 5 representing 100 - 500 ms   pulses (no "4" is decoded).If pulselength = 5 then the sync flag becomes true
64//   counter is then = '0'. Once counter reaches == '59' the sync flag becomes false.   
65// 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 
66// after the last start pulse   it must be a double 100ms pulse second resulting a bitBonly flag being true.
67
68   
69  bitBonly = false;            // clear the bitOnly flag
70  bool pinState   = digitalRead(MSFPIN);  // get the state of the interrupt pin
71  
72  // is this   a pulse start?
73
74 if (pinState == CARRIER_OFF) // pulse or sub-pulse has started,   carrier going low
75  {    
76    pulseStart = millis();    // pulseStart = current   millis everytime the MSFPIN goes low (carrier going low)   
77    digitalWrite(LED_PIN,HIGH);   // turn on LED
78    counter = counter +1;       
79    if (printTime == true   && counter == 60)       
80      {
81        Serial.print('6');       // signify   to Lazarus to display time scenario
82          if (counter <= 9) Serial.print('0');    //too satisfy Lazarus program
83          Serial.print(counter);                      
84           Serial.print(".");           
85      }  
86    return;            //   until there's a another interrupt change
87  }    
88  
89
90 // is it a pulse   end?
91
92 if(pinState != CARRIER_OFF)               // pulse end, MSFPIN goes   high (carrier going high)
93  {        
94    pulseEnd = millis();                   //   set the pulse end ms,the MSFPIN goes high   
95    minMaxPulse = pulseEnd - pulseStart;    // actual length in millis    
96    pulseLength = abs((minMaxPulse) / 100);        // get the pulse length in ms/100        
97    pulseStart = millis();                //   set the pulseStart to current millis
98    if (minMaxPulse < 90) return;             //   the pulse is too short ("noise"), return    
99    if (counter == 59 && sync)   pulseLength = 4;      // 59th second    
100    
101// if the sequence was 100ms   off + 100ms on + 100ms off, this is a 'B' only bit
102// so, if this start pulse   is less than 300ms after the last start pulse it must be
103// a double 100ms pulse   second
104
105    if(pulseStart - lastPulseStart < 300) bitBonly = true;  // this   is a 'B' bit
106    lastPulseStart = pulseStart;        // keep the last pulse start   ms count
107    digitalWrite(LED_PIN,LOW);          // turn off the LED    
108   }
109
110 switch(pulseLength) // start processing the valid pulse
111  {
112    case   5: // check for start pulse i.e. 500ms  (11111)
113      {
114        if(minMaxPulse   > 490 && minMaxPulse < 550)
115        {
116          sync = true;
117          printTime   = false;
118          counter = 0;
119          Serial.print('5');       // signify   to Lazarus a sync scenario
120          if (counter <= 9) Serial.print('0');   //too   satisfy Lazarus program
121          Serial.print(counter);                      
122           Serial.print(".");
123        }       
124        break;
125      }
126
127     case 4:  // 59th second tell Lazarus to compute time (100)
128      {        
129         sync = false;
130        Serial.print('4');       // signify to Lazarus   to compute time
131        if (counter <= 9) Serial.print('0');   //too satisfy   Lazarus program
132        Serial.print(counter);                      
133        Serial.print(".");
134         printTime = true;                
135        break;
136      }
137
138    case   3:  // check for 300ms pulse, this is an 'A' + 'B' bit case   (111)  
139     {
140         if(minMaxPulse > 290 && minMaxPulse < 350 && sync)                      
141          {           
142           Serial.print('3');       // signify to Lazarus   a 'A + B' data scenario
143           if (counter <= 9) Serial.print('0');   //too   satisfy Lazarus program
144           Serial.print(counter);                      
145            Serial.print(".");
146         }
147      break;    
148     }
149
150     case 2:  // check for 200ms pulse, this is an 'A' bit case   (110)
151      {
152         if(minMaxPulse > 190 && minMaxPulse < 250 && sync)                
153         {            
154           Serial.print('2');       // signify to Lazarus a 'A' data   scenario
155           if (counter <= 9) Serial.print('0');   //too satisfy Lazarus   program
156           Serial.print(counter);                      
157           Serial.print(".");
158          }
159        break;              
160      }
161
162    case 1:  // check   for 100ms pulse   (101 or  100)
163      {
164        if(minMaxPulse > 90 && minMaxPulse   < 150 && sync)        
165          {                        
166            if(bitBonly)
167               {
168               counter = counter-1;   // to prevent a double   count 'B' data only
169               Serial.print('1');       // signify to Lazarus   a 'B' data scenario
170               if (counter <= 9) Serial.print('0');   //too   satisfy Lazarus program
171               Serial.print(counter);                      
172                Serial.print(".");
173              }
174            else
175              {                
176               Serial.print('0');       // signify to Lazarus   a 'No' data scenario
177               if (counter <= 9) Serial.print('0');   //too   satisfy Lazarus program
178               Serial.print(counter);                      
179                Serial.print('.');
180              }
181          }   
182        break;
183       }
184  
185  }
186 
187}
188

//**************************************************************************************************
//   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;
       }
  
  }
 
}

Lazarus Pascal source file

pascal

Pascal source file

1unit mfs60;
2
3{$mode objfpc}{$H+}
4
5interface
6
7uses
8  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls,
9  StrUtils,Controls.SegmentDisplay, Controls.Blinker, CPort;
10
11
12type
13
14  { TForm1 }
15
16  TForm1 = class(TForm)
17    BlinkerBlue: TBlinker;
18    BlinkerGreen:  TBlinker;
19    BlinkerPurple: TBlinker;
20    BlinkerRed: TBlinker;
21    BlinkerWhite:  TBlinker;
22    BlinkerYellow: TBlinker;
23    ComPort4: TComPort;
24    ImageList1:  TImageList;
25    LabelBST: TLabel;
26    LabelBstImm: TLabel;
27    LabelPEBits:  TLabel;
28    LabelSync: TLabel;
29    LabelParity: TLabel;
30    LabelComPort:  TLabel;
31    LabelDay: TLabel;
32    LabelDayName: TLabel;
33    LabelDow: TLabel;
34    LabelDut: TLabel;
35    LabelDutms: TLabel;
36    LabelMonth: TLabel;
37    LabelSeconds: TLabel;
38    LabelTime: TLabel;
39    LabelYear: TLabel;
40    RadioButtonDutMinus: TRadioButton;
41    RadioButtonDutPlus: TRadioButton;
42    SegmentDisplayDay: TSegmentDisplay;
43    SegmentDisplayDow: TSegmentDisplay;
44    SegmentDisplayDut: TSegmentDisplay;
45    SegmentDisplayMonth: TSegmentDisplay;
46    SegmentDisplaySeconds: TSegmentDisplay;
47    SegmentDisplayTime: TSegmentDisplay;
48    SegmentDisplayYear: TSegmentDisplay;
49
50    procedure Setup(Sender: TObject);
51    procedure Close(Sender: TObject; var CloseAction: TCloseAction);
52    procedure  DataInput(Sender: TObject; Count: Integer);
53
54  private
55         procedure  DataSort;
56         function Dut1(start,finish:integer):string;
57         function  Year:string;
58         function Month:string;
59         function Day: string;
60         function DOW: string;
61         function Time:string;
62         function  BcdToStr(bit,count:integer):string;
63         function ParityCheck(Sbit,count,Pbit:integer):boolean;
64  public
65
66  end;
67
68var
69  Form1: TForm1;
70  bufferA, bufferB: array[0..59]  of integer;
71  Strbuff: string;
72  Sync: Boolean;
73  Bst: Integer;
74
75implementation
76
77{$R  *.lfm}
78
79{ TForm1 }
80
81procedure TForm1.Setup(Sender: TObject); //Form  create event
82begin
83     SegmentDisplayDay.Text:= '';
84     SegmentDisplayMonth.Text:=  '';
85     SegmentDisplayYear.Text:= '';
86     SegmentDisplayDow.Text:= '';
87     SegmentDisplayTime.Text:= '';
88     SegmentDisplaySeconds.Text:= '';
89     SegmentDisplayDut.Text:= '';
90     LabelDayName.Caption:='';
91     BlinkerYellow.IsOn:=  false;
92     BlinkerPurple.IsOn:= false;
93     BlinkerGreen.IsOn:= false;
94     BlinkerRed.Ison:= false;
95     BlinkerBlue.Ison:= false;
96     LabelPEBits.Visible:=  false;
97     RadioButtonDutPlus.Checked:= false;
98     RadioButtonDutMinus.Checked:=  false;
99     Strbuff:='';
100     Sync:= false;
101     Bst:= 0;
102
103     ComPort4.LoadSettings(stIniFile,'C:\\ComPortSettings.ini');
104
105     if not ComPort4.Connected then
106  begin
107    try
108      ComPort4.Open;
109    except
110      ShowMessage('Unable to open COM port.');
111    end;
112  end;
113  if ComPort4.Connected then
114      BlinkerBlue.IsOn:= true
115    else
116    BlinkerBlue.IsOn:=  false;
117
118end;
119
120
121procedure TForm1.Close(Sender: TObject; var CloseAction:  TCloseAction);
122begin
123     ComPort4.Close;
124     CloseAction:= caFree;
125end;
126
127procedure  TForm1.DataInput(Sender: TObject; Count: Integer);
128var
129  Str, s: String;
130begin
131  // Receives  msf data from Arduino.
132  Str:= '';
133  ComPort4.ReadStr(Str,  Count);
134  Strbuff:= Strbuff + Str;  //Save in Global Buffer
135  s:= RightStr(Str,1);
136  if s = '.' then  DataSort;
137end;
138
139procedure TForm1.DataSort;
140var
141  secpointer,counter,error: string;
142  i,j,n: integer;
143
144begin
145  secpointer:=  LeftStr(Strbuff,1);
146 counter:= MidStr(Strbuff,2,2);
147 if counter = '60' then  counter := '00';
148 j:= StrToInt(secpointer);
149 n:= StrToInt(counter);
150 SegmentDisplaySeconds.Text:=  counter;
151
152 if odd(n) then BlinkerWhite.IsOn:= true //switch secs indicator  on/off
153 else
154 BlinkerWhite.IsOn:= false;
155
156
157 Case j of
158   6: begin                                 //show time at 00
159        SegmentDisplayDut.Text:=  Dut1(1,8);
160        SegmentDisplayDut.Text:= Dut1(9,16);
161        SegmentDisplayYear.Text:=  Year;
162        SegmentDisplayMonth.Text:= Month;
163        SegmentDisplayDay.Text:=  Day;
164        SegmentDisplayDow.Text:= LeftStr(DOW,1);
165        LabelDayName.Caption:=  MidStr(DOW,2,(Length(DOW)-1));
166        SegmentDisplayTime.Text:= Time;
167
168        if Bst = 0 then                    //GMT Time
169        begin
170          BlinkerYellow.IsOn:=  false;
171          BlinkerPurple.IsOn:= false;
172        end;
173
174        if  Bst = 1 then                   //BST imminent
175        begin
176          BlinkerYellow.IsOn:=  false;
177          BlinkerPurple.IsOn:= true;
178        end;
179
180        if  Bst = 2 then
181        begin                  //BST Time
182          BlinkerYellow.IsOn:=  true;
183          BlinkerPurple.IsOn:= false;
184        end;
185
186        for  i:= 0 to 59 do  // Clear time Buffers
187        begin
188          bufferA[i]:=  0;
189          bufferB[i]:= 0;
190        end;
191
192      end;
193
194   5: begin
195        Sync:= true;
196        BlinkerGreen.IsOn:= true;
197        bufferA[n]:=  5;
198        bufferB[n]:= 5;
199      end;
200
201  4: begin                  //  59 seconds
202        if Sync then
203        begin
204          Sync:= false;
205          BlinkerGreen.IsOn:= false;
206
207          Bst:= 0;                           //  Reset to GMT flag
208          if bufferB[53] = 1 then Bst:= 1;   //BST imminent  flag
209          if bufferB[58] = 1 then Bst:= 2;  // BST flag
210
211           error:=  '';
212
213          if not ParityCheck(17,8,54) then error:= '17 to 24, ';
214          if not ParityCheck(25,11,55)then error:= error + '25 to 35, ';
215          if  not ParityCheck(36,3,56) then error:= error + '36 to 38, ';
216          if not  ParityCheck(39,13,57)then error:= error + '39 to 51';
217
218          If Length(error)  = 0 then
219            begin
220              BlinkerRed.IsON:= false;
221              LabelPEBits.Visible:=  false;
222              LabelPEBits.Caption:= '';
223            end
224            else
225            begin
226              BlinkerRed.IsON:= true;
227              LabelPEBits.Visible:=  true;
228              LabelPEBits.Caption:= 'Bits '+ error;
229            end;
230
231
232          bufferA[n]:= 4;
233          bufferB[n]:= 4;
234
235        end;
236
237     end;
238
239  3: begin              //A & B pulse
240        if Sync then
241        begin
242          bufferA[n]:= 1;
243          bufferB[n]:= 1;
244        end;
245      end;
246  2: begin              //A pulse only
247        if Sync then
248        begin
249          bufferA[n]:= 1;
250          bufferB[n]:= 0;
251        end;
252      end;
253  1: begin             //B pulse only
254        if Sync then
255        begin
256          bufferA[n]:= 0;
257          bufferB[n]:= 1;
258        end;
259      end;
260  0: begin             //No A or B pulse
261        if Sync then
262        begin
263          bufferA[n]:= 0;
264          bufferB[n]:= 0;
265        end;
266      end;
267
268  end;
269 If RightStr(Strbuff,1)= '.' then  Strbuff:= '';
270end;
271
272
273function  TForm1.Dut1(start,finish:integer):string;
274var
275  j,n:integer;
276begin
277  RadioButtonDutPlus.Checked:= false;
278  RadioButtonDutMinus.Checked:= false;
279
280  j:= 0;
281  for n := start to finish do
282  begin
283    if bufferB[n] = 1 then  j := j+1;
284  end;
285
286  if (finish = 8) and (j > 0) then RadioButtonDutPlus.Checked:=  True;
287  if (finish = 16) and (j > 0) then RadioButtonDutMinus.Checked:= True;
288
289  j:= j*100;
290  Result:= IntToStr(j);
291end;
292
293function TForm1.Year:string;
294var
295  s,t: string;
296begin
297  s:= BcdToStr(20,4);
298  t:= BcdToStr(24,4);
299  Result:=  s + t;
300end;
301
302function TForm1.Month:string;
303var
304  s,t: string;
305begin
306  s:= BcdToStr(25,1);
307  t:= BcdToStr(29,4);
308  Result:= s + t;
309end;
310
311function  TForm1.Day:string;
312var
313  s,t: string;
314begin
315  s:= BcdToStr(31,2);
316  t:= BcdToStr(35,4);
317  Result:= s + t;
318end;
319
320function TForm1.DOW:string;
321var
322  i: integer;
323  s: string;
324begin
325  s:= BcdToStr(38,3);
326  i:= StrToInt(s);
327  Case i of
328    0: Result:= s + 'Sunday';
329    1: Result:= s + 'Monday';
330    2: Result:= s + 'Tuesday';
331    3: Result:= s + 'Wednesday';
332    4: Result:=  s + 'Thursday';
333    5: Result:= s + 'Friday';
334    6: Result:= s + 'Saturday';
335  end;
336end;
337
338function TForm1.Time:string;
339var
340  s,t,u,v: string;
341begin
342  s:= BcdToStr(40,2);
343  t:= BcdToStr(44,4);
344  u:= BcdToStr(47,3);
345  v:=  BcdToStr(51,4);
346  Result := s + t + u + v;
347end;
348
349function TForm1.BcdToStr(bit,count:integer):string;
350var
351  total: integer;
352begin
353  total:= 0;
354  while count > 0 do
355  begin
356    if bufferA[bit] = 1 then total:= 1;
357    count:= count-1;
358    if count  = 0 then break;
359    if bufferA[bit-1] = 1 then total:= total + 2;
360    count:=  count-1;
361    if count = 0 then break;
362    if bufferA[bit-2] = 1 then total:=  total + 4;
363    count:= count-1;
364    if count = 0 then break;
365    if bufferA[bit-3]  = 1 then total:= total + 8;
366    count:= count-1;
367  end;
368  Result:= IntToStr(total);
369end;
370
371function  TForm1.ParityCheck(Sbit,count,Pbit:integer):boolean;
372var
373  total,n: integer;
374begin
375  total:= 0;
376  for n:= 0 to count -1 do
377  if bufferA[Sbit + n] = 1 then total  := total + 1;
378
379  total:= total + bufferB[Pbit];
380
381  if odd(total) then  Result:= true
382  else
383  Result:= false;
384end;
385
386end.
387
388

unit mfs60;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls,
  StrUtils,Controls.SegmentDisplay, Controls.Blinker, CPort;


type

  { TForm1 }

  TForm1 = class(TForm)
    BlinkerBlue: TBlinker;
    BlinkerGreen:  TBlinker;
    BlinkerPurple: TBlinker;
    BlinkerRed: TBlinker;
    BlinkerWhite:  TBlinker;
    BlinkerYellow: TBlinker;
    ComPort4: TComPort;
    ImageList1:  TImageList;
    LabelBST: TLabel;
    LabelBstImm: TLabel;
    LabelPEBits:  TLabel;
    LabelSync: TLabel;
    LabelParity: TLabel;
    LabelComPort:  TLabel;
    LabelDay: TLabel;
    LabelDayName: TLabel;
    LabelDow: TLabel;
    LabelDut: TLabel;
    LabelDutms: TLabel;
    LabelMonth: TLabel;
    LabelSeconds: TLabel;
    LabelTime: TLabel;
    LabelYear: TLabel;
    RadioButtonDutMinus: TRadioButton;
    RadioButtonDutPlus: TRadioButton;
    SegmentDisplayDay: TSegmentDisplay;
    SegmentDisplayDow: TSegmentDisplay;
    SegmentDisplayDut: TSegmentDisplay;
    SegmentDisplayMonth: TSegmentDisplay;
    SegmentDisplaySeconds: TSegmentDisplay;
    SegmentDisplayTime: TSegmentDisplay;
    SegmentDisplayYear: TSegmentDisplay;

    procedure Setup(Sender: TObject);
    procedure Close(Sender: TObject; var CloseAction: TCloseAction);
    procedure  DataInput(Sender: TObject; Count: Integer);

  private
         procedure  DataSort;
         function Dut1(start,finish:integer):string;
         function  Year:string;
         function Month:string;
         function Day: string;
         function DOW: string;
         function Time:string;
         function  BcdToStr(bit,count:integer):string;
         function ParityCheck(Sbit,count,Pbit:integer):boolean;
  public

  end;

var
  Form1: TForm1;
  bufferA, bufferB: array[0..59]  of integer;
  Strbuff: string;
  Sync: Boolean;
  Bst: Integer;

implementation

{$R  *.lfm}

{ TForm1 }

procedure TForm1.Setup(Sender: TObject); //Form  create event
begin
     SegmentDisplayDay.Text:= '';
     SegmentDisplayMonth.Text:=  '';
     SegmentDisplayYear.Text:= '';
     SegmentDisplayDow.Text:= '';
     SegmentDisplayTime.Text:= '';
     SegmentDisplaySeconds.Text:= '';
     SegmentDisplayDut.Text:= '';
     LabelDayName.Caption:='';
     BlinkerYellow.IsOn:=  false;
     BlinkerPurple.IsOn:= false;
     BlinkerGreen.IsOn:= false;
     BlinkerRed.Ison:= false;
     BlinkerBlue.Ison:= false;
     LabelPEBits.Visible:=  false;
     RadioButtonDutPlus.Checked:= false;
     RadioButtonDutMinus.Checked:=  false;
     Strbuff:='';
     Sync:= false;
     Bst:= 0;

     ComPort4.LoadSettings(stIniFile,'C:\\ComPortSettings.ini');

     if not ComPort4.Connected then
  begin
    try
      ComPort4.Open;
    except
      ShowMessage('Unable to open COM port.');
    end;
  end;
  if ComPort4.Connected then
      BlinkerBlue.IsOn:= true
    else
    BlinkerBlue.IsOn:=  false;

end;


procedure TForm1.Close(Sender: TObject; var CloseAction:  TCloseAction);
begin
     ComPort4.Close;
     CloseAction:= caFree;
end;

procedure  TForm1.DataInput(Sender: TObject; Count: Integer);
var
  Str, s: String;
begin
  // Receives  msf data from Arduino.
  Str:= '';
  ComPort4.ReadStr(Str,  Count);
  Strbuff:= Strbuff + Str;  //Save in Global Buffer
  s:= RightStr(Str,1);
  if s = '.' then  DataSort;
end;

procedure TForm1.DataSort;
var
  secpointer,counter,error: string;
  i,j,n: integer;

begin
  secpointer:=  LeftStr(Strbuff,1);
 counter:= MidStr(Strbuff,2,2);
 if counter = '60' then  counter := '00';
 j:= StrToInt(secpointer);
 n:= StrToInt(counter);
 SegmentDisplaySeconds.Text:=  counter;

 if odd(n) then BlinkerWhite.IsOn:= true //switch secs indicator  on/off
 else
 BlinkerWhite.IsOn:= false;


 Case j of
   6: begin                                 //show time at 00
        SegmentDisplayDut.Text:=  Dut1(1,8);
        SegmentDisplayDut.Text:= Dut1(9,16);
        SegmentDisplayYear.Text:=  Year;
        SegmentDisplayMonth.Text:= Month;
        SegmentDisplayDay.Text:=  Day;
        SegmentDisplayDow.Text:= LeftStr(DOW,1);
        LabelDayName.Caption:=  MidStr(DOW,2,(Length(DOW)-1));
        SegmentDisplayTime.Text:= Time;

        if Bst = 0 then                    //GMT Time
        begin
          BlinkerYellow.IsOn:=  false;
          BlinkerPurple.IsOn:= false;
        end;

        if  Bst = 1 then                   //BST imminent
        begin
          BlinkerYellow.IsOn:=  false;
          BlinkerPurple.IsOn:= true;
        end;

        if  Bst = 2 then
        begin                  //BST Time
          BlinkerYellow.IsOn:=  true;
          BlinkerPurple.IsOn:= false;
        end;

        for  i:= 0 to 59 do  // Clear time Buffers
        begin
          bufferA[i]:=  0;
          bufferB[i]:= 0;
        end;

      end;

   5: begin
        Sync:= true;
        BlinkerGreen.IsOn:= true;
        bufferA[n]:=  5;
        bufferB[n]:= 5;
      end;

  4: begin                  //  59 seconds
        if Sync then
        begin
          Sync:= false;
          BlinkerGreen.IsOn:= false;

          Bst:= 0;                           //  Reset to GMT flag
          if bufferB[53] = 1 then Bst:= 1;   //BST imminent  flag
          if bufferB[58] = 1 then Bst:= 2;  // BST flag

           error:=  '';

          if not ParityCheck(17,8,54) then error:= '17 to 24, ';
          if not ParityCheck(25,11,55)then error:= error + '25 to 35, ';
          if  not ParityCheck(36,3,56) then error:= error + '36 to 38, ';
          if not  ParityCheck(39,13,57)then error:= error + '39 to 51';

          If Length(error)  = 0 then
            begin
              BlinkerRed.IsON:= false;
              LabelPEBits.Visible:=  false;
              LabelPEBits.Caption:= '';
            end
            else
            begin
              BlinkerRed.IsON:= true;
              LabelPEBits.Visible:=  true;
              LabelPEBits.Caption:= 'Bits '+ error;
            end;


          bufferA[n]:= 4;
          bufferB[n]:= 4;

        end;

     end;

  3: begin              //A & B pulse
        if Sync then
        begin
          bufferA[n]:= 1;
          bufferB[n]:= 1;
        end;
      end;
  2: begin              //A pulse only
        if Sync then
        begin
          bufferA[n]:= 1;
          bufferB[n]:= 0;
        end;
      end;
  1: begin             //B pulse only
        if Sync then
        begin
          bufferA[n]:= 0;
          bufferB[n]:= 1;
        end;
      end;
  0: begin             //No A or B pulse
        if Sync then
        begin
          bufferA[n]:= 0;
          bufferB[n]:= 0;
        end;
      end;

  end;
 If RightStr(Strbuff,1)= '.' then  Strbuff:= '';
end;


function  TForm1.Dut1(start,finish:integer):string;
var
  j,n:integer;
begin
  RadioButtonDutPlus.Checked:= false;
  RadioButtonDutMinus.Checked:= false;

  j:= 0;
  for n := start to finish do
  begin
    if bufferB[n] = 1 then  j := j+1;
  end;

  if (finish = 8) and (j > 0) then RadioButtonDutPlus.Checked:=  True;
  if (finish = 16) and (j > 0) then RadioButtonDutMinus.Checked:= True;

  j:= j*100;
  Result:= IntToStr(j);
end;

function TForm1.Year:string;
var
  s,t: string;
begin
  s:= BcdToStr(20,4);
  t:= BcdToStr(24,4);
  Result:=  s + t;
end;

function TForm1.Month:string;
var
  s,t: string;
begin
  s:= BcdToStr(25,1);
  t:= BcdToStr(29,4);
  Result:= s + t;
end;

function  TForm1.Day:string;
var
  s,t: string;
begin
  s:= BcdToStr(31,2);
  t:= BcdToStr(35,4);
  Result:= s + t;
end;

function TForm1.DOW:string;
var
  i: integer;
  s: string;
begin
  s:= BcdToStr(38,3);
  i:= StrToInt(s);
  Case i of
    0: Result:= s + 'Sunday';
    1: Result:= s + 'Monday';
    2: Result:= s + 'Tuesday';
    3: Result:= s + 'Wednesday';
    4: Result:=  s + 'Thursday';
    5: Result:= s + 'Friday';
    6: Result:= s + 'Saturday';
  end;
end;

function TForm1.Time:string;
var
  s,t,u,v: string;
begin
  s:= BcdToStr(40,2);
  t:= BcdToStr(44,4);
  u:= BcdToStr(47,3);
  v:=  BcdToStr(51,4);
  Result := s + t + u + v;
end;

function TForm1.BcdToStr(bit,count:integer):string;
var
  total: integer;
begin
  total:= 0;
  while count > 0 do
  begin
    if bufferA[bit] = 1 then total:= 1;
    count:= count-1;
    if count  = 0 then break;
    if bufferA[bit-1] = 1 then total:= total + 2;
    count:=  count-1;
    if count = 0 then break;
    if bufferA[bit-2] = 1 then total:=  total + 4;
    count:= count-1;
    if count = 0 then break;
    if bufferA[bit-3]  = 1 then total:= total + 8;
    count:= count-1;
  end;
  Result:= IntToStr(total);
end;

function  TForm1.ParityCheck(Sbit,count,Pbit:integer):boolean;
var
  total,n: integer;
begin
  total:= 0;
  for n:= 0 to count -1 do
  if bufferA[Sbit + n] = 1 then total  := total + 1;

  total:= total + bufferB[Pbit];

  if odd(total) then  Result:= true
  else
  Result:= false;
end;

end.

Arduino-Lazarus_MSF Clock

c_cpp

Arduino interrupt sketch

1//**************************************************************************************************
2//  Serial MSF Test Clock (C) Copyright 2014 Phil Morris              
3
4// a "Proof  of Concept" sketch for the Arduino Uno Rev 3 and an MSF Clock module      
5//  No apologies given for the messy code as this is a sketch simply to show       
6//  some ideas around decoding MSF time signals. The code takes account of Leep        
7//  seconds and performs full parity checking. A simple output is provided to the      
8//  Serial port at 9600 baud. BST/GMT is decoded along with UTC & DUT difference.      
9//  even partial data reception can produce a valid output as long as seconds 17 thru  59     
10// are received correctly.                    
11//                                              
12//  For diagnostic purposes, the minimum and maximum pulse lengths are also displayed  in ms  
13//                          
14// You may use, modify and/or distribute  this sketch as long as you leave this text intact. 
15
16//****************************************************************************************************
17   // MSF 60KHz Interrupt driven decode program to feed Lazarus/Delphi(Pascal) high  level decode program.
18   // John Garrett 2020.
19   // Modified from a part  of sketch copyright of Phil Morris.
20
21   // the msf transmitter is switched  off for brief intervals (on-off keying) near the beginning of each second
22   //  to encode the current time and date. When carrier is low data is active. Every second  the 
23   // carrier goes low to signify data. Apart from the first second every  second consists
24   // of a 100ms pulse. This is followed by no data when the  carrier is high for 900ms or
25   // another 100ms pulse giving 200ms all together  signifying an A data. Or an extra 100ms
26   // pulse making 300ms in all, giving  an A and B data. For B data only the second pulse
27   // consists of the statuary  100ms low followed by 100ms high followed by another 100ms low
28   // beginning  of every minute the first second consists of 500ms low followed by 500ms high.
29   // each second pulse apart from the minute marker should be up to 300ms low and  up to 900ms high.
30   // the data during the current minute is for the following  minute of time.
31
32const  int CARRIER_OFF = LOW;  // this constant is set for  non-inverted MSF receiver output ie Carrier_Off equals a low. 
33                               //  invert it if your output = HIGH for carrier off.
34
35const int MSFPIN = 3;            //  the Arduino pin for the MSF device (2 or 3).
36
37volatile long pulseStart = 0;        // milliseconds when start of pulse occurred.                      
38volatile  long pulseEnd = 0;          // milliseconds when pulse ended.
39volatile long lastPulseStart  = 0;    // the previous pulse start value.  
40volatile int pulseLength = 0;        //  length of pulse/100 as an integer.
41volatile bool bitBonly = false;      // set  if a 'B' only pulse detected.
42volatile bool printTime = false;
43volatile bool  sync = false;           //true if valid start pulse.
44volatile int counter = 0;               // seconds counter.
45volatile int LED_PIN = 13;          // pin  LED is attached (optional).
46volatile int minMaxPulse = 0;       // actual length  in millis.
47
48void setup() {
49  Serial.begin(9600);               // start  the Serial port
50  attachInterrupt(MSFPIN - 2, MsfPulse, CHANGE);  // set the  interrupt
51  pinMode(LED_PIN,OUTPUT);              // configue the LED pin 
52}
53
54void  loop()
55{
56}
57
58void MsfPulse()  // interrupt routine which is called every  time the MSF receiver output changes state
59{
60// This routine is called every  time the selected Interrupt pin changes state. If it is the start of
61// a pulse,  the millis count is stored in "pulseStart". If it is the end of a pulse the millis  count
62// is stored in "pulseEnd". "pulseLength" is the result in millis/100.  The data is processed to produce an
63// integer 1 - 5 representing 100 - 500 ms  pulses (no "4" is decoded).If pulselength = 5 then the sync flag becomes true
64//  counter is then = '0'. Once counter reaches == '59' the sync flag becomes false.  
65// 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 
66// after the last start pulse  it must be a double 100ms pulse second resulting a bitBonly flag being true.
67
68  
69  bitBonly = false;            // clear the bitOnly flag
70  bool pinState  = digitalRead(MSFPIN);  // get the state of the interrupt pin
71  
72  // is this  a pulse start?
73
74 if (pinState == CARRIER_OFF) // pulse or sub-pulse has started,  carrier going low
75  {    
76    pulseStart = millis();    // pulseStart = current  millis everytime the MSFPIN goes low (carrier going low)   
77    digitalWrite(LED_PIN,HIGH);  // turn on LED
78    counter = counter +1;       
79    if (printTime == true  && counter == 60)       
80      {
81        Serial.print('6');       // signify  to Lazarus to display time scenario
82          if (counter <= 9) Serial.print('0');   //too satisfy Lazarus program
83          Serial.print(counter);                      
84          Serial.print(".");           
85      }  
86    return;            //  until there's a another interrupt change
87  }    
88  
89
90 // is it a pulse  end?
91
92 if(pinState != CARRIER_OFF)               // pulse end, MSFPIN goes  high (carrier going high)
93  {        
94    pulseEnd = millis();                   //  set the pulse end ms,the MSFPIN goes high   
95    minMaxPulse = pulseEnd - pulseStart;   // actual length in millis    
96    pulseLength = abs((minMaxPulse) / 100);       // get the pulse length in ms/100        
97    pulseStart = millis();                //  set the pulseStart to current millis
98    if (minMaxPulse < 90) return;             //  the pulse is too short ("noise"), return    
99    if (counter == 59 && sync)  pulseLength = 4;      // 59th second    
100    
101// if the sequence was 100ms  off + 100ms on + 100ms off, this is a 'B' only bit
102// so, if this start pulse  is less than 300ms after the last start pulse it must be
103// a double 100ms pulse  second
104
105    if(pulseStart - lastPulseStart < 300) bitBonly = true;  // this  is a 'B' bit
106    lastPulseStart = pulseStart;        // keep the last pulse start  ms count
107    digitalWrite(LED_PIN,LOW);          // turn off the LED    
108  }
109
110 switch(pulseLength) // start processing the valid pulse
111  {
112    case  5: // check for start pulse i.e. 500ms  (11111)
113      {
114        if(minMaxPulse  > 490 && minMaxPulse < 550)
115        {
116          sync = true;
117          printTime  = false;
118          counter = 0;
119          Serial.print('5');       // signify  to Lazarus a sync scenario
120          if (counter <= 9) Serial.print('0');   //too  satisfy Lazarus program
121          Serial.print(counter);                      
122          Serial.print(".");
123        }       
124        break;
125      }
126
127    case 4:  // 59th second tell Lazarus to compute time (100)
128      {        
129        sync = false;
130        Serial.print('4');       // signify to Lazarus  to compute time
131        if (counter <= 9) Serial.print('0');   //too satisfy  Lazarus program
132        Serial.print(counter);                      
133        Serial.print(".");
134        printTime = true;                
135        break;
136      }
137
138    case  3:  // check for 300ms pulse, this is an 'A' + 'B' bit case   (111)  
139     {
140        if(minMaxPulse > 290 && minMaxPulse < 350 && sync)                      
141         {           
142           Serial.print('3');       // signify to Lazarus  a 'A + B' data scenario
143           if (counter <= 9) Serial.print('0');   //too  satisfy Lazarus program
144           Serial.print(counter);                      
145           Serial.print(".");
146         }
147      break;    
148     }
149
150    case 2:  // check for 200ms pulse, this is an 'A' bit case   (110)
151      {
152        if(minMaxPulse > 190 && minMaxPulse < 250 && sync)                
153         {           
154           Serial.print('2');       // signify to Lazarus a 'A' data  scenario
155           if (counter <= 9) Serial.print('0');   //too satisfy Lazarus  program
156           Serial.print(counter);                      
157           Serial.print(".");
158         }
159        break;              
160      }
161
162    case 1:  // check  for 100ms pulse   (101 or  100)
163      {
164        if(minMaxPulse > 90 && minMaxPulse  < 150 && sync)        
165          {                        
166            if(bitBonly)
167              {
168               counter = counter-1;   // to prevent a double  count 'B' data only
169               Serial.print('1');       // signify to Lazarus  a 'B' data scenario
170               if (counter <= 9) Serial.print('0');   //too  satisfy Lazarus program
171               Serial.print(counter);                      
172               Serial.print(".");
173              }
174            else
175              {               
176               Serial.print('0');       // signify to Lazarus  a 'No' data scenario
177               if (counter <= 9) Serial.print('0');   //too  satisfy Lazarus program
178               Serial.print(counter);                      
179               Serial.print('.');
180              }
181          }   
182        break;
183      }
184  
185  }
186 
187}
188

//**************************************************************************************************
//  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;
      }
  
  }
 
}

Comments

Only logged in users can leave comments

jongar47

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content