cyan_base_driver.c

使用CYAN单片机的ECOG1开发板连接SIM300C的GSM模块开发的短信收发程序.供UART和AT指令编程者参考

/******************************************************************************
MODE:		AML--#GPS+accelerator+compass
MCU:		Cyan eCOG1k
COMPILER:	CyanIDE v1.41
FILE NAME:	cyan_base_driver C source code files
******************************************************************************/
#define cyan_base_driver_code

/******************************************************************************
include all head files
******************************************************************************/
#include "cyan_base_driver.h"

/******************************************************************************
Declaration of static functions.
******************************************************************************/
void delay_2us(unsigned int us_reg);
void delay_ms(unsigned int ms_reg);

int putchar(int c);
void uart_initialization(void);
void timer_initialization(void);
int getchar_a(void);
char *_fcvt_(char *str_save,double float_data);

/******************************************************************************
FUNCTIONS
    dilay functions for cyan .

RETURNS
   The MISO signal that was received.
******************************************************************************/

//-----------------------------------------------------------------------------
//delay us @5MHz
//-----------------------------------------------------------------------------
void delay_2us(unsigned int us_reg)
{
	unsigned int uuu;			//delay time = 1*2us ~ 65535*2us.
	while(us_reg-- > 0)
	{
		uuu= 5;					//delay time = 2us.
		while(uuu-- >0){}
	}
}
//-----------------------------------------------------------------------------
//delay ms @5MHz
//-----------------------------------------------------------------------------
void delay_ms(unsigned int ms_reg)
{
	unsigned int mmm;			//delay time = 1ms ~ 65535ms.
	while(ms_reg-- > 0)
	{
		mmm = 2500;				//delay time = 1ms.
		while(mmm-- >0){}
	}
}

/******************************************************************************
FUNCTION
   Implements the ANSI standard character output function. This version
   outputs a character through the DUART channel B and the LCD.

RETURNS
   The character.
******************************************************************************/
void __irq_entry usrb_tx_handler(void)
{
//	while (0 == fd.duart.b_sts.tx_rdy)
//		;
	//xy_data_transmit();
	//GPS_data_transmit();
//	fd.duart.b_int_dis.tx_rdy = 1;
	//rg.io.gp0_3_out = IO_GP0_3_OUT_CLR1_MASK | IO_GP0_3_OUT_SET1_MASK;
}

void __irq_entry usra_tx_handler(void)
{
	//GPS_data_transmit();
	//fd.duart.a_int_dis.tx_rdy = 1;
}

int putchar(int c)
{
	// Wait for the UART to be ready to transmit
	while (sim300C_CTS_Sts == 1)
		;
    while (0 == fd.duart.b_sts.tx_rdy)
       ;

    rg.duart.b_tx8 = c;
    return (c);
}
int getchar_a(void)
{
	int c;
	while (fd.duart.a_sts.rx_act == 0)
		;
	c = rg.duart.a_rx;
	return(c);
}
/******************************************************************************
NAME
    uart_initialization

SYNOPSIS
    void uart_initialization(void)

FUNCTION
    initialization uarta
    
NOTE
    Duart clk ---> HIGH_PLL by8
    
	Baud 	Duart.a_baud	Reality baud	Tolerance
	1200		650			1200.1			0.01%
	2400		324			2403.8			0.2%
	3600		216			3600.2			0.01%
	4800		162			4792.9			0.2%
	7200		107			7233			0.5%
	9600		80			9645.1			0.5%
	19200		40			19054.9			0.8%
	38400		19			39062.5			1.7%
	57600		13			55803.6			3.1%
	115200		6			111607.1		3.1%
    
RETURNS
    Nothing
******************************************************************************/
void uart_initialization(void)
{
	fd.duart.ctrl.a_rx_en = 1;				//enable UARTA receiver.
	//fd.duart.ctrl.a_tx_en = 1;
	//fd.duart.ctrl.b_rx_en = 1;
	fd.duart.ctrl.b_tx_en = 1;
	
	fd.duart.a_int_en.rx_1b_rdy = 1;		// Enable duart A receive interrupt
	//fd.duart.a_int_dis.rx_1b_rdy = 1;		// Disable duart B receive interrupt
	//fd.duart.b_int_en.tx_rdy = 1;			// Enable duart B tx interrupt
	fd.duart.b_int_dis.tx_rdy = 1;		// Disable duart B tx interrupt
	
	//fd.duart.b_tmr_cfg.guard = 63;			// Tx interval timer = 63 clock cycle
	
	rg.duart.a_baud = 162;					//baud = 4800;
	rg.duart.b_baud = 80;					//baud = 9600;
	
}
/******************************************************************************
** init Timer2
******************************************************************************/
void timer_initialization(void)
{
	//------------------------------------------------------------------------
	//timer 1
	//------------------------------------------------------------------------
	fd.tim.ctrl_en.cnt1_cnt = 1;//TIM_CTRL_EN_CNT1_CNT_MASK;
    fd.tim.int_dis1.cnt1_exp = 1;//TIM_INT_EN1_CNT1_EXP_MASK;
	
	
	//------------------------------------------------------------------------
	//timer 2
	//------------------------------------------------------------------------
	fd.tim.ctrl_en.cnt2_cnt = 1;
	//fd.ssm.rst_clr.cnt2 = 1;			//clr timer2 reset.
	//fd.ssm.div_sel.cnt2 = 0;			//reference(high freq) clock,not PLL.
	
	//fd.ssm.clk_dis.cnt2 = 1;			//disable timer2 clock.
	//fd.ssm.tap_sel2.cnt2 = 0;			//timer2 Clock is divided by 4.
	//fd.ssm.clk_en.cnt2 = 1;				//enable timer2 clock.
	
	//fd.tim.int_en1.cnt2_exp = 1;		//enable timer2 interrupt.
	fd.tim.int_dis1.cnt2_exp = 1;		//disable timer2 interrupt.
	
	//fd.tim.ctrl_dis.cnt2_cnt = 1;		//disable Timer2.
	//fd.tim.ctrl_dis.cnt2_auto_re_ld = 1;//disable timer2 auto reload.
	//rg.tim.cnt2_ld = T2_LOAD_VALUE;		//timer2 load value.
	//fd.tim.cmd.cnt2_ld = 1;				//loading value to timer2.
	//fd.tim.int_clr1.cnt2_exp = 1;		// Clear Timer2 interrupt flag	
}
/******************************************************************************
float point change to string.
******************************************************************************/
char *_fcvt_(char *str_save,double float_data)
{
	char			str_temp[56]	= {0};
	long			u_l_int			= (long)float_data;
	int				negative_flag	= 0;
	long			u_l_temp		= 0;
	int				int_count		= 0;
	int				i				= 0;
	long			one_int			= 0;
	double			_point_			= 0;
	int				one_int_p		= 0;
	unsigned int	point_len		= 5;
	
	
	if(float_data < 0)
	{
		u_l_temp = -u_l_int;
		negative_flag = 1;
	}
	else
	{
		u_l_temp = u_l_int;
		negative_flag = 0;
	}
	
	while (u_l_temp)
	{
		one_int = (long)(u_l_temp / 10) * 10;
		one_int = u_l_temp - one_int;
		str_temp[int_count++] = (char)(one_int + 0x30);
		u_l_temp = u_l_temp / 10;
	}
	
	if(int_count == 0)
	{
		str_temp[int_count++] = '0';
	}
	if(negative_flag) 
	{
		str_temp[int_count ++] = '-';
	}
	
	i = int_count;
	while (i)
	{
		str_save[int_count-i] = str_temp[i-1];
		--i;
	}
	str_save[int_count++] = '.';

	_point_ = float_data - (double)u_l_int;
	_point_ = (negative_flag ? -_point_ : _point_);
	while (point_len)
	{
		_point_ *= 10;
		one_int_p = (int)(_point_);
		if((one_int_p > 9) || (one_int_p < 0)) 
			one_int_p = 0;
		str_save[int_count++] = one_int_p + 0x30;
		_point_ -= one_int_p;
		--point_len;
	}
	str_save[int_count++] = 0;
	return str_save;
}

/******************************************************************************
end
******************************************************************************/