serial.c

os源代码 os源代码 os源代码 os源代码 os源代码 os源代码

/**************************************************************************
 * file: Serial.c
 *
 * Sandia National Laboratories Test Code
 * This is demo code to exercise the UCOS-II PowerPC 555 port.
 * The task counters increment at different rates to show the 
 * OS is working.
 * Some non-essential code is MPC555 specific.
 * Remove for a different target.
 *
 * Functions:
 * int main (void)
 * void T_Letter_A(void *data); 
 * void T_Letter_B(void *data); 
 * void T_Letter_C(void *data); 
 * void T_Letter_D(void *data); 
 * void T_Number_5(void *data);
 * void T_Number_6(void *data);
 * void ticker_start (INT32S ticks_per_second);
 *
 * Author: R. A. Williams 01/19/2000
 * [e-mail]
 *
 * Version V1.00
 *
/***************************************************************************/

#define GLOBAL_DEFINE		/* Define globals in this file */ 

#include "includes.h"

/* Defines */ 
/* Priorities */ 
enum t_prio { T_L_A_PRIO = 2, T_L_B_PRIO, T_L_C_PRIO, T_L_D_PRIO, T_N_5_PRIO, T_N_6_PRIO };

#define TASK_STK_SIZE     96 // RAW change from 2048
#define T_DELAY		1
/*
 * Note: IMMR_BASE is target specific. Change this value to match the base
 * of the memory-mapped registers on your target
 */ 
#define IMMR_BASE	0x00000000
#define TMBCLKS_PER_SEC 1000000

/*------------
I/O Registers
------------*/
short Com1Con0:0x305008;	/* SCI1 control register 0 */
short Com1Con1:0x30500A;	/* SCI1 control register 1 */
short Com1Status:0x30500C;	/* SCI1 status register */
short Com1Data:0x30500E;	/* SCI1 data register */

extern INT32U HoldMSR;	/*	For MSR */

/*--------------
Global Variables
--------------*/
INT32S ctrT_L_A;
INT32S ctrT_L_B;
INT32S ctrT_L_C;
INT32S Iterations;

OS_STK T_Letter_AStk[TASK_STK_SIZE];
OS_STK T_Letter_BStk[TASK_STK_SIZE];
OS_STK T_Letter_CStk[TASK_STK_SIZE];

INT8U T_Letter_AData;
INT8U T_Letter_BData;
INT8U T_Letter_CData;

INT8U SByte;	/* global byte, contained just received data byte */
/*------------------
Function Prototypes
------------------*/
INT8S putchar(INT8U sbyte);
INT8S ReadyToSend();
void puts(INT8S *sptr);
void putch(INT8S ch);
INT8S putchar(INT8U sbyte);
INT8S SerialReady();
INT8S GetSByte();
void InitCom1();
void inithw(void);
void IrqSvr (void);

/* OS and Test Function prototypes */ 
void T_Letter_A(void *data);
void T_Letter_B(void *data);
void T_Letter_C(void *data);
void ticker_start (INT32S ticks_per_sec);

/* INITIALIZE HARDWARE REGISTERS */
/* This routine is called once following RESET */
void inithw(){
	unsigned long *Rptr;
	unsigned short *sRptr;
/*
@ SPR638 = 0xFFF00800	<--- see __ppc_eabi_init.c
@ SPR560 = 0x00000000

*/
	Rptr = (INT32U *) 0x2fc300;	/* TBSCRK key */
	*Rptr = 0x55CCAA33;
	sRptr = (INT16U *) 0x2fc200;	/* TBSCR */
	*sRptr = 0x3CC1;					/*	Prio 7, Clr A/B, No A/B Int, TB On */
	Rptr = (INT32U *) 0x2fc384;	/* PLPRCRK key */
	*Rptr = 0x55CCAA33;
	Rptr = (INT32U *) 0x2fc30c;	/* TBK Time Base Key */
	*Rptr = 0x55CCAA33;


	Rptr = (INT32U *) 0x2fc000;	/* SIUMCR */
	*Rptr = 0x00;
	Rptr = (INT32U *) 0x2fc004;	/* SYPCR */
	*Rptr = 0xFF88;

	Rptr = (INT32U *) 0x2fc100;	/* BR0 */
	*Rptr = 0x400003;	// 32-bit set here for BDM or external flash
/*	*Rptr = 0x400803;	// 16-bit set here for EEPROM M-SEL position 1 (cs0) */
/*	*Rptr = 0x000003;	// 32-bit set here to use external booting with IMMR Flash disabled */
	Rptr = (INT32U *) 0x2fc104;	/* OR0 */
	*Rptr = 0xfff80012;

	Rptr = (INT32U *) 0x2fc108;	/* BR1 */
	*Rptr = 0x800003;
	Rptr = (INT32U *) 0x2fc10c;	/* OR1 */
	*Rptr = 0xfff80002;	         /* no wait state */

	Rptr = (INT32U *) 0x2fc110;	/* BR2 */
	*Rptr = 0xc00003;
	Rptr = (INT32U *) 0x2fc114;	/* OR2 */
	*Rptr = 0xfffe0022;

	Rptr = (INT32U *) 0x2fc118;	/* BR3 */
	*Rptr = 0x01000403;	         /* Originally for Keypad/LCD */
	Rptr = (INT32U *) 0x2fc11c;	/* OR3 */
	*Rptr = 0xfffe0FF1;	         /* maximum wait states */

	Rptr = (INT32U *) 0x2fc140;	/* DMBR */
	*Rptr = 0x00;
	Rptr = (INT32U *) 0x2fc144;	/* DMOR */
	*Rptr = 0x00;
	Rptr = (INT32U *) 0x2fc280;	/* SCCR */
	*Rptr = 0x10000;
	Rptr = (INT32U *) 0x2fc284;	/* PLPRCR */
	*Rptr = 0x400000;

	Rptr = (INT32U *) 0x2fc024;	/* SGPIODT1 */
	*Rptr = 0x0000;
	Rptr = (INT32U *) 0x2fc028;	/* SGPIODT2 */
	*Rptr = 0x0000;
	Rptr = (INT32U *) 0x2fc02c;	/* SGPIOCR */
	*Rptr = 0x0000;
	Rptr = (INT32U *) 0x2fc030;	/* EMCR */
	*Rptr = 0x0000;
	Rptr = (INT32U *) 0x307f80;	/* UMCR */
	*Rptr = 0x0000;
}

INT16S main(void)
{
	INT32S	idx;
	
	EnterCritical();
	InitCom1();	            /* initialize SCI1 serial port */
	puts("\nWelcome to uC/OSII\n");

	T_Letter_AData = 'A';
	T_Letter_BData = 'B';
	T_Letter_CData = 'c';

	/* Initialize the stack */
	for (idx = 0; idx < TASK_STK_SIZE + 0x10; idx++)
	{
		T_Letter_AStk[idx] = 0xE0E1E2E3;
		T_Letter_BStk[idx] = 0xE0E1E2E3;
		T_Letter_CStk[idx] = 0xE0E1E2E3;
	}

	OSInit ();

	OSTaskCreate (	T_Letter_A,
					(void *)&T_Letter_AData,
					(void *)&T_Letter_AStk[TASK_STK_SIZE],
					T_L_A_PRIO);

	OSTaskCreate (	T_Letter_B,
					(void *)&T_Letter_BData,
					(void *)&T_Letter_BStk[TASK_STK_SIZE],
					T_L_B_PRIO);

	OSTaskCreate (	T_Letter_C,
					(void *)&T_Letter_CData,
					(void *)&T_Letter_CStk[TASK_STK_SIZE],
					T_L_C_PRIO);

	OSStart();
	/* No, it never returns... */ 
	return 0;
}


/***********************************************/
/* TASKS                                       */
/* Note: These are NOT normal function calls   */
/***********************************************/

void T_Letter_A (void * data)
{
	ctrT_L_A = 0;

	/* OSStatInit (); */
	SetDecrementer();
	ticker_start (OS_TICKS_PER_SEC);

	for(;;)
	{
		/*
		 * Output the data letter 'A' at serial port 1.
		 * MPC555 specific.
		 */
		puts("\nTask A\n");
		/* Increment a counter to show it is working */ 
		ctrT_L_A++;
		/* Wait */ 
		OSTimeDly (T_DELAY * OS_TICKS_PER_SEC);	/* Thread drops here. */
	}
}

void T_Letter_B (void * data)
{
	ctrT_L_B = 0;

	for(;;)
	{
		/*
		 * Output the data letter 'B' at serial port 1.
		 * MPC555 specific.
		 */
		puts("\nTask B\n");
		/* Increment a counter to show it is working */ 
		ctrT_L_B++;
		/* Wait */ 
		OSTimeDly (2 * T_DELAY * OS_TICKS_PER_SEC);

	}
}

void T_Letter_C (void * data)
{
	ctrT_L_C = 0;

	for(;;)
	{
		/*
		 * Output the data letter 'C' at serial port 1.
		 * MPC555 specific.
		 */
		puts("\nTask C\n");
		/* Increment a counter to show it is working */ 
		ctrT_L_C++;
		/* Wait */ 
		OSTimeDly (3 * T_DELAY * OS_TICKS_PER_SEC);
	}
}



/***********************************************/
/* Ticker Stuff                                */
/* Note: These are called from Main and Task A */
/***********************************************/

void ticker_start (INT32S ticks_per_second)
{
	INT32U * Rptr;
	
	SetDecrementer();
	HoldMSR = MSR_ALL_EN;				//	Turn interrupts on now.
	ExitCritical();
}

/***********************************************/
/* Utility Functions                           */
/* End of OS related stuff                     */
/***********************************************/

void InitCom1(){
	Com1Con0 = 65;		   /* 9600 Baud */
	Com1Con1 = 0x000C;	/* Transmit & Receive Enabled, no parity, no interrupts */
}

INT8S putchar(INT8U sbyte){
	if(ReadyToSend())	return 1;	/* wait for ready to send */
	Com1Data = (INT16S) sbyte;
	return 0;
}

void putch(INT8S ch){

	if (ch == '\n'){
		putchar(0x0d);
		putchar(0x0a);
	}
	else{
		putchar(ch);
	}
}

void puts(INT8S *sptr){
	while(*sptr){
		putch(*sptr);
		++sptr;
	}
}


/* returns 0 if transmit register ready for another byte */
INT8S ReadyToSend(){
	INT16S Status;
	do{	/* wait for transmit byte sent to the shift register, ready for another */
		Status = Com1Status;
	}while((Status & 0x0100) == 0);
	return 0;
}

/* returns 0 if no serial data is waiting to be received */
INT8S SerialReady(){
	INT16S Status;

	Status = Com1Status;
	if( (Status & 0x0040) == 0){
		return 0;
	}
	return 1;
}

/* wait for a byte to be received from the serial port. */
/* the byte will be stored in the global register:	SByte */
INT8S GetSByte(){
	INT16S Temp1;

	while(SerialReady() == 0) ;	/* wait for new incoming data */

	Temp1 = Com1Data; 	         /* read the port */
	SByte = (INT8U) (Temp1 & 0x00FF);
	return 0;
}