忘備録-備忘録

技術的な備忘録

RX62Nのタイマを使うその3

2015-11-26 09:37:31 | RX62N
RX62NのタイマMTUを使いusオーダーで時間待ちするプログラムです。割り込みを使用しないバージョンです。

  1. #include "iodefine.h"
  2. #define PCLK    48    //PCLK = 48MHz
  3. unsigned int usecCount;
  4. /*
  5.  * タイマの初期化
  6.  *  使用タイマ MTU10
  7.  * 割込みは使用しないフラグは使用する。
  8.  */
  9. void initTimer(void)
  10. {
  11.     MSTP(MTU10) = 0;
  12.     MTU10.TCR.BIT.TPSC = 0x02;    // PCLK/16でカウント
  13.     MTU10.TCNT = 0;                //フリーランカウンタ
  14.     usecCount = PCLK*1000000L/1000000L/16L;    //1usecのカウント値
  15. }
  16. /*
  17.  * タイマスタート
  18.  */
  19. void startMTU(void)
  20. {
  21.     MTU10.TCNT = 0;
  22.     MTUB.TSTR.BIT.CST4 = 1;            /* Start MTU2_8 */
  23. }
  24. /*
  25.  * タイマストップ
  26.  */
  27. void stopMTU(void)
  28. {
  29.     MTUB.TSTR.BIT.CST4 = 0;            /* Stop MTU2_8 */
  30. }
  31. /*
  32.  * usecオーダーでの時間待ち
  33.  */
  34. void delay_us(unsigned int us)
  35. {
  36.     unsigned int waitCount;
  37.     waitCount = us * usecCount;    //カウンタの値がいくつになれば指定した時間が来たか
  38.                                 //16bitなのでオーバーフローに注意
  39.     startMTU();
  40.     while(MTU10.TCNT <waitCount);
  41.     stopMTU();
  42. }
  43. /*
  44.  * msecオーダーでの時間待ち
  45.  */
  46. void delay_ms(unsigned int ms)
  47. {
  48.     unsigned int i;
  49.     for(i=0;i<ms;i++) {
  50.         delay_us(1000);
  51.     }
  52. }

RX62Nのタイマを使うその2

2015-11-25 14:06:39 | RX62N
RX62NのタイマCMTを使いusオーダーで時間待ちするプログラムです。割り込みを使用しています。頻繁に割り込みが発生するので実用的かどうかはわかりません。

  1. #include <machine.h>
  2. #include "timer.h"
  3. #include "iodefine.h"
  4. #include "vect.h"
  5. #define PCLK    48    //PCLK = 48MHz
  6. /* 1usecでカウントアップする変数 */
  7. static volatile unsigned int utimer;
  8. /*
  9.    タイマ初期化 使用するタイマCMT1
  10.    引数  無し
  11.    戻り値 無し
  12. */
  13. void initTimer(void)
  14. {
  15.     MSTP(CMT1) = 0;                                    // enable CMT1
  16.     CMT1.CMCR.WORD = 0x0040;                        // 1/8
  17.     //CMT1.CMCOR = PCLK*1000000L/1000L/8L - 1;        // 1000Hz(1ms)
  18.     CMT1.CMCOR = PCLK*1000000L/1000000L/8L - 1;        // 1MHz(1us)
  19.     ICU.IER[IER_CMT1_CMI1].BIT.IEN_CMT1_CMI1 = 1;    //Enable CMIE
  20.     ICU.IPR[IPR_CMT1_CMI1].BYTE = 8;                // Set interrupt priority level
  21.     CMT.CMSTR0.WORD |= 0x0002;                        // start CMT0 CMT1
  22.     
  23.     utimer = 0;    //タイマの初期化
  24. }
  25. /*
  26.    タイマカウンタの初期化
  27.    引数  タイマ番号
  28.    戻り値 無し
  29. */
  30. void clearTimer(void)
  31. {
  32.     utimer = 0;
  33. }
  34. /*
  35.    タイマの値を取得する
  36.    引数  タイマ番号
  37.    戻り値 タイマの値
  38. */
  39. unsigned int getTimer(void)
  40. {
  41.     return utimer;
  42. }
  43. /*
  44.    mSec単位でウェイトをかける
  45.    引数   待ち時間 ミリ秒
  46.    戻り値  無し
  47. */
  48. void delay_ms(unsigned int ms)
  49. {
  50.     unsigned int us;
  51.     us = 1000*ms;
  52.     clearTimer();
  53.     while(getTimer()<=us);
  54. }
  55. /*
  56.    uSec単位でウェイトをかける
  57.    引数   待ち時間 マイクロ秒
  58.    戻り値  無し
  59. */
  60. void delay_us(unsigned int us)
  61. {
  62.     clearTimer();
  63.     while(getTimer()<=us);
  64. }
  65. /*
  66.    タイマ割込みプログラム
  67.    CMT1割込みで起動
  68. */
  69. void Excep_CMT1_CMI1(void)
  70. {
  71.     utimer++;
  72. }

RX62Nのタイマを使うその1

2015-11-25 14:01:23 | RX62N
RX62NのタイマMTUを使いmsオーダーで時間待ちするプログラムです。割り込みを使用していません。

  1. #include "iodefine.h"
  2. /*
  3.  * タイマの初期化
  4.  *  使用タイマ MTU8
  5.  * 割込みは使用しないがフラグは使用する。
  6.  */
  7. void initTimer(void)
  8. {
  9.     MSTP(MTU8) = 0;
  10.     MTU8.TCR.BYTE = 0x43;
  11.     MTU8.TIER.BIT.TGIEB = 1;
  12.     MTU8.TCNT = 0;                
  13.     MTU8.TGRB = 750 - 1;        /* PCLK = 48MHzで1msecごとに割り込み        */
  14.     IR(MTU8,TGIB8) = 0;
  15. }
  16. /*
  17.  * タイマスタート
  18.  */
  19. void startMTU(void)
  20. {    
  21.     MTU8.TCNT = 0;
  22.     MTUB.TSTR.BIT.CST2 = 1;            /* Start MTU2_8 */
  23. }
  24. /*
  25.  * タイマストップ
  26.  */
  27. void stopMTU(void)
  28. {    
  29.     MTUB.TSTR.BIT.CST2 = 0;            /* Stop MTU2_8 */
  30. }
  31. /*
  32.  * 1msec経過したかチェック(割込みフラグをポーリング)
  33.  */
  34. unsigned char checkIRFlag(void)
  35. {
  36.     if(IR(MTU8,TGIB8) == 1)
  37.     {
  38.         IR(MTU8,TGIB8) = 0;
  39.         return(1);
  40.     }
  41.     else
  42.     {
  43.         return(0);
  44.     }
  45. }
  46. /*
  47.  * msecオーダーでの時間待ち
  48.  */
  49. void delay_ms(unsigned int ms)
  50. {
  51.     startMTU();
  52.     while(ms > 0) {
  53.         if( checkIRFlag() == 1 ) {
  54.             ms--;
  55.         }
  56.     }
  57.     stopMTU();
  58. }

RS232C通信プログラム2

2015-03-27 08:58:53 | RX62N
RX62N用のRS232C通信プログラムです。割込みとバッファリングを使用しています。環境はkpitです。
/***********************************************************************/
/*                                                                     */
/*  FILE        :rs232ctest02.c                                        */
/*  DATE        :Thu, Dec 06, 2012                                     */
/*  DESCRIPTION :Main Program                                          */
/*  CPU TYPE    :RX62N                                                 */
/*                                                                     */
/*  This file is generated by KPIT GNU Project Generator.              */
/*                                                                     */
/***********************************************************************/
																						
#include <stdio.h>																				
#include "iodefine.h"
#include "interrupt_handlers.h"

#define PCLK 48			//PクロックMHz
#define TX_ACTIVE   1	//送信動作中
#define TX_INACTIVE 0	//送信停止中

#define TX_RING_BUFF_SIZE	32	//リングバッファのサイズ
#define RX_RING_BUFF_SIZE	32	//リングバッファのサイズ

//リングバッファ
unsigned char rx_buff[RX_RING_BUFF_SIZE];	//受信用
unsigned char tx_buff[TX_RING_BUFF_SIZE];	//送信用

//データポインタ
volatile int ptr_rx_top,ptr_rx_bottom;
volatile int ptr_tx_top,ptr_tx_bottom;
//送信フラグ データ送信中かどうか
volatile int tx_flag = TX_INACTIVE;


//受信エラー処理
void  INT_Excep_SCI0_ERI0(void)
{ 
	SCI0.SSR.BYTE &= ~0x38;	//エラーフラグクリア
}

//受信完了割込み
void  INT_Excep_SCI0_RXI0(void)
{ 
    
	/* Read data */
	rx_buff[ptr_rx_top] = SCI0.RDR;
	ptr_rx_top++;
	ptr_rx_top = ptr_rx_top % RX_RING_BUFF_SIZE;
}

//送信完了割込み
void  INT_Excep_SCI0_TXI0(void)
{

	/* Write the character out */
	SCI0.TDR = tx_buff[ptr_tx_bottom];
	ptr_tx_bottom++;
	ptr_tx_bottom = ptr_tx_bottom % TX_RING_BUFF_SIZE;
	//すべてのデータを送信したら割込み禁止
	if( ptr_tx_bottom == ptr_tx_top ) {
		IEN(SCI0, TXI0) = 0;
		tx_flag = TX_INACTIVE;
	}    
}

/* SCI初期化 引数はボーレート */
void InitSCI(int bps)
{    
	/* Enable SCI0 */
	MSTP(SCI0) = 0;
   
	/* RxD0 is input */
	PORT2.DDR.BIT.B1 = 0;
	/* Enable Input Buffer on RxD0 */
	PORT2.ICR.BIT.B1 = 1;
	/* TxD0 is output */
 	PORT2.DDR.BIT.B0 = 1;

	/* Disable Tx/Rx */
	SCI0.SCR.BYTE = 0;
    
	/*  Set mode register
		-Asynchronous Mode
		-8 bits
		-no parity
		-1 stop bit
		-PCLK clock (n = 0) */
	SCI0.SMR.BYTE = 0x00;
	//SCI0.SEMR.BIT.ABCS = 1;
	/* 送受信で割込み発生 */
	SCI0.SCR.BIT.RIE = 1;
	SCI0.SCR.BIT.TIE = 1;
    /* 割込み優先度 */
	IPR(SCI0,RXI0) = 0x04;
	IPR(SCI0,TXI0) = 0x04;
	/* Clear IR bits for TIE and RIE */
	IR(SCI0, RXI0) = 0;
	IR(SCI0, TXI0) = 0;
   
	/* 受信・送信割込み許可 */
	IEN(SCI0, RXI0) = 1;
	IEN(SCI0, TXI0) = 1;
   
	/*  Set baud rate to 115200
		N = (PCLK Frequency) / (64 * 2^(2*n - 1) * Bit Rate) - 1
		N = (48,000,000) / (64 * 2^(2*0 - 1) * 115200) - 1
		115200bps N = 12
		 38400bps N=38 
	*/
	//SCI0.BRR = 38;
	SCI0.BRR = PCLK *1000000 / 32 / bps - 1;

	/* Enable Tx/Rx */
	SCI0.SCR.BYTE |= 0x30;
	
	/*リングバッファ初期化*/
	ptr_rx_top = ptr_rx_bottom = 0;
	ptr_tx_top = ptr_tx_bottom = 0;
}

/* データの送信 */
void charput(unsigned char output_char)
{
	int tmp;
	tmp = ptr_tx_top + 1;
	tmp = tmp % TX_RING_BUFF_SIZE;
	while(tmp == ptr_tx_bottom) ;	//バッファに空きができるまで待つ
	
	tx_buff[ptr_tx_top] = output_char;
	ptr_tx_top++;
	ptr_tx_top = ptr_tx_top % TX_RING_BUFF_SIZE;
	if(tx_flag == TX_INACTIVE) {
		tx_flag = TX_ACTIVE;
		IEN(SCI0, TXI0) = 1;
		SCI0.SCR.BYTE |= 0xA0; //送信割込み発生
	}
}

/* データの受信 バッファに受信したデータがなければ受信するまで待つ */
unsigned char charget(void)
{
	unsigned char c;
	
	while(ptr_rx_bottom == ptr_rx_top); //データを受信するまで待つ
	c = rx_buff[ptr_rx_bottom];
	ptr_rx_bottom++;
	ptr_rx_bottom = ptr_rx_bottom % RX_RING_BUFF_SIZE;
	return c;
}

/* 文字列の出力 */
void printString(char *s)
{
	while( *s != 0 ) {
		if(( *s == '\r' ) && ( *(s+1) != '\n')) {
			charput('\r');charput('\n');
		} else if( (*s == '\n') && ( *(s-1) != '\r') ) {
			charput('\r');charput('\n');
		} else {
			charput(*s);
		}
		s++;
	}
}

/* printf関数で使用 */
int _write(int file,char *ptr,int len)
{
	int i;
	
	for(i=0;i<len;i++) {
		if( (ptr[i]=='r') || (ptr[i]=='n')) {
			charput('r');charput('n');
		} else {
			charput(ptr[i]);
		}
	}

    return len;
}

/* scanf関数で使用 */
int _read (int file, char *ptr, int len)
{
	*ptr = charget();
     return 1;
}


int main(void)
{
	char c;
    // TODO: add application code here

	SYSTEM.SCKCR.BIT.ICK = 0x00;		//システムクロック x16 96MHz
	SYSTEM.SCKCR.BIT.PCK = 0x01;		//周辺クロック   x4  48MHz
	SYSTEM.SCKCR.BIT.BCK = 0x01;		//外部バスクロック x4  48MHz
	
	InitSCI(38400);	//38400bpsで初期化
	
	printf("Startn");
    while (1) {
		c = charget();
		printf("%c",c);
    }
  return 0;
}


RS232C通信プログラム1

2015-03-27 08:53:50 | RX62N
RX62N用のRS232C通信プログラムです。割り込みを利用しません。
/***********************************************************************/
/*                                                                     */
/*  FILE        :RS232Ctest.c                                          */
/*  DATE        :Thu, Jul 12, 2012                                     */
/*  DESCRIPTION :Main Program                                          */
/*  CPU TYPE    :RX62N                                                 */
/*                                                                     */
/*  This file is generated by KPIT GNU Project Generator.              */
/*                                                                     */
/***********************************************************************/
                    
																							
																							
#include "iodefine.h"

/******************************************************************************
* Function Name: InitSCI
* Description  : Initializes SCI channel for asychronous operation
* Arguments    : none
* Return Value : none
******************************************************************************/
void InitSCI(void)
{    
	/* Enable SCI0 */
	MSTP(SCI0) = 0;
   
	/* RxD0 is input */
	PORT2.DDR.BIT.B1 = 0;
	/* Enable Input Buffer on RxD1 */
	PORT2.ICR.BIT.B1 = 1;
	/* TxD0 is output */
 	PORT2.DDR.BIT.B0 = 1;

	/* Disable Tx/Rx */
	SCI0.SCR.BYTE = 0;
    
	/*  Set mode register
		-Asynchronous Mode
		-8 bits
		-no parity
		-1 stop bit
		-PCLK clock (n = 0) */
	SCI0.SMR.BYTE = 0x00;
	//SCI0.SEMR.BIT.ABCS = 1;
	/* Enable RXI and TXI interrupts, even though we are not
		using the interrupts, we will be checking the IR bits
		as flags */
	//SCI0.SCR.BIT.RIE = 1;
	//SCI0.SCR.BIT.TIE = 1;
    
	/* Clear IR bits for TIE and RIE */
	//IR(SCI0, RXI0) = 0;
	//IR(SCI0, TXI0) = 0;
   
	/* Disable RXI and TXI interrupts in ICU because we are polling */
	//IEN(SCI0, RXI0) = 0;
	//IEN(SCI0, TXI0) = 0;
   
	/*  Set baud rate to 115200
		N = (PCLK Frequency) / (64 * 2^(2*n - 1) * Bit Rate) - 1
		N = (48,000,000) / (64 * 2^(2*0 - 1) * 115200) - 1
		N = 12
		38400bps N=38 */
	SCI0.BRR = 38;

	/* Enable Tx/Rx */
	SCI0.SCR.BYTE |= 0x30;
}

/******************************************************************************
* Function Name: charput
* Description  : Outputs a character on a serial port
* Arguments    : character to output
* Return Value : none
******************************************************************************/
void charput(unsigned char output_char)
{
	
	/* Wait for transmit buffer to be empty */
	//while(IR(SCI1, TXI1) == 0);
	while(SCI0.SSR.BIT.TDRE == 0);

	/* Clear TXI IR bit */
	//IR(SCI0, TXI0) = 0;

	/* Write the character out */
	SCI0.TDR = output_char;    
}

/******************************************************************************
* Function Name: charget
* Description  : Gets a character on a serial port
* Arguments    : character to output
* Return Value : none
******************************************************************************/
unsigned char charget(void)
{
	unsigned char temp;
    
	/* エラーチェック */
	if (SCI0.SSR.BYTE & 0x38) {
		SCI0.SSR.BYTE &= ~0x38;	//エラーフラグクリア
		temp = SCI0.RDR;
		return 0;
	}
	/* Read any 'junk' out of receive buffer */
	//temp = SCI0.RDR;
    
	/* Clear flag to receive next byte */
	//IR(SCI0, RXI0) = 0;
    
	/* Wait for next receive data */
	//while(IR(SCI1, RXI1) == 0);
	while(SCI0.SSR.BIT.RDRF == 0);
    
	/* Read data */
	temp = SCI0.RDR;
    
/*	// Echo data back out 
	if(temp == 0x0d)
	{
		// Enter was pressed, output newline 
		charput('\r');
		charput('\n');
	}
	else
	{
		// Echo back character 
		charput(temp);
	}
*/  
	// Receive data acquired, send back up 
	return temp;         
}

/* 文字列の出力 */
void printString(char *s)
{
	while( *s != 0 ) {
		charput(*s);
		s++;
	}
}

int main(void)
{
    // TODO: add application code here

	SYSTEM.SCKCR.BIT.ICK = 0x00;		//システムクロック x16 96MHz
	SYSTEM.SCKCR.BIT.PCK = 0x01;		//周辺クロック   x4  48MHz
	SYSTEM.SCKCR.BIT.BCK = 0x01;		//外部バスクロック x4  48MHz
	InitSCI();
	
	printString("Start\r\n");
    while (1) {
		charput(charget());
    }
  return 0;
}