test.c

ucosii的源代码希望能给予学习嵌入式系统的朋友一定的帮助

/*
**************************************************************************************************************
*                                                uC/OS-II
*                                          The Real-Time Kernel
*
*
*                                             AVR Sample code
* File        : TEST.C
* By          : Ole Saether
* Version     : V1.08
*			2006. 2. TETRIS PROGRAM with uC/OS-II 
*			This project has used AVR MCU with RTOS.
*
*			*UART Routine REMOVE &  unnecessary code REMOVE & key task add.
*
*			This Version. 
*			Success Graphic LCD.
*			Drop Block.
*			Key Input Task Add.
*			Line Delete (IdentLine()).
*
*			Next Taget.
*			Score Display
*			Ending().
**************************************************************************************************************
*/

#include "includes.h"
#include "util_bk.h"
#include "lcd_bk.h"
#include <avr/stdlib.h>	


/*
**************************************************************************************************************
*                                               CONSTANTS
**************************************************************************************************************
*/
#define  TASK_STK_SIZE  OS_TASK_DEF_STK_SIZE            /* Size of each task's stacks (# of bytes)          */

#define CLI_LED PORTD = PORTD | 0x04				//PORTD 2	LED
#define SET_LED PORTD = PORTD & 0xfb

/*
**************************************************************************************************************
*                                               VARIABLES
**************************************************************************************************************
*/

OS_STK          TaskStartStk[TASK_STK_SIZE];

/*
**************************************************************************************************************
*                                           FUNCTION PROTOTYPES
**************************************************************************************************************
*/

void  Task(void *data);                                 /* Function prototypes of tasks                     */
void  TaskStart(void *data);                            /* Function prototypes of Startup task              */
void  AvrInit(void);                                    /* Initialize AVR                                   */

/*
**************************************************************************************************************
*                                               TASK ADD
**************************************************************************************************************
*/
#define KEY_CHAT	3
#define KEY_OVERLAP 7
#define KEY_TETRIS 0xf0

OS_STK          TaskKeyStk[TASK_STK_SIZE];					//Task Stack.
void  TaskKey(void *data);
void TetrisKey(INT8U ch);


OS_STK          TaskTetrisStk[TASK_STK_SIZE];				//Task Stack.
void  TaskTetris(void *data);

void Set_Port(unsigned char Reg, unsigned char ddr_reg, unsigned char val);
void WriteData(INT8U LcdCS, INT8U data);
void WriteInstruct(INT8U LcdCS, INT8U Command);
void WriteCom(INT8U LcdCS, INT8U LcdData);
void DispBlock(INT8S x, INT8S y, INT8U LcdCS, INT8U Flag);
void StartFild(void);
void FirstDraw(void);
void BlockMove(int a, int b);
int LookBlock(int a, int b, int c);
void BlockCopy(void);
void DrawBlock(INT8S a, INT8S b);
void DelBlock(INT8S a, INT8S b);
int GtBlock(int a, int b);
void BlockTurn(void);
void IdentLine(void);
void StartTetris(void);
void Ending(void);

////tetris
#define WIDTH 8 
#define HEIGHT 17 
#define DELBLOCK 1
#define DISBLOCK 2
#define UP_KEY 	0x04			//0x48 
#define DOWN_KEY 0x08		//0x50 
#define RIGHT_KEY 0x02		//0x4d 
#define LEFT_KEY 0x01			//0x4b 
#define SPC_KEY 0x20 


char Fild[HEIGHT+2][WIDTH+2];
char NextBlock[4][2] = {0, 0, 0, 0, 0, 0, 0, 0};
char NextType;
char BlockCode[4][2];
char OldBlock[4][2]; 
char NewBlock[4][2];
char BlockType; 
int FallTime = 0; 
int MaxFallTime = 1;

void StartFild(void);
void CreBlock(void);

OS_EVENT *DrawBlockSem;								//Prevent to use overlap

INT8U KeyLevel=0;

/*
**************************************************************************************************************
*                                                MAIN
**************************************************************************************************************
*/

int main (void)
{
  AvrInit();                                          /* Initialize the AVR UART and Timer and Memory                */
  OSInit();

	DrawBlockSem = OSSemCreate(1);
  OSTaskCreate(TaskStart, (void *)0, (void *)&TaskStartStk[TASK_STK_SIZE - 1], 3);
    
  OSStart();                                          /* Start multitasking                               */
  return 0;
}

/*
**************************************************************************************************************
*                                              STARTUP TASK
**************************************************************************************************************
*/

void TaskStart (void *data)
{

  data = data;                                        /* Prevent compiler warning                         */


  OSStatInit();                                       /* Initialize uC/OS-II's statistics                 */
	OSTaskCreate(TaskKey, (void *)0, (void *)&TaskKeyStk[TASK_STK_SIZE - 1], 9);
	
	WriteInstruct('0',GLCD_ON);
	WriteInstruct('1',GLCD_ON);
	WriteCom('0',0x00);
	WriteCom('1',0x00);
	GLCDString(0,9,"uC/OS-II");
	GLCDString(1,8,"v2.52");
	GLCDString(1,1,"PRESS");
	GLCDString(0,0,"ANY KEY!");
	
  for (;;) {
    OSTimeDlyHMSM(0, 0, 1, 0);                        /* Wait one second                                  */
  }
}
/*
**************************************************************************************************************
*                                                  KEY Input Task
**************************************************************************************************************
*/


void  TaskKey(void *data)
{
	data = data;
	INT8U KeyData, KeyBuffer, KeyValue=KEY_TETRIS;

	OSTaskDelReq(3);											//Delete unnecessary task.

	KeyChkReg KeyInVal;

	KeyInVal.KeyBuff = 0;
	KeyInVal.KeyCnt = 0;
	KeyInVal.ChatCnt = KEY_CHAT;
	KeyInVal.DefValue = KEY_TETRIS;
	KeyInVal.KeyOverlap = KEY_OVERLAP;
	
	for(;;){

		if(KeyLevel == 0){										//Main Menu
			KeyData = PINE & KEY_TETRIS;
			KeyValue = KeyChatExt(KeyData, &KeyInVal);

			if(KeyValue != 0)
			{
				StartTetris();
				KeyLevel = 1;
			}
		}else if(KeyLevel == 1){								//Tetris
			KeyData = PINE & KEY_TETRIS;
			KeyValue = KeyChatExt(KeyData, &KeyInVal);

			KeyData = (((~KeyValue)>>4) & (KEY_TETRIS >> 4));	
			TetrisKey(KeyData);
		}
		
	OSTimeDlyHMSM(0,0,0,40);
	}
}



void TetrisKey(INT8U ch){
	
	INT8U i;
	
     if((ch == UP_KEY)||(ch == RIGHT_KEY)||(ch == LEFT_KEY)||(ch == DOWN_KEY))
     {
		ClrBit(PORTD, 2);
		switch(ch)
	      {
      	       case UP_KEY : BlockCopy(); BlockTurn();break; 
               case DOWN_KEY : BlockCopy(); if(LookBlock(4, 0, -1)) BlockMove(1, -1); break; 
               case RIGHT_KEY : BlockCopy(); if(LookBlock(4, 1, 0)) BlockMove(0, 1); break; 
               case LEFT_KEY : BlockCopy(); if(LookBlock(4, -1, 0)) BlockMove(0, -1); break; 
//               case SPC_KEY : BlockCopy(); while(LookBlock(4, 0, -1)) BlockMove(1, -1); break; 
               default : break;
	      } 
	    for(i = 0; i < 4; i++)
	       DelBlock(OldBlock[i][0], OldBlock[i][1]);
	    for(i = 0; i < 4; i++)
	       DrawBlock(NewBlock[i][0], NewBlock[i][1]); 
     }
     ch = 0;
}

void StartTetris(void)
{
	WriteInstruct('0',GLCD_ON);
	WriteInstruct('1',GLCD_ON);
    WriteCom('0',0xff);
    OSTimeDlyHMSM(0,0,1,0);
    WriteCom('0',0x00);
    OSTimeDlyHMSM(0,0,1,0);
    WriteCom('1',0xff);
    OSTimeDlyHMSM(0,0,1,0);
    WriteCom('1',0x00);
    OSTimeDlyHMSM(0,0,1,0);

	GLCDString(1,0,"START!");
	OSTimeDlyHMSM(0,0,1,0);
	WriteCom('0',0x00);
	OSTaskCreate(TaskTetris, (void *)0, (void *)&TaskTetrisStk[TASK_STK_SIZE - 1], 10);
}

/*
**************************************************************************************************************
*                                                  Tetris Task
**************************************************************************************************************
*/
//**block[0][x], **block[1][y]
#define TETRISMAIN
void TaskTetris (void *data)
{
	INT8U score, i;
	INT16S loop1, loop2; 
	volatile INT8U Led;

	data = data;


	for(;;){
#ifdef TETRISMAIN
		loop1 = TRUE;
		loop2 = TRUE;
		
    	StartFild();
		score = 0; 
		   CreBlock(); 					//Block Create & Delete

		   while(loop1)
		   {
		   	CreBlock(); 					//Block Create & Delete
		    FirstDraw(); 
			
		    while(loop2)
		    {

			 OSTimeDlyHMSM(0,0,1,500);
		     FallTime++;
		     if(FallTime == MaxFallTime)
		     {
		      if(LookBlock(4, 0, -1)) 								//One Step Down 
		      {
		       BlockCopy();
		       BlockMove(1, -1);
		       
		      	for(i = 0; i < 4; i++)
		        	DelBlock(OldBlock[i][0], OldBlock[i][1]);
		       	for(i = 0; i < 4; i++)
		       		DrawBlock(NewBlock[i][0], NewBlock[i][1]); 	

		      }else{
		       	for(i = 0; i < 4; i++)
					Fild[NewBlock[i][1]][NewBlock[i][0]] = (char )1;	//block_color;
		       		loop2 = FALSE;
		      }
		     FallTime = 0;
		     }

		   }
		    loop2 = TRUE;
		    if(Fild[HEIGHT][WIDTH / 2])
	     		loop1 = FALSE;
		    IdentLine(); 
		   }