基于单片机的黑白棋课程设计

单片机课程设计报告

目录

1. 设计的系统的目的、用途、功能 (3)

1.1.硬件设计思想和电路原理图 (3)

1.2.红外线发射接收模块 (4)

1.3.棋盘显示模块 (4)

1.4.单片机接口 (5)

1.5.硬件单元的使用 (5)

2. 软件设计思想及软件流程 (6)

2.1.主函数 (6)

2.2.按键输入模块 (7)

2.3.游戏算法模块 (8)

2.4.显示模块 (9)

3. 详细说明软件功能 (9)

3.1.显示模块 (9)

3.2.按键模块 (9)

3.3.黑白棋规则模块（check_chess函数） (9)

3.4.胜利模式（victory函数） (9)

3.5.主函数 (10)

3.6.源程序 (10)

4. 系统测试过程及测试数据 (22)

4.1.硬件测试： (22)

4.2.软件测试单独： (22)

4.3.系统与软件综合测试： (22)

5. 测试数据： (22)

6. 分析相应的指标参数 (22)

7. 所需的全部资源 (23)

8. 成员分工和工作情况............................................................................. 错误！未定义书签。

1.设计的系统的目的、用途、功能

实现对黑白棋游戏的无子化操作，增加游戏的趣味性和方便性。学习实践单片机显示、按键等技术。

每一枚“棋子”就是一枚双色发光二极管，64枚双色发光二极管排成8×8的阵列。每一枚二极管有三支引脚，引脚电平的高低决定了二极管显示的颜色，而有单片机控制双色发光二极管引脚的电平高低，实现棋盘上二极管显示不同颜色，以代表棋子。发光二极管亮度高，功耗低，寿命长，且选用双色发光二极管减少了焊接工作量，发光二极管的两种颜色红色和绿色的对比度也较大，使棋子醒目清楚。

1.1.硬件设计思想和电路原理图

当阻断红外线发射二极管和接收二极管之间的光路时，接收管的电平会变化。用16对红外线发射接收二极管，8对感受行信号，8对感受列信号，行列发射接收二极管的光路的交点即一枚棋子的位置。当手指碰触到某个交点时，一组行列红外管的光路阻断，产生的信号通过优先编码器输入到单片机的IO口。

单片机在本作品中的功能有三点：首先，接收处理红外线接收二极管产生的电平信号；其次，存储棋盘上棋子的状态，计算需要变色的二极管的坐标，并输出到双色发光二极管阵列；再次，计算双方比分，有七段数码管输出，判断游戏的胜负。

图表1工作流程

1.2. 红外线发射接收模块

图表 2红外线发射接收模块

行列各有一组发射接收阵列，构成矩阵键盘。单片机PB7输出高电平时，非门ULN2803转变为低电平，红外线发射二极管开始工作，即使能红外线发射。红外线接收管电平变化的信号先通过非门74HC04，然后通过8-3优先编码器74HC148输出到单片机。

1.3. 棋盘显示模块

图表 3棋盘显示模块

8排上图所示结构构成棋盘。单片机输出的控制双色二极管变色的信号通过一个3-8译码器74LS138译码再通过两个非门对双色发光二极管的颜色。利用ULN2803灌电流大的特

红外线发射二极管

红外线接收二极管

点，避免芯片的损坏。

1.4.单片机接口

图表4单片机接口

1.5.硬件单元的使用

每一枚“棋子”就是一枚双色发光二极管，64枚双色发光二极管排成8×8的阵列。每一枚二极管有三支引脚，引脚电平的高低决定了二极管显示的颜色，而有单片机控制双色发光二极管引脚的电平高低，实现棋盘上二极管显示不同颜色，以代表棋子。

有两组各八对红外线发射接收二极管，每只二极管前面加一只准直小管以保证任意两对红外线发射接收管的信号不相互干扰。使用时用手指遮挡一组行列红外发射接收二极管光路的交点（即对应于棋盘上的一枚双色二极管），把由这些红外发射接收二极管组成的虚拟按键触发产生一个落子点的位置坐标信息，再由单片机识别判断。还设计了“让棋”“悔棋”按键使游戏更加完善。两个七段数码管负责显示双方成绩，双方各有一枚代表自己颜色的发光二极管，自己所对应的二极管亮时代表落子权在自己手中。当某一方胜利时，棋盘上会闪动胜方棋子所对应的颜色。

2.软件设计思想及软件流程2.1.主函数

图表1 主函数

图表2 棋子按键

图表3 悔棋让棋按键

图表4 check_chess函数

图表5 button函数

2.4.显示模块

定时器timer0每隔1ms触发一次中断，扫描相应LED和七段数码管。

3.详细说明软件功能

3.1.显示模块

利用定时器0比较中断，每隔1ms改变各个端口的输出，从而实现棋盘和记分板的扫描。

3.2.按键模块

分为红外按键（落子按键）和悔棋让棋按键两部分：

红外按键：利用定时器2的溢出中断，每隔65ms扫描一次红外按键阵列。若有输入，则使能其比较中断，2ms后在比较中断中比较两次输入的键值，实现消抖处理。

悔棋让棋按键：悔棋让棋按键接在了PB2端口，一旦有键按下，便会触发INT2下降沿中断。在INT2的中断函数中，将check_button 置1。主函数中，检查chess_button的值，若为1，则执行button函数。button函数中，实现按键消抖，和判断具体是悔棋还是让棋的功能并加以执行。若PB1值为1，则执行让棋操作，值为0执行悔棋操作。

3.3.黑白棋规则模块（check_chess函数）

通过检查当前落子位置周围的八个方位上能否使对方棋子变色。能变色，则允许落子，实现棋子存储数组chess和比分记录变量red, green的相应改变。

3.4.胜利模式（victory函数）

获胜方棋子闪动

3.5.主函数

首先实现单片机的初始化。然后判断棋局是否结束。没结束则一直检测是否落子和有悔棋让棋按键按下。若有落子，执行check_chess函数。若有悔棋让棋按键按下，则执行button 函数。棋局结束后，执行victory 函数。

3.6.源程序

#include

#include

flash unsigned char disbuffer[10]={0x01,0x67,0x12,0x22,0x64,0x28,0x08,0x63,0x00,0x20}; unsigned char chess[2][8]={{0,0,0,0x10,0x08,0,0,0},{0,0,0,0x08,0x10,0,0,0}};

//red=0,green=1

unsigned char red=2,green=2,state=1,check=0,vic=0,count=0,count_timer0=9,check_button=0; unsigned char chess_res[2][8]={{0,0,0,0x10,0x08,0,0,0},{0,0,0,0x08,0x10,0,0,0}};

unsigned char chess_p[2][8]={{0,0,0,0x10,0x08,0,0,0},{0,0,0,0x08,0x10,0,0,0}};

unsigned char red_res=2,green_res=2;

unsigned char input=0x00,input_0,input_jtd=0x20;

/*****************************************************

延时函数，实现延时1ms

*****************************************************/

void delay_ms(char n)

{

char i;

while(n--)

{

i=400;

while(--i)

{

NOP();

NOP();

NOP();

NOP();

NOP();

}

}

}

/*******************************************************

各个I/O端口的初始化

********************************************************/

void port_init(void)

{

PORTA = 0x00;

DDRA = 0xFF;

PORTB = 0x06;

DDRB = 0xF9;

PORTC = 0x00; //m103 output only

DDRC = 0xFF;

PORTD = 0x20;

DDRD = 0x00;

}

/**********************************************

定时器0的初始化，利用其比较中断，每隔1ms改变各个端口的输出，从而实现棋盘和记分板的扫描。

*********************************************/

void timer0_init(void)

{

TCCR0 = 0x00; //stop

TCNT0 = 0x00; //set count

OCR0 = 0x3F; //set compare

TCCR0 = 0x0B; //start timer

}

#pragma interrupt_handler timer0_comp_isr:20

void timer0_comp_isr(void)

{

//compare occured TCNT0=OCR0

if(count_timer0==9)

{

PORTB=0X06;

PORTC=disbuffer[green%10]|(state<<7);

PORTA=disbuffer[red%10]|(~state<<7);

PORTB=0x86;

}

else if(count_timer0==8)

{

PORTB=0X06;

PORTC=disbuffer[green/10]|(state<<7);

PORTA=disbuffer[red/10]|(~state<<7);

PORTB=0x07;

}

else

{

PORTB=0X06;

PORTA=0x00;

PORTC=0X00;

PORTB=0X0E|(count_timer0<<4);

PORTA=chess[0][count_timer0];

PORTC=chess[1][count_timer0];

}

if(!(count_timer0--))

{

count_timer0=9;

if(!input_jtd&&input_jtd==(PIND&0x20)) //PINC5的输入禁用JTAG端口，从而使屏幕正常显示

{

MCUCSR|=0X80;

MCUCSR|=0X80;

input_jtd=0x20;

}

else input_jtd=PIND&0X20;

}

if(vic) count++;

}

/***************************************************************

利用定时器2的溢出中断，每隔65ms扫描一次红外按键阵列。若有输入，则使能其比较中断，2ms后在比较中断中比较两次输入的键值，实现消抖处理

****************************************************************/

void timer2_init(void)

{

TCCR2 = 0x00; //stop

ASSR = 0x00; //set async mode

TCNT2 = 0x00 /*INVALID SETTING*/; //setup

OCR2 = 0x10 /*INVALID SETTING*/;

TCCR2 = 0x07; //start

}

#pragma interrupt_handler timer2_comp_isr:4

void timer2_comp_isr(void)

{

//compare occured TCNT2=OCR2

if((PIND&~0x20)==input_0)

{

input=input_0;

}

PORTB=0X06;

if(count_timer0==9) count_timer0=0;

else count_timer0++;

TIMSK = 0x42;

}

#pragma interrupt_handler timer2_ovf_isr:5

void timer2_ovf_isr(void)

{unsigned char i=8;

TCNT2 = 0x00 /*INVALID SETTING*/; //reload counter value

TIMSK=0X40;

PORTB=0x06;

PORTA=0X7F;

PORTC=0X7F;

PORTB=0X86;

delay_ms(2);

input_0=PIND&~0x20;

if((PIND&1)&&(input!=input_0)) TIMSK = 0xC0;

else

{

PORTB=0X06;

if(count_timer0==9) count_timer0=0;

else count_timer0++;

TIMSK=0X42;

}

}

/**************************************************************

悔棋让棋按键接在了PB2端口，一旦有键按下，便会触发下降沿中断。在INT2的中断函数中，将check_button 置1。主函数中，检查chess_button的值，若为1，则执行button函数。button函数中，实现按键消抖，和判断具体是悔棋还是让棋的功能并加以执行。若PB1值为1，则执行让棋操作，值为0执行悔棋操作。

*************************************************************/

#pragma interrupt_handler int2_isr:19

void int2_isr(void)

{

//external interupt on INT2

check_button=1;

}

void button()

{

//external interupt on INT2

char com;

com=PINB&0x02;

delay_ms(10);

if((PINB&0x02)==com&&(PINB&0x04)==0)

{

state=~state&0x01;

if(!com)

{while(i--)

{

chess[0][i]=chess_res[0][i];

chess[1][i]=chess_res[1][i];

}

red=red_res;

green=green_res;

}

}

check_button=0;

}

//初始化

void init_devices(void)

{

//stop errant interrupts until set up

CLI(); //disable all interrupts

MCUCSR&=0X7F;

MCUCSR&=0X7F;

port_init();

timer0_init();

timer2_init();

MCUCR = 0x00;

GICR = 0x20;

TIMSK = 0x42 ;//timer interrupt sources

SEI(); //re-enable interrupts

//all peripherals are now initialized

}

/***************************************************************************** 通过检查当前落子位置周围的八个方位上能否使对方棋子变色。能变色，则允许落子，实现棋子存储数组chess和比分记录变量red, green的相应改变。

*****************************************************************************/ void check_chess(void)

{

unsigned char row,col_res,row_res,state_re;

unsigned char i,j,col=8,n=0;

unsigned char red_p,green_p;

while(col--)

{

chess_p[0][col]=chess[0][col];

chess_p[1][col]=chess[1][col];

}

red_p=red;

green_p=green;

col_res=(~input>>4&0X01)|(~input>>5&0X06);

row_res=~input>>1&0x07;

state_re=~state&0x01;

if (!(chess[state][col_res]&1<

if(row_res)

{row=row_res; //col up check

do

row--;

while(chess[state_re][col_res]&1<

if(chess[state][col_res]&1<

{

chess[state][col_res]|=1<

i=row_res-row;

while(--i)

{

chess[state][col_res]|=1<<(row+i);

chess[state_re][col_res]&=~(1<

}

i=row_res-row;

if(state)

{

green+=i-n;

red-=i-1;

}

else

{

red+=i-n;

green-=i-1;

}

n=1;

}}

if(7-row_res)

{row=row_res; //col down check

do

row++;

while(chess[state_re][col_res]&1<

chess[state][col_res]|=1<

i=row-row_res;

while(--i)

{

chess[state][col_res]|=1<<(row-i);

chess[state_re][col_res]&=~(1<<(row-i));

}

i=row-row_res;

if(state)

{

green+=i-n;

red-=i-1;

}

else

{

red+=i-n;

green-=i-1;

}

n=1;

}}

if(col_res)

{col=col_res;//row left check

do

col--;

while(chess[state_re][col]&1<

if(chess[state][col]&1<

chess[state][col_res]|=1<

j=col_res-col;

while(--j)

{

chess[state][col+j]|=1<

chess[state_re][col+j]&=~(1<

}

j=col_res-col;

if(state)

{

green+=j-n;

red-=j-1;

}

else

{

red+=j-n;

green-=j-1;

}

n=1;

}}

if(7-col_res)

{col=col_res;//row right check

do

col++;

while(chess[state_re][col]&1<

chess[state][col_res]|=1<

j=col-col_res;

while(--j)

{

chess[state][col-j]|=1<

chess[state_re][col-j]&=~(1<

}

j=col-col_res;

if(state)

{

green+=j-n;

red-=j-1;

}

else

{

red+=j-n;

green-=j-1;

}

n=1;

}}

if(row_res&&col_res)

{ row=row_res;col=col_res;//angle up left check

do

{row--;col--;}

while(chess[state_re][col]&1<

if(chess[state][col]&1<

{

chess[state][col_res]|=1<

i=row_res-row;

while(--i)

{

chess[state][col+i]|=1<<(row+i);

chess[state_re][col+i]&=~(1<<(row+i));

}

i=row_res-row;

if(state)

{

green+=i-n;

red-=i-1;

}

else

{

red+=i-n;

green-=i-1;

}

n=1;

}

}

if((7-row_res)&&(7-col_res))

{row=row_res;col=col_res;//angle right down check

do

{row++;col++;}

while(chess[state_re][col]&1<

{

chess[state][col_res]|=1<

i=row-row_res;

while(--i)

{

chess[state][col-i]|=1<<(row-i);

chess[state_re][col-i]&=~(1<<(row-i));

}

i=row-row_res;

if(state)

{

green+=i-n;

red-=i-1;

}

else

{

red+=i-n;

green-=i-1;

}

n=1;

}

}

if(col_res&&(7-row_res))

{row=row_res;col=col_res;//angle left down check do

{row++;col--;}

while(chess[state_re][col]&1<

{

chess[state][col_res]|=1<

i=row-row_res;

while(i--)

{

chess[state][col+i]|=1<<(row-i);

chess[state_re][col+i]&=~(1<<(row-i));

}

i=row-row_res;

if(state)

{

green+=i-n;

red-=i-1;

}

else

{

red+=i-n;

green-=i-1;

}

n=1;

}

}

if(row_res&&(7-col_res))

{row=row_res;col=col_res;//angle right up check

do

{row--;col++;}

while(chess[state_re][col]&1<

if(chess[state][col]&1<

{

chess[state][col_res]|=1<

i=row_res-row;

while(--i)

{

chess[state][col-i]|=1<<(row+i);

chess[state_re][col-i]&=~(1<

}

i=row_res-row;

if(state)

{

green+=i-n;

red-=i-1;

}

else

{

red+=i-n;

green-=i-1;

}

n=1;

}

}

if(n)

{

state=~state&0x01;

red_res=red_p;

green_res=green_p;

i=8;

while(i--)

{

chess_res[0][i]=chess_p[0][i];

chess_res[1][i]=chess_p[1][i];

}

}

}

}

/********************************************************** 胜利模式，获胜方棋子闪动