单片机的应用例子--多功能红外线遥控前级

Biglee_163 · 发表于 2007-10-1 10:39

来了一些图

彭兴 · 发表于 2007-10-1 10:56

关注下

Biglee_163 · 发表于 2007-10-1 15:25

//******************************************************************************
//注意：文档名字不可用汉字
//2007-08-15, 四象限前级
//memory large model
#define NEC // NEC码
//#define RC6 // 飞利浦RC6码（已屏蔽）
//所用遥控器的控制码, 不同遥控器的码会不一样
#define user  0xFF00;// 用户码
#define vol_up  0x18; // 增音量 <vol +> 按键
#define vol_dn  0x07; // 减音量 <vol -> 按键
#define ch_up  0x1A; // 下一个切换位置 <tune +> 按键
#define ch_dn  0x0E; // 前一个切换位置 <tune -> 按键
#define mute  0x00; // 静音 <mute> 按键
#define pwr 0x10; // 电源开关 <pwr> 按键
#define anti  0x04; // 左声道反相 <mode> 按键
#define agc 0x06; // 自动音量 <audio> 按键

#include <eZ8.h>       （包含头文件）
#include <stdio.h>       （同上，包含标准输入输出头文件）
#include <sio.h> // non-standard I/O  （包含非标准输入输出头文件）
#include "main.h"          （包含main.h头文件）

/* option bit:
0xA3; medium crystal freq. ,WDT always on, disable VBO, read protect（可选位？）
0xA7; medium crystal freq. ,WDT always on, disable VBO
0xAF; medium crystal freq. , WDT always on
0xBF; high crystal freq. , WDT always on
*/                            （此段已经屏蔽？）
//FLASH_OPTION2 = 0xEF; //crystal osc on, not required

//actual use
//FLASH_OPTION1 = 0xBB; //high crystal freq, WDT always on, read protect

//for testing only
FLASH_OPTION1 = 0xFF; //high crystal freq., WDT off

///////////////////////////////////////////////////////
// Global - Variable             （全局变量）

unsigned int pulse_count = 0;    （定义脉冲计数器==0）
unsigned int pulse_count0= 0;             （定义脉冲计数器0==0）
unsigned int pwm_current = 2500;          （定义电源电流==2500？？）
unsigned int pwm_current0 = 2500;          （定义电源电流0==2500？？）
unsigned int pwm_current1 = 2500;          （定义电源电流1==2500？？）
unsigned int offset_cal = 0;       （定义失调呼叫==0）
unsigned int gain_cal = 0;       （定义增益呼叫==0）
unsigned int cycle_tmr = 0;          （定义循环定时器==0）
unsigned char range_cal = 6;          （定义范围呼叫==6？？）
unsigned char range = 0;          （定义范围==0）

char DigCtr =0; //位数计
char DplDuty =0; //亮度
char DplFlag =0; //bit0 = blank, bit1 = ALC on, bit2 = new channel, bit3 = test mode（共4位，0位空、1位是ALC开、2位是新频道、3位是测试模式，请问这个是显示出来的效果吗？）
char FuncNr =0; //功能选择    (function No)
unsigned char Volume =0; //音量  (字段型）
unsigned char ChNr =0;          （channal No)
unsigned char width =0; //脉宽
unsigned char step_ctr =0;             (步进控制）
char keycode0 =0;                   （键盘代码0）
char keycode =0;                   （键盘代码）

char but0_tmr =0;                      （按键0定时）
char but1_tmr =0;                      （按键1定时）
char but2_tmr =0;                      （按键2定时）
char set_tmr =0;                      （设置定时）
char set_flag =0;                      （设置标志）
char but_flag =0;                         （按键标志）
char ir_flag =0;                         （红外标志）

char bin_tmr = 0;                （2进制定时）
char bin_tmr0 = 0;                （2进制定时0）
char adc_ch = 4;                （模数频道定义，为何是4？）
char valid_ch = 0;                （有效频道定义）
char key_count = 0;                （定义按键计数器）
char off_cal = 0;                （定义关呼叫）
char gain_calH = 0;                （定义增益呼叫-高位）
char gain_calL = 0;                （定义增益呼叫-低位）

unsigned char adc_high = 0;          （定义模数-高位）
unsigned char adc_low = 0;          （定义模数-低位）
char sign_bit = 0;                   （定义标志位）
char print_flag = 0;                   （定义打印标志）
char flash_empty = 0;                   （定义刷新空标志）

char deci_flag = 0;                   （？？）
char rx_flag = 0;                   （接收标志）
char adc_flag = 0;                   （模数标志）
char block_start = 0;                   （块-开始）
char write_flag = 0;                      （写标志）
char scan_flag = 0;                      （扫描标志）
char mute_flag = 0;                            （静音标志）
char pwr_flag = 0;                               （电源标志）
char anti_flag = 0; //左声道反相
char agc_flag = 0; //自动音量

char rx_ptr = 0;                （接收—？？）
char rx_ptrL = 0;                   （接收-？？低位）
unsigned char rx_tmr = 0;          （字符型  接收—定时？）
char UART_flag = 0;                   （UART是什么？）
char rx_dly = 0;                   （接收—延时？）

char cmd_code; //控制码                   （命令码）
char comp_code; //反码
int user_code; //用户码
unsigned int update_timer; //切换显示时间

char temp_array[16]; //use as scratch in asm       临时阵列（16bit) ASM什么意思？scratch什么意思？

unsigned int cal_array[16]; //0 = offset, 1 = scale, 2 = range CAL阵列(16bit)，0=失调，1=？2=范围
int adc_array[8];                                        ADC阵列

////////////////////////////////////////////////////////

Biglee_163 · 发表于 2007-10-1 15:28

// Main program beings here
main ()                            （主程序开始）
{
unsigned long int temp0;             （设定无符号长整型变量temp0\temp1)
long temp1;
unsigned int interval;             （设定无符号长整型变量interval）
//char user, vol_up, vol_down, ch_up, ch_down, mute, agc, L_anti;  （已屏蔽）

// Initialize WDT       （屏蔽了，初始化WDT）
WDTCTL = 0x55;       //Unlock control byte 1    （WDTCTL变量在什么地方曾经定义？？WDT是watch Dog Timer的意思吧）
WDTCTL = 0xAA;       //Unlock control byte 2    （给同一个变量两次赋值后WDTCTL的数值应该最后是OX55A，这是什么意思？）
WDTU = 0x00;       //Upper byte value about 1 sec.（上位定义00）
WDTH = 0x3F;       //High byte value                      （高位定义3F）
WDTL = 0xFF;       //Low byte value                      （低位定义FF， 0000 0011 1111 是否这个意思？）

DI(); // Disable Interrupts    （禁止中断）

flashread(); //读取eeprom 的设置参数             （函数段）
/* user    = cal_array[0]; // 用户码
            vol_up    = cal_array[1];
vol_down                   = cal_array[2];
ch_up = cal_array[3];
ch_down = cal_array[4];
mute = cal_array[5]; // 静音
agc = cal_array[6]; // 自动音量
L_anti = cal_array[7]; // 左声道反相
*/
// init_uart0();                  // Intialize Uart          （初始化UART)
init_port();                                                 (初始化端口）
init_timer(); // Intialize Timer（初始化定时器）
init_adc(); // Intialize adc（初始化模数变化器）

// if ((PBIN & UP) !=0)    （如果PBIN  and UP不等于0，PBIN及UP未见定义，请问在何方？）
// {

// OSCCTL = 0xE7; //use crystal osc as sys clk
// OSCCTL = 0x18;
// OSCCTL = 0xE2;                                                       （反复向一个变量赋值什么意思？）
// }

EI(); // 允许中断
Volume = 20;                                                 （音量==20（十进制））
ChNr = 0x1F;                                                 （频道号==1F）
cmd(); // 输出       （调用cmd函数）

while(1) // 永续环
{
asm("\t wdt");                                        （asm是什么命令，我忘记了）

if (DplFlag & 0x01) // 每1.5毫秒一次    （如果DplFlag and 0x01==1)
     {
shiftdpl();                               (调用shiftdpl函数）还是老问题，这些变量在哪里定义？
interval++;                               （如果DplFlag and 0x01==0，interval+1）

// test();
　
if (update_timer<65535) //　　　（如果update_timer<64K）
{
update_timer++;       （update_timer+1）
}

if (but_flag & 0x01) // 按键（如果but_flag and 0x01==1）
     {
readbut();                （调用readbut函数）
}
}

if (width>0 || ir_flag>0) // 红外线（如果width>0 或者 ir_flag>0)
     {
// readcode();
#ifdef NEC    (ifdef是什么意思？）
IR_decode_NEC();       （先判断IR_decode_NEC函数）
#endif
#ifdef RC6
IR_decode_RC6();       （然后判断IR_decode_RC6函数）
#endif
IR_keycode();          （调用IR_keycode函数）
width=0; //标记已处理（返回置width==0)
ir_flag=0;                            (返回置ir_flag==0）
}

if (keycode != 0 && interval>133) // 最少间隔200毫秒（如果keycode不等于0且interval>133)
     {
switch(keycode)                      (切换keycode数值至不同的情况段）
{
case 1:
if(FuncNr>0 && FuncNr<13) FuncNr++;  （如果FunNr>0且FunNr<13,FunNr+1)是指连续按压频道+按键？
else                               (否则）
{
     update_timer=10000;          （update_timer赋值10000，到底是多少时间我不会算）
if (Volume>0) Volume--;       （如果Volume>0,Volume-1)  是指连续按压音量-按键？
}
break;                                        (中断返回switvh(keycode)语句）

case 2:
if(FuncNr>1) FuncNr--;             （如果FunNr>1,FunNr-1）是指连续按压频道-的情况
else                                  （不然）
{
     update_timer=10000;
if (Volume<60) Volume++;    （如果Volume<60,累加）指连续按压音量+的情况
}
break;

case 3:
     update_timer=0;                      （将update_timer清0）
if (ChNr<0x8F)                         （如果ChNr<0x8F)
     {
ChNr = ChNr + 16;                (进位显示十进制）
}
break;

case 4:
     update_timer=0;
if (ChNr>0x1F)
     {
ChNr = ChNr - 16;             （退位显示十进制）
}
break;

         case 5:
               update_timer=0;
               mute_flag ^= 0x01;                               （^=是什么意思？）
         break;

         case 6:
            update_timer=0;
            pwr_flag ^= 0x01;
         break;

         case 7:
            update_timer=0;
            anti_flag ^= 0x01;
         break;

         case 8:
            update_timer=0;
            agc_flag ^= 0x01;
         break;

}

interval=0;          （interval置0）
cmd();                （执行cmd函数）
}
keycode =0;                   （keycode置0）
if( rx_tmr>20) step_ctr=0;    （如果rx_tmr>20 将step_ctr清0）

} //End of while    （兄台妙句，方便理解）
} // End of main program

//============================

test()             (test子函数）
{

if (step_ctr==34) //如果step_ctl等于34
{
     update_timer=10000;    （将update_timer赋值10000）
Volume = cmd_code;       （将cmd_code赋值给Volume)
// Volume = user_code;
step_ctr=0;             (写完数据擦屁股）
}
}

//============================
IR_keycode()             （IR_Keycode子函数）
{
int i;                   （设整型变量i）
char c;                   （设字符变量c）

if (step_ctr>33)  //有效码
{
update_timer=10000;
  step_ctr=0;
  i = user;             （将user返回值赋值给i）

/* 当要寻找个别遥控码时在此设置一个断开点(break point)
? 执行(go)程序，按下你所要的按键，程序就会在此暂停
把浮标(cursor)指着 user_code 就可读出用户码，然后
把浮标(cursor)指着 cmd_code 就可读出控制码，然后
从新执行(go)程序，重复以上步骤以获取别的控制码
*/
  if( user_code == i)    （如果user_code==i）
  {
c = vol_up;          （将vol_up值赋予C）
if(cmd_code == c) keycode = 1; （如果cmd_code=c的话，则将keycode定义为1）
c = vol_dn;
if(cmd_code == c) keycode = 2;
c = ch_up;
if(cmd_code == c) keycode = 3;
c = ch_dn;
if(cmd_code == c) keycode = 4;
c = mute;
if(cmd_code == c) keycode = 5;
c = pwr;
if(cmd_code == c) keycode = 6;
c = anti;
if(cmd_code == c) keycode = 7;
c = agc;
if(cmd_code == c) keycode = 8; （依次定义各遥控按键的keycode)

  }
}
}

#ifdef NEC
////////////////////////////////////////////////////////
// 红外线解码 NEC 发射码， 2007-08-23 江文正
// 方法 : 接收管输出下降沿触发中断子程序，读取下降沿之间的时间 width 后把定时器重新置零
// width 单位= 92.59uS, 前提是定时器时钟 = 5.5296 MHz, prescale = 2
// 两个下降沿之间时段: 引导码, >11.81mS : width=128
// 重复码, >9mS : width=97
// >1.69mS : width=18 = 高电平数据,  <1.69mS : width=18 = 低电平数据

IR_decode_NEC()             (红外解码_NEC子函数）
{
char rcv_8bit=0;             （设定字符型变量rcv_8bit)
int rcv_16bit=0;             （设定整型变量rcv_16bit)

ir_flag &= 0xFE; //标记已处理    (&=是什么运算？）
if (step_ctr ==0)    （如果step_ctr返回0）
{
step_ctr=1;    （将之置1）
}
else                   （否则继续判断）
{
if (width > 128) //引导码    （判断宽度）
{
step_ctr=2;          （将step_ctr致2）
user_code=0; // 清0
cmd_code=0; // 清0
}
else
{
if ((width > 97) && (step_ctr=1)) //重复码
{
step_ctr=34; // （将step_ctr置越界标志）
}
      else if (step_ctr > 1)
{
if (width > 18) //高电平
{
rcv_8bit=1;
rcv_16bit=1;
}

if (step_ctr<18) //用户码
{
rcv_16bit = rcv_16bit << (step_ctr-2);（<<是重定向的意思吗？）
user_code |= rcv_16bit; （|=是什么运算？）
}
else
{
if (step_ctr<26) //控制码
{
rcv_8bit = rcv_8bit << (step_ctr-18);
cmd_code |= rcv_8bit;
}
}
if (step_ctr>25) //反码
{
rcv_8bit = rcv_8bit << (step_ctr-26);
comp_code |= rcv_8bit;
}

step_ctr++;                （step_ctr累加）
if (step_ctr>33) //有效码
{
comp_code ^= 0xFF; //反位
      if (cmd_code != comp_code)
{
step_ctr = 0; //错码，无效
}
}

}
}
}
}
#endif

Biglee_163 · 发表于 2007-10-1 15:29

#ifdef RC6（非里蒲)
/* ////////////////////////////////////////////////////////
红外线解码飞利浦 RC6 发射码， 2007-08-29 江文正
方法 : 接收管输出下降沿触发中断子程序，读取下降沿之间的时间 width 后把定时器重新置零
width 单位= 92.59uS, 前提是定时器时钟 = 5.5296 MHz, prescale = 2

*/
IR_decode_RC6()
{
char rcv_8bit=0;

// ir_flag &= 0xFE; //标记已处理
switch(step_ctr)
{
case 0: //开始
if(width > 0) // 曾经有过下降沿
{
step_ctr++;
T1CTL= 0x09; //停止 T1
T1RH= 0xDC;
T1RL= 0xFF; //15mS
T1H = 0x00; //同步
T1L = 0x01;
T1CTL= 0x89; //启动 T1, prescale=2
}
break;
case 1: //引导码
if(width > 36 && width < 41) // 3.556mS 正负0.222mS 之间
{
user_code=0; // 清0
cmd_code=0; // 清0
step_ctr++;
     }
break;
default:
if (ir_flag & 0x02) //高电平
{
rcv_8bit=0x01;
}
if (step_ctr>1 && step_ctr<8) //引导码
{
step_ctr++;
}
else
{
if (step_ctr>7 && step_ctr<16) //用户码
{
rcv_8bit = rcv_8bit << (step_ctr-8);
user_code |= rcv_8bit;
step_ctr++;
}
else
{
if (step_ctr>15 && step_ctr<24) //控制码
{
rcv_8bit = rcv_8bit << (step_ctr-16);
cmd_code |= rcv_8bit;
step_ctr++;
}
}
}
if (step_ctr>23) //
{
step_ctr=34;
}
}
}
#endif

/*
case 2:
if(width > 12 && width < 17) step_ctr++; // 1.332mS 正负0.222mS 之间
break;
case 3:
if(width > 7 && width < 12) step_ctr++; // 0.889mS 正负0.222mS 之间
break;
case 4:
if(width > 7 && width < 12) step_ctr++; // 0.889mS 正负0.222mS 之间
break;
case 5: //完成领头码
if(width > 12 && width < 17) step_ctr++; // 1.332mS 正负0.222mS 之间, trailer 下降沿=0
if(width > 22 && width < 27) // 2.221mS 正负0.222mS 之间, trailer 上升沿=1
{
     step_ctr++;
     step_ctr++; //step 7
user_code=0x80; //MSB = 1
}
if(width > 27 && width < 32) // 2.667mS 正负0.222mS 之间, trailer 上升沿=1
{
     step_ctr++;
     step_ctr++; //step 7
user_code=0x00; //MSB = 0
}
break;
case 6: //第一个位数据
if(width > 12 && width < 17)
{
step_ctr++; // 1.332mS 正负0.222mS 之间
}
if(width > 17 && width < 22)
{
step_ctr++; // 1.667mS 正负0.222mS 之间
user_code=0x80; //MSB = 1
}
break;
case 7: //第二个位数据
if(width > 12 && width < 17)
{
step_ctr++; // 1.332mS 正负0.222mS 之间
}

break;

default:
step_ctr=0;
break;
*/

/*
#pragma interrupt                                  （程序中断）
void isr_timer0(void) // 1.5 毫秒中断       （  void函数是什么类型的函数？）
{
DplFlag |= 0x01; // 刷新显示符号  （|=是什么运算？）
if(set_tmr<255) set_tmr++;             （如果set_tmr<0xFF，累加）
if(bin_tmr<255) bin_tmr++;
if(rx_tmr<255) rx_tmr++;

}

#pragma interrupt
void isr_timer1(void) // 15 / 0.889 毫秒中断
{
#ifdef NEC
// cmd_code = 0xFF; // 15mS 无信号之后重复码无效
step_ctr = 0; // 无红外线信号时段
#endif
#ifdef RC6
if ( !(PCIN & 0x08)) // 红外线下降沿       （ !是not的意思吗？）
{
ir_flag |= 3; // 标记高电平和新数据
}
else
{
ir_flag |= 1; // 标记新数据
}
#endif
}

#pragma interrupt
void isr_C2(void) // port C2 中断
{
if ( !(PCIN & 0x04)) // 按键下降沿
{
but_flag |= 0x01;
}
}

#pragma interrupt
void isr_C3(void) // port C3 中断
{
if ( !(PCIN & 0x08)) // 红外线下降沿
{
width=T1H;
#ifdef NEC
T1H=0;
T1L=1;
#endif
#ifdef RC6
T1H=0x66; // 使定时器重新同步
T1L=0x02;
#endif
IRQ0 &= 0xBF; // 10111111B,清除潜伏中断
}
}

*/

Biglee_163 · 发表于 2007-10-1 15:31

我把main.c贴了上来，括号里面是我的注释和不理解的地方。请高手指点的。没办法，基础比较薄弱，C的部分还是属于看的懂一点的部分。

Biglee_163 · 发表于 2007-10-1 15:32

真正的天书即将登场：汇编

Biglee_163 · 发表于 2007-10-1 15:39

; 红外线接收
.include "eZ8.inc"
segment code

xdef _readcode

xref _set_tmr
xref _set_flag
xref _but_flag
xref _but0_tmr
xref _but1_tmr
xref _but2_tmr
xref _DigCtr
xref _FuncNr
xref _step_ctr
xref _user_code
xref _cmd_code
xref _comp_code  （反码）
xref _width
xref _keycode
xref _write_flag

; 红外线读码 2007-08-21
; 方法 : 接收管输出下降沿触发中断子程序，读取下降沿之间的时间 width 后把定时器重新置零
; width 单位= 92.23uS, 前提是定时器时钟 = 5.5296 MHz, prescale = 2
; 两个下降沿之间时段: 引导码, >11.81mS : width=128
; 重复码, >9mS : width=97
; >1.69mS : width=18 = 高电平数据,  <1.69mS : width=18 = 低电平数据
;=================================================
_readcode:
cpx _step_ctr,#0 ;开始  (_step_ctr-#0)  cp命令是比较，返回flag一个值
jr nz,$F                (if NZ,jump to front $$) nz==no zero??
ldx _step_ctr,#1          (#1-->_step_ctr)
ret                                  (return)
$$:
cpx _width,#128 ;引导码(_witch-#128)
jr ult,$F                      (if ult,jump to $F) what's mean of ult??
ldx _step_ctr,#2                (#2-->_step_ctr)
ldx _user_code,#0 ;清0          (#0-->_user_code)
ldx _cmd_code,#0 ;清0          (#0-->_cmd_code)
ldx _comp_code,#0 ;清0          (#0-->_comp_code)
ret                                           (return)
$$:
cpx _width,#97 ;重复码
jr ult,$F
ldx _step_ctr,#34 ;有效码       (#34-->_step_ctr)
ret
$$:
push R0 ;                (进站）
push R1 ;
push R2 ;

clr R0                         (clear R0)
ld R1,#1                      (#1-->R1)
cpx _width,#18 ;高电平(_width-#18)
jr uge,$F                      (if uge,jump to front $$) what's mean of uge??
clr R1                         (clear R1)
$$:
cpx _step_ctr,#18 ;用户码    (_step_ctr-#18) compare _step_ctr and #18
jr ult,$F                      (if ult,jump to front $$)
ldx R2,_step_ctr                (_step_ctr-->R2)
loop1 rl R1                                  (循环1：R1左移一位）
rlc R0                         (R0左移一位带进位）
djnz R2,loop1                            (if R2 not=1,jump to loop1)
orx high(_user_code),R0       (_user_code 高位 OR R0)
orx low(_user_code),R1          (_user_code 低位 OR R1)
jr inc_step                   (jump to inc_step)
$$:
cpx _step_ctr,#26 ;指令码    (_step_ctr-#26)
jr ult,$F
ldx R2,_step_ctr                (_step_ctr-->R2)
loop2 rl R1                                  (循环2：R1左移一位）
djnz R2,loop2                            (if R2 not=1,jump to loop2)
orx _cmd_code,R1                (_cmd_code or R1)
jr inc_step                   (jump to inc_step)
$$:
ldx R2,_step_ctr ;反码       (_step_ctr-->R2)
loop3 rl R1                                  (循环3：R1左移一位）
djnz R2,loop3                            (if R2 not=1,jump to loop3)
orx _comp_code,R1             (_comp_code or R1)
jr inc_step                (jump to inc_step)
inc_step:                                                 (程序段）
addx _step_ctr,#1                      (_step_ctr+#1-->_step_ctr+#1)
cpx _step_ctr,#34             (_step_ctr-#34-->_step_ctr)
jr ult,$F
xorx _comp_code,#%FF ;反位             (异或_comp_code 与FF，异或：同1异0的意思）
subx _comp_code,#1                      (_comp_code-#1-->_comp_code)
cpx _cmd_code,_comp_code       (_cmd_code-_comp_code)
jr eq,$F                      (if eq,jump to $F)
ldx _step_ctr,#0 ;错码，无效  (else #0-->_step_ctr)

$$:
pop R2                                  (收工出站）
pop R1
pop R0

ret                                        (return)

Biglee_163 · 发表于 2007-10-1 15:41

后面括号里的也是我夹注的，目的是学习单片机的语句，所以不厌其烦地查看官方的PDF文件中对于汇编指令的解释。各位高手看了就不要笑话我了

Biglee_163 · 发表于 2007-10-1 15:43

反正在JiangWZ老大的指点下，实验是获得的成功的。但我的目的似乎应该是放在学习单片机的编程方面才是

Biglee_163 · 发表于 2007-10-1 18:00

这里没有讨论单片机编程的高手吗？
郁闷undefined

vdeedomen · 发表于 2007-10-1 18:17

显示和按键电路。。用一个 ET6202 不是更好吗。。。。。。

Biglee_163 · 发表于 2007-10-1 20:59

回楼上：这次用了数码管和VFD两种，楼主用的VFD而我用的是数码管，我们的子程序是不一样的

Biglee_163 · 发表于 2007-10-1 21:00

/*
真空荧光管驱动子程序
2007-09-09 江文正
*/
#include <eZ8.h>
#include <stdio.h>
#include <sio.h> // non-standard I/O
#include "vfd.h"

// STB 下降后的第一字节是指令，往后的是数据，

#define vfd_mode    0x03; // 7 位数 15 段
#define addr_write    0xC0; // 写00进入显示地址
#define data_write    0x40; // 写显示数据，地址自动加1
#define dsp_on    0x8F; // 点亮显示，14/16 亮度
#define dsp_off    0x80; // 熄灭显示
#define key_read    0x42; // 读按键

// 引脚定义

#define data_addr PBADDR // Port B address
#define data_ctl PBCTL // Port B control
#define data_in PBIN // Port B in
#define data_out PBOUT // Port B out
#define data_0 0xFE // PB0
#define data_1 0x01 // PB0
#define stb_out PBOUT // Port B out
#define stb_0 0xFD // PB1
#define stb_1 0x02 // PB1
#define clk_out    PCOUT // Port C out
#define clk_0 0x7F // PC7
#define clk_1 0x80 // PC7

#define colon 0x02; //显示左声道反相或者自动音量
#define point 0x01; //显示自动关机

extern char DplFlag; //bit0 = blank, bit1 = ALC on, bit2 = new channel, bit3 = test mode
extern char FuncNr; //功能选择
extern char mute_flag;
extern char pwr_flag;
extern char anti_flag;
extern char agc_flag;
extern char off_flag;
extern unsigned char Volume; //音量
extern unsigned char ChNr; //切换位置

//15段字符表 HGFE,DCBA,7654,3210
const char SegTable[80] ={ 0x64, 0x46, //0 0110,0100,0100,0110
0x01, 0x20, //1 0000,0001,0010,0000
0xA5, 0x45, //2 1010,0101,0100,0101
0x45, 0x45, //3 0100,0101,0100,0101
0xC1, 0x07, //4 1100,0001,0000,0111
0xC5, 0x43, //5 1100,0101,0100,0011
0xE5, 0x43, //6 1110,0101,0100,0011
0x40, 0x44, //7 0100,0000,0100,0100
0xE5, 0x47, //8 1110,0101,0100,0111
0xC5, 0x47, //9 1100,0101,0100,0111
0xE1, 0x47, //A 1110,0001,0100,0111
0x45, 0x65, //B 0100,0101,0110,0101
0x24, 0x42, //C 0010,0100,0100,0010
0x45, 0x64, //D 0100,0101,0110,0100
0xA5, 0x42, //E 1010,0101,0100,0010
0xA1, 0x42, //F 1010,0001,0100,0010
0x64, 0x43, //10 G 0110,0100,0100,0011
0xE1, 0x07, //11 H 1110,0001,0000,0111
0x05, 0x60, //12 I 0000,0101,0110,0000
0x64, 0x44, //13 J 0110,0100,0100,0100
0x09, 0x28, //14 K 0000,1001,0010,1000
0x24, 0x02, //15 L 0010,0100,0000,0010
0x61, 0x66, //16 M 0110,0001,0110,0110
0x69, 0x16, //17 N 0110,1001,0001,0110
0x64, 0x46, //18 O 0110,0100,0100,0110
0xA1, 0x47, //19 P 1010,0001,0100,0111
0x6C, 0x46, //1A Q 0110,1100,0100,0110
0xA9, 0x47, //1B R 1010,1001,0100,0111
// HGFE,DCBA,7654,3210
0xC5, 0x43, //1C S 1100,0101,0100,0011
0x01, 0x60, //1D T 0000,0001,0110,0000
0x64, 0x06, //1E U 0110,0100,0000,0110
0x31, 0x0A, //1F V 0011,0001,0000,1010
0x65, 0x26, //20 W 0110,0101,0010,0110
0x19, 0x18, //21 X 0001,1001,0001,1000
0xC5, 0x07, //22 Y 1100,0101,0000,0111
0x15, 0x48, //23 Z 0001,0101,0100,1000
0x00, 0x00, //24 0000,0000,0000,0000 空白
0x99, 0x19, //25 * 1001,1001,0001,1001 米字
0x81, 0x21, //26 + 1000,0001,0010,0001
0x81, 0x01 //27 - 1000,0001,0000,0001

};

//文字查码表，切换位置文字=8*4=32个，红外线设置显示=7*6=42个
const char TextTable[81] ={ 0x1C,0x0A,0x1D,0x01, //SAT1 0
0x1C,0x0A,0x1D,0x02, //SAT2 4
0x0D,0x0A,0x0C,0x24, //DAC 8
0x0D,0x1F,0x0D,0x24, //DVD 12
0x0C,0x0D,0x24,0x24, //CD 16
0x0A,0x1E,0x21,0x01, //AUX1 20
0x0A,0x1E,0x21,0x02, //AUX2 24
0x1D,0x0E,0x1C,0x1D, //TEST 28
0x1F,0x18,0x15,0x24,0x1E,0x19,0x24, //VOL UP 32
0x1F,0x18,0x15,0x24,0x0D,0x17,0x24, //VOL DN 39
0x0C,0x11,0x24,0x1E,0x19,0x24,0x24, //CH UP 46
0x0C,0x11,0x24,0x0D,0x17,0x24,0x24, //CH DN 53
0x16,0x1E,0x1D,0x0E,0x24,0x24,0x24, //MUTE 60
0x15,0x24,0x0A,0x17,0x1D,0x12,0x24, //L ANTI 67
0x19,0x20,0x1B,0x24,0x18,0x0F,0x0F //PWR OFF 74

};

unsigned char codebuf[7]; // 7 个字

scandpl()
{
char count;
char vfd_buf;

// vfd_buf = dsp_off; //熄灭显示
// stb_out &= stb_0;
// vfd_out(vfd_buf);
// stb_out |= stb_1;
vfd_buf = vfd_mode; //显示模式
stb_out &= stb_0;                   （&=是什么运算，忘记了）
vfd_out(vfd_buf);
stb_out |= stb_1;                      （|=是什么运算，也忘了）
vfd_buf = data_write;//设置显示数据，地址自动加1
stb_out &= stb_0;
vfd_out(vfd_buf);
stb_out |= stb_1;
vfd_buf = addr_write;//写00进入显示地址
stb_out &= stb_0;
vfd_out(vfd_buf);

// 显示7位数据
get_code();
for(count=0;count<7;count++)          （7位循环显示）
{
vfd_buf = SegTable[codebuf[count]*2];
if(anti_flag & 0x01 && count == 4) vfd_buf |= colon; //显示左声道反相
if(agc_flag & 0x01 && count == 2) vfd_buf |= colon; //显示自动音量
if(off_flag & 0x01 && count == 4) vfd_buf |= point; //显示自动关机
// vfd_out(Volume); // 输出8比特, 测试用
vfd_out(vfd_buf); // 输出前8比特
vfd_buf = SegTable[codebuf[count]*2+1];
// vfd_out(ChNR); // 输出8比特, 测试用
vfd_out(vfd_buf); // 输出后8比特
}
stb_out |= stb_1;

vfd_buf = dsp_on; //点亮显示
stb_out &= stb_0;
vfd_out(vfd_buf);
stb_out |= stb_1;

}

void get_code(void) //（get_code函数）
{
char count;
char temp;
char offset;

if(mute_flag & 0x01 || pwr_flag & 0x01)    //if mute_flag=1 or pwr_flag=1
{
offset = 60; //mute
if(pwr_flag & 0x01) offset = 74; //pwr off
for(count=0;count<7;count++) // 7个字
{
codebuf[count] = TextTable[count+offset]; // 文字显示
}
}
else
{
switch(FuncNr)
{
case 0:
codebuf[0] = TextTable[ChNr*4]; // 平时显示切换位置
codebuf[1] = TextTable[ChNr*4+1];
codebuf[2] = TextTable[ChNr*4+2];
codebuf[3] = TextTable[ChNr*4+3];
codebuf[4] = 0X24; //空白
temp = Volume/10;
codebuf[5] = temp; //volume 十位
temp = Volume-temp*10;
codebuf[6] = temp; //volume 个位
break;
default:
for(count=0;count<7;count++) // 7个字
{
codebuf[count] = TextTable[FuncNr*7+count+25]; // 设置红外线码时的文字显示
}
break;
}
}
}

void vfd_out(char vfd_buf) //串移8位数据
{
char count;
char out_bit=1;

data_addr = 0x01;    // Data Dir
data_ctl &= data_0; // data as output
data_addr = 0x00;    // lock
for(count=0;count<8;count++)
{
wait_uS(1); //延时
if(vfd_buf & out_bit)
{
data_out |= data_1;
}
else
{
data_out &= data_0;
}
wait_uS(1); //延时
clk_out |= clk_1; //clk 置高
wait_uS(1); //延时
clk_out &= clk_0; //clk 置低
out_bit = (out_bit << 1);
}
}

//================================================================
char read_key() //读取8个按键
{
char count;
char vfd_buf;
char key=0;

vfd_buf = key_read; //读按键模式
stb_out &= stb_0;
vfd_out(vfd_buf);
vfd_buf = vfd_in();
stb_out |= stb_1;

switch(vfd_buf)
{
case 2:
key = 3;
break;
case 4:
key = 1;
break;
case 8:
key = 2;
break;

}
return key;
}

char vfd_in() //串移8位数据
{
char count;
char in_bit;
char vfd_buf;

data_addr = 0x01;    // Data Dir
data_ctl |= data_1; // data as input
data_addr = 0x00;    // lock
vfd_buf=0;
for(count=0;count<8;count++)
{
in_bit=0;
wait_uS(1); //延时
if(data_in & data_1) in_bit=1;
in_bit = in_bit << count;
vfd_buf |= in_bit;
clk_out |= clk_1; //clk 置高
wait_uS(1); //延时
clk_out &= clk_0; //clk 置低
}

return vfd_buf;

}

void wait_uS(unsigned char sec) //延时
{
unsigned char count;
for(count=0;count<sec;count++)
{

}

}

holged · 发表于 2007-10-1 22:11

提示: 作者被禁止或删除内容自动屏蔽

holged · 发表于 2007-10-1 22:14

提示: 作者被禁止或删除内容自动屏蔽

Biglee_163 · 发表于 2007-10-1 22:41

谢谢楼上的朋友帮我回忆起

184328796 · 发表于 2007-10-26 08:41

WWB · 发表于 2007-10-26 09:45

这两个周未我仔细分析一下这些程式。

lusson · 发表于 2007-10-26 09:50

不是不讨论单片机，只是你用的单片机比较偏。还有想问下WWB，PIC16C54是多少钱一片？

[DIY制作] 单片机的应用例子--多功能红外线遥控前级

开工了

_read_ir.asm

VFD驱动程序（C语言编写）

up

社区贡献

优秀设计

论坛贵宾