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

sydz · 发表于 2011-11-10 19:38:31

WWVB在网络上的时钟设计DIY有很多版本。商业的“原子”时钟是便宜和广泛使用，但我想我的手，在设计一个获得接收到WWVB的洞察力和了解PIC单片机编程的一个小尝试。我的版本是不是最简单的，但它工作得很好，我认为它提供了一些独特的功能.

WWVB时钟功能

接收时间播出，WWVB，柯林斯堡，CO
WWVB时间自动同步与内部时间
WWVB信号丢失时保持本地时间
这个版本是太平洋标准时间，并自动检测/纠正Daylignt储蓄的时间
6位数字显示小时，分钟，秒使用1“七段LED显示
WWVB同步指示器
时间显示在12小时格式
的PIC 16F628单片机
C语言编写的软件
所有工具（原理图编辑器，C编译器，PCB布局软件，PIC的程序员都是免费的，在网络上可供下载。

的完整描述和规范WWVB广播（免费）， WWVB信号播出时间为60 kHz载波AM调制代码帧，每分钟更新一次。数据传输速率是一个比特每秒。随着时间码信息，数据帧还包含同步位，日历数据，UT1之修正，闰年，闰秒的数据。这里介绍的时钟设计只解码数据的时间和夏令时的校正数据。该软件可以很容易地进行修改，包括其他信息位解码，如果需要的话。低频WWVB信号强度较弱和接收可能会出现问题。信号采集时间是可变的，位置和大气条件而定。接待处通常情况下，最好在晚上八时至晚上-上午04时。要使用的时钟，只需接通电源，并等待接收WWVB信号。时钟接收到一个完整的无差错的数据帧时，它会自动重置显示，以显示正确的时间。在最初的时间校正，时钟将保持一段时间，即使失去WWVB接待。

硬件描述

在原理图（PDF格式）所示，在时钟的心脏是一个PIC 16F628单片机运行在4 MHz 。解码的实时数据依次从微控制器的输出（RA0 - RA3）到7段解码器/驱动程序上的4位数据总线。数据输出顺序为秒，分，秒，分钟，小时和10小时10秒10。微控制器输出（RB1，RB2，RB3）路由10微秒stroble的脉冲RB4的出到7段解码器/驱动程序，在适当的时间锁存数据总线值。秒和10秒显示值每秒更新一次。分钟，10分钟，小时和10小时，每分钟更新一次。显示由1“橘红色的LED七段显示器上显示的小数点用来形成冒号分开秒，分钟和小时10秒和10分钟显示安装倒挂形成上部的结肠点。WWVB接收器是一个C - MAX模型CMMR - 6从DIGI - KEY 一部分＃561 - 1014 - ND loopstick天线完成。从接收器输出的数据进行采样RB0的微控制器。

我已经建立了两个时钟，一个点，以点布线和使用PCB。两个版本都表现良好。只要保持接收器远离噪声源和电线/走线长度尽可能短，以减小电感。我发现接收器也是由电源产生的磁场敏感。我用一个9V，200毫安，而不是一个内部电源“壁疣”，以消除这个问题。

我的PCB设计使用免费PCB软件。艺术品包含的主板和显示在一个单一的布局，以节省两个单独的电路板的成本板。发送Gerber文件和使用他们的“裸骨”的过程。 “裸骨”的过程，不包括阻焊也不丝网。切断主电路板显示板和主板安装直角和线一起使用提供的垫。

软件简介

我用C编译器源升压开发软件。它是免费提供

该软件是中断驱动，从PIC定时器2模块。基本时序设置为接收器采样和内部时间传播提供32个中断/秒。接收到的数据进行采样，每秒32样本。软件交叉关联存储的“理想”样本一，零，和同步模式的输入样本。确定在连续两个连续的同步比特的数据帧的开始。当检测到这种模式，秒的数据被重置为零，后续位或零的提取分钟和小时的数据检测。只有时间显示有关的数据进行解码。内的数据帧不包含时间数据位被忽略。 31出32位检测互相关算法需要接收到的数据和存储的“理想”的同步模式之间的样本协定。

开启时同步检测和关闭时同步丢失秒位数的小数点。位和零的检测需要28 32接收到的数据和存储的“理想”模式之间的样本协议。如果任何检测到的位不符合或超过相关阈值，整个画面被丢弃，并启动一个新的搜索帧同步。当成功侦破的一帧的时间内数据同步和数据纠正太平洋标准时间和夏令时。该软件必须改变为其他时区的正确更正。还纠正一个WWVB在每个数据帧开始的有效时间造成的偏移分钟的时间。完全矫正的时间转换为12小时格式，然后更新内部的时间值。如果WWVB信号丢失，内部时间继续从它是依赖PIC晶体振荡器WWVB，直到下一个数据帧接收和验证，传播时间。 PIC16F628是使用WIN PIC软件，免费提供编程

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
}

复制代码

零件清单

在零件清单中，我已经包括IC及零件，可能很难找到的制造商与Digi - Key库存数量。电阻和电容，可以从众多的供应商购买的公用部分。

组件	零件编号	说明	制造商	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

下载：

www.syyyd.com原理图.pdf (96.75 KB, 下载次数: 35)

clock5A C.rar (4.9 KB, 下载次数: 27)

clock5A HEX.zip (2.03 KB, 下载次数: 26)

PCBgerber_files.zip (58.1 KB, 下载次数: 27)

帐号		自动登录	找回密码
密码			立即注册

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

相关帖子

浏览过的版块