忘備録-備忘録

技術的な備忘録

RX62NでFreeRTOSを動かす

2015-11-27 22:05:41 | RX62N
RX62N(インターフェス2011年5月号付録)でFreeRTOSを動かしました。環境はe2 studio, renesas RXCコンパイラです。
ここにプロジェクトをエクスポートしたものを置いておきます。
ファイル構成は次の通りです。
”FreeRTOS”以下のフォルダに必要なファイルをまとめました。
”FreeRTOS/renesas”以下にウィザードが自動生成するファイルをまとめておいてあります。
”port.c”にエラーが表示されているのはインラインアセンブラを使用しているためです。



フォルダを閉じるとユーザープログラムのみでシンプルになります。



プロジェクト作成時にはできるだけ自動生成するファイルを省き、それでも作成されるものは”FreeRTOS/renesas”のファイルと被るので削除します。



ここに”FreeRTOS”フォルダ以下のファイルをドラッグアンドドロップでコピーすればFreeRTOSのインストールは終了です。



4つのタスクが違う間隔で起動と待期を繰り返しながらLEDを点滅させるプログラムは次のようになります。

  1. #include <stdio.h>
  2. #include "FreeRTOS/renesas/iodefine.h"
  4. /* Kernel includes. */
  5. #include "FreeRTOS/FreeRTOS.h"
  6. #include "FreeRTOS/task.h"
  7. #include "FreeRTOS/queue.h"
  11. void vTask1(void *pvParameters)
  12. {
  13.     while(1) {
  14.         PORTD.DR.BIT.B1 = ~PORTD.DR.BIT.B1;
  15.         vTaskDelay(100/portTICK_PERIOD_MS);
  16.     }
  17. }
  19. void vTask2(void *pvParameters)
  20. {
  21.     while(1) {
  22.         PORTD.DR.BIT.B2 = ~PORTD.DR.BIT.B2;
  23.         vTaskDelay(200/portTICK_PERIOD_MS);
  24.     }
  25. }
  27. void vTask3(void *pvParameters)
  28. {
  29.     while(1) {
  30.         PORTD.DR.BIT.B3 = ~PORTD.DR.BIT.B3;
  31.         vTaskDelay(300/portTICK_PERIOD_MS);
  32.     }
  33. }
  35. void vTask4(void *pvParameters)
  36. {
  37.     while(1) {
  38.         PORTD.DR.BIT.B0 = ~PORTD.DR.BIT.B0;
  39.         vTaskDelay(400/portTICK_PERIOD_MS);
  40.     }
  41. }
  43. void main(void)
  44. {
  45.     /* Renesas provided CPU configuration routine. The clocks are configured in
  46.     here. */
  48.     /* Turn all LEDs off. */
  49.     PORTD.DDR.BYTE = 0xFF;    //ポートC出力
  50.     PORTD.DR.BYTE = 0xFF;    //初期値
  53.     xTaskCreate(vTask1,"Task1",100,NULL,1,NULL);
  54.     xTaskCreate(vTask2,"Task2",100,NULL,1,NULL);
  55.     xTaskCreate(vTask3,"Task3",100,NULL,1,NULL);
  56.     xTaskCreate(vTask4,"Task4",100,NULL,1,NULL);
  59.     /* Create the queue. */
  60.     vTaskStartScheduler();
  62.     /* If all is well the next line of code will not be reached as the scheduler
  63.     will be    running. If the next line is reached then it is likely that there was
  64.     insufficient heap available for the idle task to be created. */
  65.     for( ;; );
  66. }

RX62Nの12bitAD変換を使うその2

2015-11-26 15:00:48 | RX62N
RX62Nの12bitAD変換器を動かすプログラムのサンプルです。MTU0のTGRAのコンペアマッチを使い一定間隔で変換を行います。AD変換結果の読み出しに割り込みを使用しています。

  2. #include <stdio.h>
  3. #include <machine.h>
  4. #include "iodefine.h"
  5. #include "vect.h"
  7. #define PCLK    48    //PCLK = 48MHz
  9. /*
  10.  * MTU0の初期化
  11.  * TGRAのコンペアマッチでAD変換をスタートさせる
  12.  *
  13.  * 12bit A/Dコンバータ初期化
  14.  * AN0のみ使用
  15.  */
  16. void initMTU0_S12AD(void)
  17. {
  18.     MSTP(MTU0) = 0;                    //タイマMTU0回路動作
  19.     MTU0.TCR.BIT.CCLR = 1;            //TGRAコンペアマッチでカウンタクリア
  20.     MTU0.TCR.BIT.CKEG = 0;            //クロックエッジ選択ビット (使用しない)
  21.     MTU0.TCR.BIT.TPSC = 3;            //PCLK/64でカウント
  22.     MTU0.TMDR.BIT.MD = 0;            //通常動作
  23.     MTU0.TIER.BIT.TTGE = 1;            //A/D変換開始要求の発生を許可
  24.     MTU0.TCNT = 0;
  25.     MTU0.TGRA = PCLK*1000000L/64L/1000L - 1L;    // PCLK = 48MHzで1秒間に1000回AD変換を行う
  27.     MSTP(S12AD) = 0;                // 12bit　AD変換回路動作
  28.     delay_ms(100);                    // AD変換回路が安定するのを待つ
  29.     PORT4.DDR.BIT.B0 = 0;            // AN0を使用するためデジタル入力に
  30.     S12AD.ADCSR.BIT.CKS = 3;        // クロック　PCLK/1
  31.     S12AD.ADCSR.BIT.EXTRG = 0;        // A/D開始トリガ選択レジスタ（ADSTRGR）で選択されたタイマ要因による、スキャン変換の開始を選択
  32.     S12AD.ADCSR.BIT.TRGE = 1;        // 外部トリガ（ADTRG0#）または、MTU、TMRトリガによるスキャン変換を許可
  33.     S12AD.ADCSR.BIT.ADIE = 1;        // スキャン終了後のS12ADI0割り込み発生の許可
  34.     IR(S12AD,ADI) = 0;                // 割り込みフラグクリア
  35.     IEN(S12AD,ADI) = 1;                // 割込み許可
  36.     IPR(S12AD,ADI) = 0x01;            // 割り込み優先順位設定
  37.     S12AD.ADANS.BIT.ANS = 0x01;        // AN0のみ変換
  38.     S12AD.ADCER.BIT.ADRFMT = 0;        // 保存データは右詰め
  39.     S12AD.ADSTRGR.BIT.ADSTRS = 1;    // TRG0AN_0トリガで変換開始
  41.     MTUA.TSTR.BIT.CST0 = 1;            // タイマMTU0スタート
  42. }
  44. /*
  45.  * S12AD ADI
  46.  * AD変換終了で呼び出される割り込み関数
  47.  * AD変換の結果を表示
  48.  */
  49. //
  50. void Excep_S12AD_ADI(void)
  51. {
  52.     int ans;
  54.     ans = S12AD.ADDR0;
  55.     printf("AD value %d\n",ans);
  56. }
  59. int main(void)
  60. {
  61.     volatile int i;
  63.     Initialization();
  64.     initMTU0_S12AD();                        //AD変換初期化
  66.     printf("A/D converter test.\n");
  67.     while (1) {
  68.         //何もしない　割込みで動作
  69.     }
  71. }

RX62Nの12bitAD変換を使うその1

2015-11-26 14:51:43 | RX62N
RX62Nの12bitAD変換器を動かすプログラムのサンプルです。

  1. #include <stdio.h>
  2. #include <machine.h>
  3. #include "iodefine.h"
  5. /*
  6.  * 12bit A/Dコンバータ初期化
  7.  * AN0のみ使用
  8.  */
  9. void s12ad_init(void) {
  10.     MSTP(S12AD) = 0;
  11.     delay_ms(100);                // AD変換回路が安定するのを待つ
  12.     PORT4.DDR.BIT.B0 = 0;        // AN0を使用するためデジタル入力に
  13.     S12AD.ADCSR.BIT.CKS = 0x03;    // クロック　PCLK/1
  14.     S12AD.ADANS.BIT.ANS = 0x01;    // AN0のみ変換
  15.     S12AD.ADCER.BIT.ADRFMT = 0;    // 保存データは右詰め
  16. }
  18. /*
  19.  * AD変換を実行
  20.  */
  21. unsigned short get_s12ad(void) {
  23.   int i;
  24.   unsigned short adv;
  26.   S12AD.ADCSR.BIT.ADST = 1;         // AD変換開始
  27.   while(S12AD.ADCSR.BIT.ADST==1);    // AD変換が終了するのを待つ
  28.   adv = S12AD.ADDR0;                // 結果の読み出し
  30.   return adv;
  31. }
  33. int main(void)
  34. {
  35.     int adv;
  37.     Initialization();
  39.     s12ad_init();                        //AD変換初期化
  41.     printf("A/D converter test.\n");
  42.     while (1) {
  43.         adv = get_s12ad();
  44.         printf("AD value %d\n",adv);
  45.         delay_ms(100);
  46.     }
  48. }

RX62Nのタイマを使うその3

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

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

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