基于PIC WWVB时钟-自动校准时间-原理图-PCB-C程序-转载外国网站 - 圣源电子制作

// **************** Problem Log **************
// 1. Need to fix the display on turn-on so
// that all digits are blanked except the
// seconds count.
//
//
//
//
//
// ***************** Revisions *********************
// Initial working program (N/C) 11/09/2008
//
// Rev. A: 11/11/08 Fixed one-minute error problem
// caused by wwv message "on-time" at the
// start of a new message
#include <system.h>
//Target PIC16F628 configuration word
#pragma DATA _CONFIG, _PWRTE_OFF & _WDT_OFF & _XT_OSC & _CP_OFF
//Set clock frequency
#pragma CLOCK_FREQ 4000000
// variable declarations
char varl@0x0E; // TMR1L register absolute address
char varh@0x0F; // TMR1H register absolute address
// bit patterns for correlation per WWVB description
unsigned long sync = 0xFC000000;
unsigned long one = 0xFFFF0000;
unsigned long zero = 0xFFFFFF80;
unsigned long samples = 0; // input sample register
unsigned long sync_temp;
unsigned char i;
unsigned char j;
unsigned char k;
unsigned char n;
unsigned char sync_count;
unsigned char one_count;
unsigned char zero_count;
unsigned char sync_threshold = 31; // stringent sync threshold
unsigned char bit_threshold = 28; // less stringent bit threshold
unsigned char sync_bit_1;
unsigned char sync_bit_2;
unsigned char sample_flag = 0;
unsigned char seconds = 0;
unsigned char ten_seconds = 0;
unsigned char seconds_counter = 0;
unsigned char seconds_temp = 0;
unsigned char local_hours;
unsigned char wwv_minutes;
unsigned char wwv_ten_minutes;
unsigned char wwv_hours;
unsigned char wwv_ten_hours;
unsigned char error;
unsigned char msg_valid = 0;
unsigned char internal_minutes_counter = 0;
unsigned char internal_ten_min = 0;
unsigned char internal_min = 0;
unsigned char internal_hours = 0;
// *************************** sample() *******************
//
// This routine collects samples from the wwvb receiver data
// output and places them into the sample register. The sample
// register is a FIFO.
//
// Called from: Interrupt service routine
//
// *******************************************
sample()
{
samples >>= 1;
samples.31 = portb.0;
sample_flag = 1;
}
// ************************** end of sample() *****************
// ****************** update_display() *************************
//
// This routine writes minutes, ten minutes, hours, and ten hour
// data to the display drivers.
//
// Parameters
// Entry: minutes, ten_minutes and hours from wwvb or from internal time
// Exit: none
//
// Called from: update_internal_time()
//
// ***************************************************************
void update_display()
{
unsigned char display_hours = 0;
unsigned char display_ten_hours = 0;
// convert hrs back to 2-byte format
if (internal_hours == 0)
display_hours = 2;
if ((internal_hours > 0) && (internal_hours < 10))
display_hours = internal_hours;
if ((internal_hours > 9) && (internal_hours < 13))
{
display_hours = internal_hours - 10;
display_ten_hours = 1;
}
if ((internal_hours > 12) && (internal_hours < 22))
{
display_hours = internal_hours - 12;
display_ten_hours = 0;
}
if ((internal_hours > 21) && (internal_hours <= 23))
{
display_hours = internal_hours - 22;
display_ten_hours = 1;
}
// port a values contain data for the 4511 display drivers
// port b values are addresses for the hct138 1-8 decoder
// to distribute the strobes for the individual display
// digits.
porta = internal_min;
portb.1 = 0;
portb.2 = 1;
portb.3 = 0;
portb.4 = 1;
delay_us(10);
portb.4 = 0;
porta = internal_ten_min;
portb.1 = 1;
portb.2 = 1;
portb.3 = 0;
portb.4 = 1;
delay_us(10);
portb.4 = 0;
porta = display_hours;
portb.1 = 0;
portb.2 = 0;
portb.3 = 1;
portb.4 = 1;
delay_us(10);
portb.4 = 0;
if (display_ten_hours != 1)
porta = 0x0F; // this will cause the 4511 chip to blank the
// ten-hours digit
else
porta = display_ten_hours;
portb.1 = 1;
portb.2 = 0;
portb.3 = 1;
portb.4 = 1;
delay_us(10);
portb.4 = 0;
}
// ************************* end of update_display() *****************
// *********************** update_internal_time() ******************
//
// This routine keeps time either using the internal 32 sample/sec
// time base or wwv received time. The time is in the following format:
//
// internal_minutes: 0-9
// internal_ten_minutes: 0-5
// internal_hours: 0-23
//
// Parameters
// Entry: none
// Exit: none
//
// ******************************************************************
void update_internal_time()
{
unsigned char temp_int_min = 0;
unsigned char temp_internal_ten_minutes = 0;
unsigned char temp_wwv_ten_min = 0;
if (msg_valid == 0)
{
if (internal_minutes_counter < 59)
{
internal_minutes_counter++;
temp_int_min = internal_minutes_counter;
internal_ten_min = 0;
while( temp_int_min > 9)
{
internal_ten_min++;
temp_int_min -= 10;
}
internal_min = temp_int_min;
}
else
{
internal_minutes_counter = 0;
internal_min = 0;
internal_ten_min = 0;
if (internal_hours < 23)
internal_hours++;
else
internal_hours = 0;
}
}
else // msg_valid == 1
{
temp_wwv_ten_min = wwv_ten_minutes;
temp_internal_ten_minutes = 0;
while( temp_wwv_ten_min > 0 )
{
temp_wwv_ten_min--;
temp_internal_ten_minutes += 10;
}
internal_minutes_counter = temp_internal_ten_minutes + wwv_minutes;
internal_min = wwv_minutes;
internal_ten_min = wwv_ten_minutes;
internal_hours = local_hours;
}
update_display();
msg_valid = 0;
}
// ************************* end of update_internal_time *************************
// **********************************************************************************************
// Timer 1 interrupt handler. This interrupt obtains new input data samples 32 times per second
// **********************************************************************************************
void interrupt( void )
{
//Handle timer1 interrupt
if( pir1 & (1<<TMR1IF) )
{
clear_bit( pir1, TMR1IF ); //clear timer 1 interrupt bit
clear_bit( t1con, TMR1ON ); //stop timer 1
// load timer 1 with 0xC304
varh = 0xC3; // 0xC304 is an emperically adjusted
// number to yield 32.0 samples/sec
varl = 0x04;
set_bit( t1con, TMR1ON ); //enable timer 1
sample(); // "input sample routine
// update "seconds" based on 32 sps interrupt rate
if (n < 31)
n++;
else
{
n = 0;
if (seconds_counter < 59)
seconds_counter++;
else
{
seconds_counter = 0;
// propagate unsync internal time
update_internal_time();
}
seconds_temp = seconds_counter;
ten_seconds = 0;
while (seconds_temp > 9)
{
ten_seconds++;
seconds_temp -= 10;
}
seconds = seconds_temp;
porta = seconds;
clear_bit(portb, 1);
clear_bit(portb, 2);
clear_bit(portb, 3);
set_bit(portb, 4);
delay_10us(1);
clear_bit(portb, 4);
porta = ten_seconds;
portb.1 = 1;
portb.2 = 0;
portb.3 = 0;
portb.4 = 1;
delay_10us(1);
portb.4 = 0;
}
}
}
// ******************* end of timer 1 interrupt handler *****************
// ************************** configure_mpu ***********************
//
// Set up the 16F628 internal registers
//
// Parameters
// Entry: none
// Exit: Registers set
//
// Called from: Main()
//
// *****************************************************************
void configure_mpu()
{
//Configure port A
trisa = 0x00; // port a configured as outputs (except porta.5 which is
// input only.
//Configure port B
trisb = 0xC1; // port b 0, 6, and 7 are inputs
// port b 1, 2, 3, 4, and 5 are outputs
//Initialize port A
porta = 0x00;
//Initialize port B
portb = 0x00;
cmcon = 7; //disable comparators
//Set Timer0 mode
clear_bit( option_reg, T0CS ); //configure timer0 as a timer
//Set prescaler assignment
clear_bit( option_reg, PSA ); //prescaler is assigned to timer0
//Set prescaler rate
clear_bit( option_reg, PS2 ); //prescaler rate 1:2
clear_bit( option_reg, PS1 );
clear_bit( option_reg, PS0 );
//Set timer0 source edge selection
set_bit( option_reg, T0SE ); //increment on high-to-low transition on RA4/T0CKI pin
//Set timer 1 prescaler rate
clear_bit( t1con, T1CKPS1 ); //prescaler rate 1:2
set_bit( t1con, T1CKPS0 );
//Set timer 1 mode
clear_bit( t1con, TMR1CS ); //Internal clock (FOSC/4)
clear_bit( pir1, TMR1IF ); //clear timer 1 interrupt bit
clear_bit( t1con, TMR1ON ); //stop timer 1
varh = 0xC3; // 0xC301 is a adjusted number to yield 32.0 samples/sec
varl = 0x01;
set_bit( t1con, TMR1ON ); //enable timer 1
//Set timer 2 prescaler rate
clear_bit( t2con, T2CKPS1 ); //prescaler rate 1:1
clear_bit( t2con, T2CKPS0 );
//Set timer 2 postscaler rate
clear_bit( t2con, TOUTPS3 ); //postscaler rate 1:1
clear_bit( t2con, TOUTPS2 );
clear_bit( t2con, TOUTPS1 );
clear_bit( t2con, TOUTPS0 );
//Set timer 2 mode (enable or disable)
clear_bit( t2con, TMR2ON ); //enable timer 2
//Enable interrupts (Timer1)
intcon = 0xC0; // enable global interrupts, disable timer0 interrupt bit
pie1 = 0x01; // enable timer1 overflow interrupt bit
}
// ***************************** end of configure_mpu() *****************
// ************************ find_sync() *************************
//
// This routine correlates the sample register with the wwvb 2 bit
// sync sequence that starts each message. The first bit looks for
// correlation on a bit-by-bit basis. Once the first sync bit is
// detected, the second bit is tested as a complete 32-bit word.
// Sync is declared when both sync bits pass the sync threshold test
//
// Parameters:
// Entry: sync_bit_1 and sync_bit_2 are reset
// Exit: sync_bit_1 and sync_bit_2 are set.
//
// Called from: main()
//
// *******************************************************************
unsigned char find_sync()
{
// colons OFF = no sync
portb.5 = 0;
while ((sync_bit_1 && sync_bit_2) == 0)
{
while(sample_flag == 0)
{
; // wait for 32 samples/sec interrupt and get new sample
}
sample_flag = 0;
// Set up a counter which will count the number of agreements
// between the sample register and the sync pattern
sync_count = 0;
// XOR the sample register with the sync pattern to see which bits agree
sync_temp = sync ^ samples;
// Count the number of bit agreements between samples and initial sync pattern
for (i = 0; i < 32; i++)
{
if (sync_temp.0 == 0)
sync_count++;
sync_temp >>= 1;
}
// compare agreement count to the sync_threshold value, set sync bit flags accordingly
if ((sync_count >= sync_threshold) && (sync_bit_1 == 0))
{
sync_bit_1 = 1;
if (sync_bit_1 == 1)
{
for (j = 0; j < 32; j++) // get 32 new samples
{
while(sample_flag == 0)
{
;
}
sample_flag = 0;
}
sync_count = 0;
sync_temp = sync ^ samples;
for (i = 0; i < 32; i++)
{
if (sync_temp.0 == 0)
sync_count++;
sync_temp >>= 1;
}
if (sync_count >= sync_threshold)
// sync found!!!
sync_bit_2 = 1;
else
// sync not found
sync_bit_1 = 0;
}
}
}
}
// ***************** end of find_sync *************************
// ************************** get_bit() ***********************
//
// this routine determines whether the received bit is a
// one or zero
//
// Parameters:
// Entry: none
// Exit: none
//
// Called from: main()
//
// ***************************************************************
void get_bit()
{
unsigned char j;
unsigned long one_temp;
unsigned long zero_temp;
for (j = 0; j < 32; j++) // get 32 new samples
{
while(sample_flag == 0)
{
; // wait for sample time interrupt
}
sample_flag =0;
}
one_count = 0;
zero_count = 0;
one_temp = one ^ samples;
zero_temp = zero ^ samples;
for (i = 0; i < 32; i++)
{
if (one_temp.0 == 0)
one_count++;
one_temp >>= 1;
if (zero_temp.0 == 0)
zero_count++;
zero_temp >>= 1;
}
}
// ************* end of get_bit() **********************
// *************** skip_bit() **************************
//
// this routine is used to skip over the wwvb reserved bits and
// other bits not used for this clock design
//
// Parameters
// Entry: none
// Exit: none
//
// Called from: main()
//
// *******************************************************
void skip_bit()
{
unsigned char j;
for (j = 0; j < 32; j++)
{
while(sample_flag == 0)
{
; // wait for sample time interrupt
}
sample_flag = 0;
}
}
// ***************** end of skip_bit() **************************
// *************************** main routine starts here *****************
void main()
{
// variable declarations
unsigned char k;
unsigned char temp_ten_minutes;
unsigned char temp_minutes;
unsigned char temp_hours;
unsigned char temp_ten_hours;
unsigned char utc_hours;
unsigned char ten_utc_hours;
unsigned char a;
unsigned char x;
unsigned char y;
unsigned char z;
unsigned char last_msg_valid_flag = 0;
unsigned char dst = 0; // daylight savings time flag. 1 = dst, 0 = std time
configure_mpu();
seconds = 0;
ten_seconds = 0;
//Endless loop
while( 1 )
{
sync_bit_1 = 0;
sync_bit_2 = 0;
find_sync();
// sync found, process bits
// seconds and ten_seconds reset here
seconds_counter = 0;
n = 31;
wwv_minutes = 0;
wwv_ten_minutes = 0;
utc_hours = 0;
ten_utc_hours = 0;
wwv_hours = 0;
wwv_ten_hours = 0;
portb.5 = 1; // colons ON = sync
error = 0;
// first get 3 bits of 10-minutes data (40, 20, 10, MSB first format)
// the 4th bit is a reserved (don't care) bit
for (k = 0; k < 3; k++)
{
get_bit();
if (one_count >= bit_threshold)
{
wwv_ten_minutes <<= 1;
wwv_ten_minutes.0 = 1;
}
else
if (zero_count >= bit_threshold)
{
wwv_ten_minutes <<= 1;
wwv_ten_minutes.0 = 0;
}
else
error = 1; // handle error, did not detect 1 or 0 bit
}
// ************ could add error check here to be sure ten-minutes are between 0 and 5 **********
// skip over the don't care bit
skip_bit();
// first get 4 bits of minutes data (8, 4, 2, 1, MSB first format)
if (error == 0)
{
for (k = 0; k < 4; k++)
{
get_bit();
if (one_count >= bit_threshold)
{
wwv_minutes <<= 1;
wwv_minutes.0 = 1;
}
else
if (zero_count >= bit_threshold)
{
wwv_minutes <<= 1;
wwv_minutes.0 = 0;
}
else
error = 1; // handle error, did not detect 1 or 0 bit
}
}
// ************ could add error check here to be sure minutes are between 0 and 9 **********
// now get the next 2 bits representing 10 utc hour data (24-hour format)
if (error == 0)
{
// skip over the position marker and (2) reserved bits
for (k = 0; k < 3; k++)
skip_bit();
for (k = 0; k < 2; k++)
{
get_bit();
if (one_count >= bit_threshold)
{
ten_utc_hours <<= 1;
ten_utc_hours.0 = 1;
}
else
if (zero_count >= bit_threshold)
{
ten_utc_hours <<= 1;
ten_utc_hours.0 = 0;
}
else
error = 1; //handle error, did not detect 1 or 0 bit
}
}
// ************ could add error check here to be sure ten-utc_hours are between 0 and 2 **********
// now get the 4 bits representing utc_hours
if (error == 0)
{
// skip the next (reserved) bit
skip_bit();
for (k = 0; k < 4; k++)
{
get_bit();
if (one_count >= bit_threshold)
{
utc_hours <<= 1;
utc_hours.0 = 1;
}
else
if (zero_count >= bit_threshold)
{
utc_hours <<= 1;
utc_hours.0 = 0;
}
else
error = 1; // handle error, did not detect 1 or 0 bit
}
}
// correct for time being valid at the previous frame sync marker
if (error == 0)
{
temp_ten_minutes = wwv_ten_minutes;
x = 0;
while ( temp_ten_minutes > 0)
{
x += 10;
temp_ten_minutes--;
}
y = x + wwv_minutes; // y is now minutes in a single
// char format
z = 0;
temp_ten_hours = ten_utc_hours;
while( temp_ten_hours > 0)
{
z += 10;
temp_ten_hours--;
}
a = z + utc_hours; // a is now hours in a single
// char format
if (y < 59)
y++; // bump minutes
else // y = 59
{
y = 0; // bump hours
if (a < 23)
a++;
else
a = 0;
}
// now unpack back to 2-byte format
temp_ten_minutes = 0;
while (y > 9)
{
temp_ten_minutes++;
y -= 10;
}
wwv_ten_minutes = temp_ten_minutes;
wwv_minutes = y;
temp_ten_hours = 0;
while (a > 9)
{
temp_ten_hours++;
a -= 10;
}
ten_utc_hours = temp_ten_hours;
utc_hours = a;
}
// daylight savings time info is in bits 57 and 58
// we will only test bit 57 for dst and do nothing for bit 58
// to allow re-sync
if (error == 0)
{
// skip the next 38 bits to get to message bit 57
for (k = 0; k < 38; k++)
skip_bit();
// get bit 57 to see if DST is in effect
get_bit();
if (one_count >= bit_threshold)
dst = 1;
else
if (zero_count >= bit_threshold)
dst = 0;
else
error = 1; //handle error, did not detect 1 or 0 bit
}
// ************ could add error check here to be sure utc_hours are between 0 and 9 **********
// ok, now we need to convert UTC hours to local (PST) time
// ********** CHANGE THIS CODE SEGMENT FOR DIFFERENT TIME ZONES!!!!! *********
if (error == 0)
{
temp_hours = 0;
for (k = 0; k < ten_utc_hours; k++)
temp_hours += 10;
temp_hours = temp_hours + utc_hours;
// now have a single word representing utc hours
if (dst == 0) // standard time
{
if (temp_hours <= 7)
local_hours = temp_hours + 16;
if ((temp_hours > 7) && (temp_hours <= 23))
local_hours = temp_hours - 8;
}
if (dst == 1) // daylight savings time
{
if( temp_hours <= 6 )
local_hours = temp_hours + 17;
if( (temp_hours > 6) && (temp_hours <= 23))
local_hours = temp_hours - 7;
}
// if we made it this far with error = 0
// then the message is valid
msg_valid = 1;
}
else
msg_valid = 0;
} // end of while(1) endless loop
}

复制代码

组件	零件编号	说明	制造商	Digi - Key的股票＃

IC1的	的PIC 16F628	微控制器	Microsemi的	PIC16F628-04/P-ND
IC2 - IC7	4511N	BCD到7段解码器/驱动器	各种	296 - 3528 - 1 - ND
IC8	74HCT138	3-8译码器	各种	296 - 1608 - 5 - ND
IC9	7805	5V稳压器	各种	LM7805CT - ND
R1 - R42	150欧姆1 / 8 W	电阻	各种
R43，R51	10千欧姆1 / 8 W	电阻	各种
R44型 - 48	270欧姆1 / 8 W	电阻	各种
第一季度	为4 MHz	水晶	各种	X971 - ND
C1，C2，	20 PF，50V	电容器	各种
C3，C4，C6	0.1用友，50V	电容器	各种
C7	10 uF的，35V	电容器	各种
与天线接收模块	CMMR - 6		CMAX	561 - 1014 - ND
LED1 - LED6	LDS - CA14RI	1“LED 7段显示器	Lumex公司	67 - 1487 - ND