Articles

RX64Mでスマートコンフィグレータを使用したアプリの作成

１．新しいプロジェクトを作成する
２．プロジェクトの作成
・マイクロコントローラ：RX
・使用するコントローラ：R5F564M (使用するマイコンに合わせる)
・プロジェクトの種類：空のアプリケーション(CC-RX)
・プロジェクト名：任意
・作成場所：任意
・プロジェクト名のフォルダを作成する：チェック推奨
以上を設定して「作成」ボタンをクリック

３．スマートコンフィグレータを起動
プロジェクトツリーから、スマートコンフィグレータ（設計ツール）をダブルクリック
初期状態では、コンポーネントにr_bspのみ登録されている。
・ボードの設定はそのまま
・クロックの設定を実際のボードの構成に合わせる

３．コードの生成
コードの生成ボタンをクリックする。
セクション設定画面が表示されるので、「はい」を選択して変更を行う。
プロジェクトツリーのファイルを見ると、Smart Configuratorにソースが追加されている。

４．ビルド
この状態でビルドすると、main関数が無いと言って、エラーが出る。
これは、初めに空のアプリケーションを作った為。
（普通のアプリケーションを作ると、余分なファイルが出来て、スマートコンフィグレータを使用すると消される）
なので、メインのソースファイルを追加する。
・まずは、新しいカテゴリ（フォルダ）「src」を追加する。
・「src」を選択して、新しいファイルを追加する。
（ファイル名は任意、作成場所に、「src\」を追加）
・void main(void){} を追加すれば、ソースファイルの完成。
これで、ビルドが正常に完了する。

５．最低限のソース

//メインプログラム
#include "Pin.h"

void main(void){
    R_Pins_Create();

}

//メインプログラム

#include "Pin.h"

void main(void){

R_Pins_Create();

}

なぜか、「R_Pins_Create」は初期化時に実行されないらしい。

今回のバージョンでは、これだけですんなりと動くようになっており、かなり進歩した感じ。

RX64MにSDRAMを追加する

今回使用するSDRAMはISSIのIS42S16160。256Mbitです。
接続については、データシート通り。

１．スマートコンフィグレータでバスを追加
名前はそのままで、終了をクリック。
２．バスの一般設定
　外部バス領域のSDCSをチェックする。
３．SDCS設定
アドレスマルチプレクスと、バスタイミングを設定する。
４．ソースに初期化処理を追加する
R_Config_BSC_InitializeSDRAM();
を追加することで、SDRAMが使用出来るようになります。

RX64MのEthernet1のみ使用する

RX64MにはEthernetコントローラが2ch搭載されています。ルネサスのTCP/IPライブラリであるT4を使う場合、1chまたは、2chを選択することが可能です。しかし、1chで使用する場合はEthernet0が使用されるため何とかしたいと思います。

使用したバージョン
M3S-T4-Tiny(Ethernet) version 2.09 for RXV1 LITTLE endian.(Jun 18 2019, 18:43:35)

１．コンポーネントから「r_t4_rx」を追加する。
r_ether_rx
r_cmd_rx
r_sys_timer_rx
r_t4_driver
が追加される。

２．r_ether_rxの設定を行う
今回は、ETHERC1を使用する為、下記の通り設定。
３．r_t4_rxの設定を行う
今回は、1chのみ使用する為、下記の通り設定。
４．コード生成を行う。

５．ソースの改造
T4ライブラリでは、1CHで使用する場合は、ETHERC0を使用するのが前提らしい。
なので、まともに動かない。
（ちなみに、1chしか使用しない場合でも、T4を2ch設定にしてしまえば、そのままでも使える。ただし、メモリが多くいる）
改造するためには、スマートコンフィグレータで作成したファイルを編集する必要があるが、
コード生成を行うたびに戻ってしまう恐れがある為、コピーを追加する。
・既存のソースをビルドから除外する。
・コピーしたソースをプロジェクトに追加し、編集する。
単純に、アクセスするチャンネルを0と1をすべて入れ替えました。
修正したファイルはこちらです。（動作未保障）

６．動作確認
以下のコードにて、PCからPINGが通ることを確認。

#define T4_WORK_SIZE (11276)
static UW tcpudp_work[T4_WORK_SIZE / 4 + 1];    //ワークメモリ
static UB T4_RESET_REQUEST = 0;                 //コールバックのリセット要求

//T4コールバック
ER system_callback ( UB channel, UW eventid, VP param ){

    switch(eventid){
    case ETHER_EV_LINK_OFF:     //  0 ETHER 層のリンクが切断しました。
        break;
    case ETHER_EV_LINK_ON:      //  1 ETHER 層のリンクが接続しました。
        break;
    case ETHER_EV_COLLISION_IP: //  2 IP アドレスの衝突を検出しました。
        break;
    case DHCP_EV_LEASE_IP:      // 20 DHCP にてIP アドレスの取得を完了しました。
        break;
    case DHCP_EV_LEASE_OVER:    // 21 DHCP にてIP アドレスのリース時間が切れました。
        break;
    case DHCP_EV_INIT:          // 22 DHCP の初期化動作を開始しました。
        break;
    case DHCP_EV_INIT_REBOOT:   // 23 DHCP の再接続を開始しました。
        break;
    case DHCP_EV_APIPA:         // 24 APIPA アドレスを設定しました。
        break;
    case DHCP_EV_NAK:           // 25 DHCP サーバからNAK を受信しました。
        break;
    case DHCP_EV_FATAL_ERROR:   // 26 DHCP に致命的なエラーが発生しました。
        break;
    case DHCP_EV_PLEASE_RESET:  // 27 tcpudp_reset()をしてT4 をリセットしてください。
        T4_RESET_REQUEST = channel + 1;
        //tcpudp_reset(channel);    //コールバック内では禁止
        break;
    }   
    printf("ch=%d,Event=%d\n",channel,eventid);
    return 0;
}

//Ethernetを開く
void eth_open(void){
    ER  ercd;
    W   size;
    sys_time_err_t systime_ercd;
    
    //Version
    printf("%s\n",(char*)R_t4_version.library);

    //システムタイマ 初期化
    systime_ercd = R_SYS_TIME_Open();
    if(systime_ercd != SYS_TIME_SUCCESS){ printf("SystemTimer Open Error\n"); while(1); }
    //LAN controller 初期化
    ercd = lan_open();
    if(ercd != E_OK){ printf("LAN Open Error\n"); while(1); }
    //ワークメモリ 確保
    size = tcpudp_get_ramsize();
    printf("T4 WorkSize=%d\n",size);
    if(size > (sizeof(tcpudp_work))){ printf("WrokSize Error\n"); while(1); }
    //T4 ライブラリ 初期化
    ercd = tcpudp_open(tcpudp_work);
    if(ercd != E_OK){ printf("T4 Open Error\n"); while(1); }
}

//Ethernetを閉じる
void eth_close(void){
    tcpudp_close();
    lan_close();
    R_SYS_TIME_Close(); 
}

//Ethernetの監視
void eth_task(void){
    if(T4_RESET_REQUEST){
        tcpudp_reset(T4_RESET_REQUEST-1);
        T4_RESET_REQUEST = 0;   
    }   
}


void main(void){
    R_Pins_Create();

    eth_open();
    
    while(1){
        eth_task();
    }   
}

#define T4_WORK_SIZE (11276)

static UW tcpudp_work[T4_WORK_SIZE / 4 + 1]; //ワークメモリ

static UB T4_RESET_REQUEST = 0; //コールバックのリセット要求

//T4コールバック

ER system_callback ( UB channel, UW eventid, VP param ){

switch(eventid){

case ETHER_EV_LINK_OFF: // 0 ETHER 層のリンクが切断しました。

break;

case ETHER_EV_LINK_ON: // 1 ETHER 層のリンクが接続しました。

break;

case ETHER_EV_COLLISION_IP: // 2 IP アドレスの衝突を検出しました。

break;

case DHCP_EV_LEASE_IP: // 20 DHCP にてIP アドレスの取得を完了しました。

break;

case DHCP_EV_LEASE_OVER: // 21 DHCP にてIP アドレスのリース時間が切れました。

break;

case DHCP_EV_INIT: // 22 DHCP の初期化動作を開始しました。

break;

case DHCP_EV_INIT_REBOOT: // 23 DHCP の再接続を開始しました。

break;

case DHCP_EV_APIPA: // 24 APIPA アドレスを設定しました。

break;

case DHCP_EV_NAK: // 25 DHCP サーバからNAK を受信しました。

break;

case DHCP_EV_FATAL_ERROR: // 26 DHCP に致命的なエラーが発生しました。

break;

case DHCP_EV_PLEASE_RESET: // 27 tcpudp_reset()をしてT4 をリセットしてください。

T4_RESET_REQUEST = channel + 1;

//tcpudp_reset(channel); //コールバック内では禁止

break;

}

printf("ch=%d,Event=%d\n",channel,eventid);

return 0;

}

//Ethernetを開く

void eth_open(void){

ER ercd;

W size;

sys_time_err_t systime_ercd;

//Version

printf("%s\n",(char*)R_t4_version.library);

//システムタイマ初期化

systime_ercd = R_SYS_TIME_Open();

if(systime_ercd != SYS_TIME_SUCCESS){ printf("SystemTimer Open Error\n"); while(1); }

//LAN controller 初期化

ercd = lan_open();

if(ercd != E_OK){ printf("LAN Open Error\n"); while(1); }

//ワークメモリ確保

size = tcpudp_get_ramsize();

printf("T4 WorkSize=%d\n",size);

if(size > (sizeof(tcpudp_work))){ printf("WrokSize Error\n"); while(1); }

//T4 ライブラリ初期化

ercd = tcpudp_open(tcpudp_work);

if(ercd != E_OK){ printf("T4 Open Error\n"); while(1); }

}

//Ethernetを閉じる

void eth_close(void){

tcpudp_close();

lan_close();

R_SYS_TIME_Close();

}

//Ethernetの監視

void eth_task(void){

if(T4_RESET_REQUEST){

tcpudp_reset(T4_RESET_REQUEST-1);

T4_RESET_REQUEST = 0;

}

void main(void){

R_Pins_Create();

eth_open();

while(1){

eth_task();

}

以前と比べ、T4はかなり進歩してますね。DHCPも標準で対応してる。

RX64MでSD(TF)カードにアクセスする

RX64MにはSDホストインタフェースが搭載されています。
以前は、ライセンスの関係で一般には使用出来なかった様ですが、最近FITモジュールが公開されていますので、さっそく使用してみたいと思います。

使用したバージョンは以下の通りで、それぞれのFITモジュールを設定していきます。
r_sdc_sdmem_rx 3.00
r_sdhi_rx 2.06
WP端子を使用しない場合はチェックを外します。
アクティブの変更は出来ないようなので、使用する場合は注意します。

r_tfat_driver_rx 1.08
r_tfat_rx 4.00
[設定項目なし]

ソフトウエアについては、システムタイマを使っているので、以下のファイルをインクルードします。

//システムタイマ
#include "r_sys_time_rx_if.h"
//SDC
#include "r_sdhi_rx_if.h"
#include "r_sdhi_rx_pinset.h"
#include "r_sdc_sd_rx_if.h"
#include "r_sdc_sd_rx_config.h"
//FAT
#include "r_tfat_driver_rx_if.h"
#include "r_tfat_driver_rx_config.h"

//システムタイマ

#include "r_sys_time_rx_if.h"

//SDC

#include "r_sdhi_rx_if.h"

#include "r_sdhi_rx_pinset.h"

#include "r_sdc_sd_rx_if.h"

#include "r_sdc_sd_rx_config.h"

//FAT

#include "r_tfat_driver_rx_if.h"

#include "r_tfat_driver_rx_config.h"

SDカード制御用のソースは、下記の様に作成しました。

#define SD_CARD_DEBUG_PRINT     1                   //デバッグ用 Printfの有効化
#define SD_CARD_DEV_NO          0                   //SDカード デバイス番号
#define SD_CARD_DRV_LETTER      "0:"                //SDカード ドライブ番号(FatFs)
#define SD_POWER_PORT            PORT1.PODR.BIT.B0  //SDカード電源制御ポート

FATFS               SD_CARD_FATFS;                  //SDカード ファイルシステム
uint32_t            SD_CARD_WORK_MEM[50];           //SDカード ワークエリア(200Byte必要)
unsigned short      SD_CARD_POWER_WAIT;             //SDカード 電源投入タイマ
unsigned short      SD_CARD_ERR_STATUS = 0;         //SDカード エラーステータス
unsigned short      SD_CARD_READY = 0;              //SDカード 準備テータス

//SDカード 電源初期化
sdc_sd_status_t sd_card_power_init(uint32_t card_no){
    if (SDC_SD_CARD_NO0 == card_no){    //User must create processing for device number 1 or later.
       SD_POWER_PORT = 0;               //SD-POW
    }
    return SDC_SD_SUCCESS;
}

//SDカード 電源 ON
sdc_sd_status_t sd_card_power_on(uint32_t card_no){
    if (SDC_SD_CARD_NO0 == card_no){    //User must create processing for device number 1 or later.
        SD_POWER_PORT = 1;              //SD-POW
    }
    //R_BSP_SoftwareDelay(10, BSP_DELAY_MILLISECS);    //Supplies the Power to the SD Card and waits.
    SD_CARD_POWER_WAIT = 10;
    return SDC_SD_SUCCESS;
}

//SDカード 電源 OFF
sdc_sd_status_t sd_card_power_off(uint32_t card_no){
    if (SDC_SD_CARD_NO0 == card_no){    //User must create processing for device number 1 or later.
        SD_POWER_PORT = 0;              //SD-POW
    }
    //R_BSP_SoftwareDelay(1, BSP_DELAY_MILLISECS);    //Supplies the Power to the SD Card and waits.
    return SDC_SD_SUCCESS;
}

//カード検出(CD)コールバック
sdc_sd_status_t sd_card_cd_callback (int32_t cd){
    uint32_t card_no;
    R_SDC_SD_CdInt(SD_CARD_DEV_NO, SDC_SD_CD_INT_DISABLE, 0);
    return SDC_SD_SUCCESS;
}

//カード状態変化コールバック
sdc_sd_status_t sd_card_status_callback (int32_t channel){
    return SDC_SD_SUCCESS;
}


//エラー検出
void sd_card_error_trap (uint32_t sdc_sd_card_no){
    sdc_sd_status_t err_code;
    err_code = R_SDC_SD_GetErrCode(sdc_sd_card_no);
    #ifdef SD_CARD_DEBUG_PRINT
    printf("ERROR: error code (sdc_sd_status_t) is %d.\n", err_code);
    #endif
    SD_CARD_ERR_STATUS |= 0x0020;
}

//タイマ処理
void sd_card_1ms_interval(void){
    if(SD_CARD_POWER_WAIT) SD_CARD_POWER_WAIT--;
    r_sdc_sd_1msInterval();
}

//SDカードの初期化
void sd_card_init(void){
    sdc_sd_status_t sdc_sd_status;
    uint32_t        cmt_channel;
    bool            cmt_ret;
    
    //1mS周期割り込みの登録
    //cmt_ret = R_CMT_CreatePeriodic(1000,(void(*)(void*))R_SDC_SD_1msInterval, &cmt_channel);
    cmt_ret = R_CMT_CreatePeriodic(1000,(void(*)(void*))sd_card_1ms_interval, &cmt_channel);
    if(cmt_ret != true){
        SD_CARD_ERR_STATUS |= 0x0001;
    }
    
    //SDHI インタフェースの初期化
    R_SDHI_PinSetInit();                    //SDHI 端子の初期設定
    sd_card_power_init(SD_CARD_DEV_NO);     //カード電源初期化
    
    //SD メモリカードドライバの初期化
    sdc_sd_status = R_SDC_SD_Open(SD_CARD_DEV_NO, SD_CARD_DEV_NO, &SD_CARD_WORK_MEM);
    if(sdc_sd_status != SDC_SD_SUCCESS){
        #ifdef SD_CARD_DEBUG_PRINT
        printf("ERROR: R_SDC_SD_Open. Error code (sdc_sd_status_t) is %d.\n", sdc_sd_status);
        #endif
        SD_CARD_ERR_STATUS |= 0x0010;
    }
    sdc_sd_status = R_SDC_SD_CdInt(SD_CARD_DEV_NO, SDC_SD_CD_INT_ENABLE, sd_card_cd_callback);
    if (SDC_SD_SUCCESS != sdc_sd_status){
        sd_card_error_trap(SD_CARD_DEV_NO);
    }
    //sdc_sd_status = R_SDC_SD_IntCallback(SD_CARD_DEV_NO, sd_card_status_callback);
    sdc_sd_status = R_SDC_SD_IntCallback(SD_CARD_DEV_NO, NULL);
    if (SDC_SD_SUCCESS != sdc_sd_status){
        sd_card_error_trap(SD_CARD_DEV_NO);
    }
    
}

//SDカード検出処理
void sd_card_task(void){
    static short                init_status = 0;                            //初期化状態フラグ
    static sdc_sd_status_t      pre_detection_status = SDC_SD_SUCCESS;      //カード検出前回値

    sdc_sd_status_t     detection_status;
    sdc_sd_status_t     sdc_sd_status;
    sdc_sd_cfg_t        sdc_sd_config;
    FRESULT             f_res;
    
    //カード検出状態の確認
    detection_status = R_SDC_SD_GetCardDetection(SD_CARD_DEV_NO);
    if(pre_detection_status != detection_status){
        pre_detection_status = detection_status;
        if(detection_status == SDC_SD_SUCCESS){
            //カード検出時
            #ifdef SD_CARD_DEBUG_PRINT
            printf("Detected attached SD card.\n");
            #endif
            sd_card_power_on(SD_CARD_DEV_NO);                               //カード電源投入
            init_status = 1;
        }else{
            //カード未検出時
            #ifdef SD_CARD_DEBUG_PRINT
            printf("Detected detached SD card.\n");
            #endif
            sdc_sd_status = R_SDC_SD_End(SD_CARD_DEV_NO, SDC_SD_MODE_MEM);
            if (SDC_SD_SUCCESS != sdc_sd_status){
                sd_card_error_trap(SD_CARD_DEV_NO);
            }
            init_status = 0;
            sd_card_power_off(SD_CARD_DEV_NO);
            SD_CARD_READY = 0;
        }
    }
    
    //カード初期化処理
    if(init_status == 1){
        if(SD_CARD_POWER_WAIT == 0){    //電源投入後安定化待ち
            R_SDHI_PinSetTransfer();    //ホストを転送可能状態にする
            init_status++;
        }
    }else if(init_status){
        sdc_sd_config.mode = SDC_SD_CFG_DRIVER_MODE;                    
        sdc_sd_config.voltage = SDC_SD_VOLT_3_3;
        sdc_sd_status = R_SDC_SD_Initialize(SD_CARD_DEV_NO, &sdc_sd_config, SDC_SD_MODE_MEM);
        if (SDC_SD_SUCCESS == sdc_sd_status){
            init_status = 0;
            f_res = f_mount(&SD_CARD_FATFS, SD_CARD_DRV_LETTER, 0);
            if(f_res == FR_OK){
                SD_CARD_READY = 1;
            }else{
                SD_CARD_ERR_STATUS |= 0x0400;
            }
        }else{
            sdc_sd_status = R_SDC_SD_End(SD_CARD_DEV_NO, SDC_SD_MODE_MEM);
            if (SDC_SD_SUCCESS != sdc_sd_status){
                sd_card_error_trap(SD_CARD_DEV_NO);
            }
            if(init_status++ > 10000){
                init_status = 0;
                SD_CARD_ERR_STATUS |= 0x0100;
                SD_CARD_READY = 0;
            }
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

#define SD_CARD_DEBUG_PRINT 1 //デバッグ用 Printfの有効化

#define SD_CARD_DEV_NO 0 //SDカードデバイス番号

#define SD_CARD_DRV_LETTER "0:" //SDカードドライブ番号(FatFs)

#define SD_POWER_PORT PORT1.PODR.BIT.B0 //SDカード電源制御ポート

FATFS SD_CARD_FATFS; //SDカードファイルシステム

uint32_t SD_CARD_WORK_MEM[50]; //SDカードワークエリア(200Byte必要)

unsigned short SD_CARD_POWER_WAIT; //SDカード電源投入タイマ

unsigned short SD_CARD_ERR_STATUS = 0; //SDカードエラーステータス

unsigned short SD_CARD_READY = 0; //SDカード準備テータス

//SDカード電源初期化

sdc_sd_status_t sd_card_power_init(uint32_t card_no){

if (SDC_SD_CARD_NO0 == card_no){ //User must create processing for device number 1 or later.

SD_POWER_PORT = 0; //SD-POW

}

return SDC_SD_SUCCESS;

}

//SDカード電源 ON

sdc_sd_status_t sd_card_power_on(uint32_t card_no){

if (SDC_SD_CARD_NO0 == card_no){ //User must create processing for device number 1 or later.

SD_POWER_PORT = 1; //SD-POW

}

//R_BSP_SoftwareDelay(10, BSP_DELAY_MILLISECS); //Supplies the Power to the SD Card and waits.

SD_CARD_POWER_WAIT = 10;

return SDC_SD_SUCCESS;

}

//SDカード電源 OFF

sdc_sd_status_t sd_card_power_off(uint32_t card_no){

if (SDC_SD_CARD_NO0 == card_no){ //User must create processing for device number 1 or later.

SD_POWER_PORT = 0; //SD-POW

}

//R_BSP_SoftwareDelay(1, BSP_DELAY_MILLISECS); //Supplies the Power to the SD Card and waits.

return SDC_SD_SUCCESS;

}

//カード検出(CD)コールバック

sdc_sd_status_t sd_card_cd_callback (int32_t cd){

uint32_t card_no;

R_SDC_SD_CdInt(SD_CARD_DEV_NO, SDC_SD_CD_INT_DISABLE, 0);

return SDC_SD_SUCCESS;

}

//カード状態変化コールバック

sdc_sd_status_t sd_card_status_callback (int32_t channel){

return SDC_SD_SUCCESS;

}

//エラー検出

void sd_card_error_trap (uint32_t sdc_sd_card_no){

sdc_sd_status_t err_code;

err_code = R_SDC_SD_GetErrCode(sdc_sd_card_no);

#ifdef SD_CARD_DEBUG_PRINT

printf("ERROR: error code (sdc_sd_status_t) is %d.\n", err_code);

#endif

SD_CARD_ERR_STATUS |= 0x0020;

}

//タイマ処理

void sd_card_1ms_interval(void){

if(SD_CARD_POWER_WAIT) SD_CARD_POWER_WAIT--;

r_sdc_sd_1msInterval();

}

//SDカードの初期化

void sd_card_init(void){

sdc_sd_status_t sdc_sd_status;

uint32_t cmt_channel;

bool cmt_ret;

//1mS周期割り込みの登録

//cmt_ret = R_CMT_CreatePeriodic(1000,(void(*)(void*))R_SDC_SD_1msInterval, &cmt_channel);

cmt_ret = R_CMT_CreatePeriodic(1000,(void(*)(void*))sd_card_1ms_interval, &cmt_channel);

if(cmt_ret != true){

SD_CARD_ERR_STATUS |= 0x0001;

}

//SDHI インタフェースの初期化

R_SDHI_PinSetInit(); //SDHI 端子の初期設定

sd_card_power_init(SD_CARD_DEV_NO); //カード電源初期化

//SD メモリカードドライバの初期化

sdc_sd_status = R_SDC_SD_Open(SD_CARD_DEV_NO, SD_CARD_DEV_NO, &SD_CARD_WORK_MEM);

if(sdc_sd_status != SDC_SD_SUCCESS){

#ifdef SD_CARD_DEBUG_PRINT

printf("ERROR: R_SDC_SD_Open. Error code (sdc_sd_status_t) is %d.\n", sdc_sd_status);

#endif

SD_CARD_ERR_STATUS |= 0x0010;

}

sdc_sd_status = R_SDC_SD_CdInt(SD_CARD_DEV_NO, SDC_SD_CD_INT_ENABLE, sd_card_cd_callback);

if (SDC_SD_SUCCESS != sdc_sd_status){

sd_card_error_trap(SD_CARD_DEV_NO);

}

//sdc_sd_status = R_SDC_SD_IntCallback(SD_CARD_DEV_NO, sd_card_status_callback);

sdc_sd_status = R_SDC_SD_IntCallback(SD_CARD_DEV_NO, NULL);

if (SDC_SD_SUCCESS != sdc_sd_status){

sd_card_error_trap(SD_CARD_DEV_NO);

}

//SDカード検出処理

void sd_card_task(void){

static short init_status = 0; //初期化状態フラグ

static sdc_sd_status_t pre_detection_status = SDC_SD_SUCCESS; //カード検出前回値

sdc_sd_status_t detection_status;

sdc_sd_status_t sdc_sd_status;

sdc_sd_cfg_t sdc_sd_config;

FRESULT f_res;

//カード検出状態の確認

detection_status = R_SDC_SD_GetCardDetection(SD_CARD_DEV_NO);

if(pre_detection_status != detection_status){

pre_detection_status = detection_status;

if(detection_status == SDC_SD_SUCCESS){

//カード検出時

#ifdef SD_CARD_DEBUG_PRINT

printf("Detected attached SD card.\n");

#endif

sd_card_power_on(SD_CARD_DEV_NO); //カード電源投入

init_status = 1;

}else{

//カード未検出時

#ifdef SD_CARD_DEBUG_PRINT

printf("Detected detached SD card.\n");

#endif

sdc_sd_status = R_SDC_SD_End(SD_CARD_DEV_NO, SDC_SD_MODE_MEM);

if (SDC_SD_SUCCESS != sdc_sd_status){

sd_card_error_trap(SD_CARD_DEV_NO);

}

init_status = 0;

sd_card_power_off(SD_CARD_DEV_NO);

SD_CARD_READY = 0;

}

//カード初期化処理

if(init_status == 1){

if(SD_CARD_POWER_WAIT == 0){ //電源投入後安定化待ち

R_SDHI_PinSetTransfer(); //ホストを転送可能状態にする

init_status++;

}

}else if(init_status){

sdc_sd_config.mode = SDC_SD_CFG_DRIVER_MODE;

sdc_sd_config.voltage = SDC_SD_VOLT_3_3;

sdc_sd_status = R_SDC_SD_Initialize(SD_CARD_DEV_NO, &sdc_sd_config, SDC_SD_MODE_MEM);

if (SDC_SD_SUCCESS == sdc_sd_status){

init_status = 0;

f_res = f_mount(&SD_CARD_FATFS, SD_CARD_DRV_LETTER, 0);

if(f_res == FR_OK){

SD_CARD_READY = 1;

}else{

SD_CARD_ERR_STATUS |= 0x0400;

}

}else{

sdc_sd_status = R_SDC_SD_End(SD_CARD_DEV_NO, SDC_SD_MODE_MEM);

if (SDC_SD_SUCCESS != sdc_sd_status){

sd_card_error_trap(SD_CARD_DEV_NO);

}

if(init_status++ > 10000){

init_status = 0;

SD_CARD_ERR_STATUS |= 0x0100;

SD_CARD_READY = 0;

}

初期化処理として、sd_card_init();を一度実行します。
その後はメインループにて、sd_card_task();を常時実行します。
カードの挿入を検出すると、SD_CARD_READY が1となり、アクセスが可能です。

ファイル操作自体は、ChaNさんのFatfsを使用しているので、そちらを参照します。
アプリケーションノートのサンプルをそのまま使用する場合は、こんな感じになります。

void tfat_sample(void){
    FIL g_file;
    FRESULT rst;
    UINT file_rw_cnt;
    uint32_t byte_count;
    uint16_t data_count;
    uint8_t buff[512]; /* Working buffer */
    
    printf("Start TFAT sample.\n");

    // Create the directory 
    rst = f_mkdir("0:FLD1");
    if (FR_OK != rst){
        R_error(2, &rst);
    }

    // Create the file to be written
    rst = f_open( &g_file, path_txt, FA_CREATE_ALWAYS | FA_WRITE);
    if (FR_OK != rst){
        R_error(3, &rst);
    }
    // Complete file open

    // Copy the contents to the newly created file
    rst = f_write( &g_file, (void *) filebuffer, sizeof(filebuffer), &file_rw_cnt);
    if (rst != FR_OK || file_rw_cnt < sizeof(filebuffer)){
        R_error(4, &rst);
    }
    // file write complete

    // Close the file
    rst = f_close( &g_file);
    if (FR_OK != rst){
        R_error(5, &rst);
    }

    /* Open the file to be read */
    rst = f_open( &g_file, path_txt, FA_OPEN_ALWAYS | FA_READ);
    if (FR_OK != rst){
        R_error(6, &rst);
    }

    /* Ensure that the file pointer points at beginning of the file */
    rst = f_lseek( &g_file, 0);
    if (FR_OK != rst){
        R_error(7, &rst);
    }

    /* Clear the counter before counting the no. of bytes read */
    byte_count = 0;

    /* Repeat the read process until required no. of bytes are read */
    while (byte_count < (sizeof(filebuffer) - 1)){
        /* Read the file. 512 bytes at a time. */
        rst = f_read( &g_file, (void *) buff, sizeof(buff), &file_rw_cnt);

        /* Check if the read operation was successful & the no. of bytes read
        by the function matches with the size of the R/W buffer */
        if (rst != FR_OK || file_rw_cnt < sizeof(buff)){
            R_error(8, &rst);
        }else{
            /* Compare the contents of the file with the ROM data */
            for (data_count = 0; data_count < sizeof(buff); data_count++){
            if (buff[data_count] != filebuffer[byte_count + data_count]){
                /* error indication */
                /* explicit error data, address */
                R_error(9, &rst);
            }
        }
        /* verify complete */
        /* ================== */
        }
        /* Update the counter with the total no. of bytes read from the file */
        byte_count += file_rw_cnt;
    }

    /* Close the file    */
    rst = f_close( &g_file);
    if (FR_OK != rst){
        R_error(10, &rst);
    }

    printf("Finished TFAT sample.\n");
}

void tfat_sample(void){

FIL g_file;

FRESULT rst;

UINT file_rw_cnt;

uint32_t byte_count;

uint16_t data_count;

uint8_t buff[512]; /* Working buffer */

printf("Start TFAT sample.\n");

// Create the directory

rst = f_mkdir("0:FLD1");

if (FR_OK != rst){

R_error(2, &rst);

}

// Create the file to be written

rst = f_open( &g_file, path_txt, FA_CREATE_ALWAYS | FA_WRITE);

if (FR_OK != rst){

R_error(3, &rst);

}

// Complete file open

// Copy the contents to the newly created file

rst = f_write( &g_file, (void *) filebuffer, sizeof(filebuffer), &file_rw_cnt);

if (rst != FR_OK || file_rw_cnt < sizeof(filebuffer)){

R_error(4, &rst);

}

// file write complete

// Close the file

rst = f_close( &g_file);

if (FR_OK != rst){

R_error(5, &rst);

}

/* Open the file to be read */

rst = f_open( &g_file, path_txt, FA_OPEN_ALWAYS | FA_READ);

if (FR_OK != rst){

R_error(6, &rst);

}

/* Ensure that the file pointer points at beginning of the file */

rst = f_lseek( &g_file, 0);

if (FR_OK != rst){

R_error(7, &rst);

}

/* Clear the counter before counting the no. of bytes read */

byte_count = 0;

/* Repeat the read process until required no. of bytes are read */

while (byte_count < (sizeof(filebuffer) - 1)){

/* Read the file. 512 bytes at a time. */

rst = f_read( &g_file, (void *) buff, sizeof(buff), &file_rw_cnt);

/* Check if the read operation was successful & the no. of bytes read

by the function matches with the size of the R/W buffer */

if (rst != FR_OK || file_rw_cnt < sizeof(buff)){

R_error(8, &rst);

}else{

/* Compare the contents of the file with the ROM data */

for (data_count = 0; data_count < sizeof(buff); data_count++){

if (buff[data_count] != filebuffer[byte_count + data_count]){

/* error indication */

/* explicit error data, address */

R_error(9, &rst);

}

/* verify complete */

/* ================== */

}

/* Update the counter with the total no. of bytes read from the file */

byte_count += file_rw_cnt;

}

/* Close the file */

rst = f_close( &g_file);

if (FR_OK != rst){

R_error(10, &rst);

}

printf("Finished TFAT sample.\n");

}

あとは、const uint8_t filebuffer[] = {・・・} に書き込むダミーデータを用意し、
エラー表示用のstatic void R_error (uint8_t err_code, FRESULT *rst){} 関数を用意します。

標準のファイルシステムがfatfsになったので、使いやすくなりました。

RX64MでUSBメモリにアクセスする

RX64MにはUSBホストコントローラが内蔵されていますので、USBメモリを使用することができます。
今回は、USBAを使用します。USBは、USB0とUSBAの2種類ありますが、使用方法は同じです。
リソースの設定で、USB0_HOSTかUSBA_HOSTのどちらを選ぶかが異なります。
使用するFITモジュールと設定は下記のとおりです。

r_usb_basic 1.30
r_usb_hmsc 1.30
[設定項目なし]
r_tfat_driver_rx 1.08
r_tfat_rx 4.00
[設定項目なし]

ソフトウエアについては、以下のファイルをインクルードします。

//USB
#include "r_usb_basic_if.h"
#include "r_usb_hmsc_if.h"
//FAT
#include "r_tfat_driver_rx_if.h"
#include "r_tfat_driver_rx_config.h"

//USB

#include "r_usb_basic_if.h"

#include "r_usb_hmsc_if.h"

//FAT

#include "r_tfat_driver_rx_if.h"

#include "r_tfat_driver_rx_config.h"

USB制御用コードは、下記の様に作成しました。

#define USB_MEM_DEBUG_PRINT     1                   //デバッグ用 Printfの有効化
#define USB_MEM_DEV_NO          0                   //USBメモリ デバイス番号
#define USB_MEM_DRV_LETTER      "1:"                //USBメモリ ドライブ番号(FatFs)

FATFS               USB_MEM_FATFS;                  //USBメモリ ファイルシステム
usb_ctrl_t          USB_MEM_CTRL_TBL;               //USBメモリ 通信制御構造体
unsigned short      USB_MEM_ERR_STATUS = 0;         //USBメモリ エラーステータス
unsigned short      USB_MEM_READY = 0;              //USBメモリ 準備テータス

//USBメモリの初期化
void usb_mem_init(void){
    usb_err_t usb_err;
    usb_cfg_t cfg;

    //USB ピン設定
    R_USB_PinSet_USBA_HOST();

    //USBモジュール・ドライバ初期設定
    USB_MEM_CTRL_TBL.module = USB_IP1;
    USB_MEM_CTRL_TBL.type = USB_HMSC;
    cfg.usb_speed = USB_FS;
    cfg.usb_mode = USB_HOST;
    usb_err = R_USB_Open( &USB_MEM_CTRL_TBL, &cfg);
    if (USB_SUCCESS != usb_err){
        #ifdef USB_MEM_DEBUG_PRINT
        printf("ERROR: R_USB_Open.\n");
        #endif
        USB_MEM_ERR_STATUS |= 0x0001;
    }
}

//USBメモリ検出処理
void usb_mem_task(void){
    usb_status_t usb_event;
    uint8_t drv_no;
    FRESULT             f_res;

    usb_event = R_USB_GetEvent(&USB_MEM_CTRL_TBL);
    switch (usb_event){
        case USB_STS_CONFIGURED:    // Configured 状態
            #ifdef USB_MEM_DEBUG_PRINT
            printf("Detected attached USB memory.\n");
            #endif
            R_USB_HmscGetDriveNo(&USB_MEM_CTRL_TBL, &drv_no);
            if(drv_no != 0) break;
            f_res = f_mount(&USB_MEM_FATFS, USB_MEM_DRV_LETTER, 0);
            if(f_res == FR_OK){
                USB_MEM_READY = 1;
            }else{
                USB_MEM_ERR_STATUS |= 0x0400;
            }
            break;
        case USB_STS_DETACH:        // Detach 状態
            #ifdef USB_MEM_DEBUG_PRINT
            printf("Detected detached USB memory.\n");
            #endif
            USB_MEM_READY = 0;
            break;
        case USB_STS_DEFAULT:       // Default 状態
        case USB_STS_SUSPEND:       // Suspend 状態
        case USB_STS_NONE:
        default:
            break;
    }
}

#define USB_MEM_DEBUG_PRINT 1 //デバッグ用 Printfの有効化

#define USB_MEM_DEV_NO 0 //USBメモリデバイス番号

#define USB_MEM_DRV_LETTER "1:" //USBメモリドライブ番号(FatFs)

FATFS USB_MEM_FATFS; //USBメモリファイルシステム

usb_ctrl_t USB_MEM_CTRL_TBL; //USBメモリ通信制御構造体

unsigned short USB_MEM_ERR_STATUS = 0; //USBメモリエラーステータス

unsigned short USB_MEM_READY = 0; //USBメモリ準備テータス

//USBメモリの初期化

void usb_mem_init(void){

usb_err_t usb_err;

usb_cfg_t cfg;

//USB ピン設定

R_USB_PinSet_USBA_HOST();

//USBモジュール・ドライバ初期設定

USB_MEM_CTRL_TBL.module = USB_IP1;

USB_MEM_CTRL_TBL.type = USB_HMSC;

cfg.usb_speed = USB_FS;

cfg.usb_mode = USB_HOST;

usb_err = R_USB_Open( &USB_MEM_CTRL_TBL, &cfg);

if (USB_SUCCESS != usb_err){

#ifdef USB_MEM_DEBUG_PRINT

printf("ERROR: R_USB_Open.\n");

#endif

USB_MEM_ERR_STATUS |= 0x0001;

}

//USBメモリ検出処理

void usb_mem_task(void){

usb_status_t usb_event;

uint8_t drv_no;

FRESULT f_res;

usb_event = R_USB_GetEvent(&USB_MEM_CTRL_TBL);

switch (usb_event){

case USB_STS_CONFIGURED: // Configured 状態

#ifdef USB_MEM_DEBUG_PRINT

printf("Detected attached USB memory.\n");

#endif

R_USB_HmscGetDriveNo(&USB_MEM_CTRL_TBL, &drv_no);

if(drv_no != 0) break;

f_res = f_mount(&USB_MEM_FATFS, USB_MEM_DRV_LETTER, 0);

if(f_res == FR_OK){

USB_MEM_READY = 1;

}else{

USB_MEM_ERR_STATUS |= 0x0400;

}

break;

case USB_STS_DETACH: // Detach 状態

#ifdef USB_MEM_DEBUG_PRINT

printf("Detected detached USB memory.\n");

#endif

USB_MEM_READY = 0;

break;

case USB_STS_DEFAULT: // Default 状態

case USB_STS_SUSPEND: // Suspend 状態

case USB_STS_NONE:

default:

break;

}

初期化処理として、usb_mem_init();を一度実行します。
その後はメインループにて、usb_mem_task();を常時実行します。
カードの挿入を検出すると、USB_MEM_READYが1となり、アクセスが可能です。

ファイル操作自体は、ChaNさんのFatfsを使用しているので、そちらを参照します。
SDカードのサンプルと同様です。

FATライブラリとT4ライブラリを同時に使用する

スマートコンフィグレータを使用すると、簡単にFITモジュールを組み込むことができます。
しかし、残念な事にライブラリ同士の相性も存在するらしく、組み合わせるとエラーが出ることがあります。

そこで、ソースファイルを編集して対応します。原因はUINTが複数のモジュールで競合しているため。
それぞれのヘッダファイルに、#ifdef XXXと、#endifを追加し、別のモジュールを読み込んでいたら、typedefしない様に修正。
（すでにtypedef済みかチェックできると、良いのだけれど…）

r_t4_itcpip.h
#ifndef FF_DEFINED
typedef UW UINT;
#endif

ff.h
#ifndef _R_T4_ITCPIP_H
typedef unsigned int UINT; /* int must be 16-bit or 32-bit */
#endif

SDカードとUSBメモリが同時に使用できない

SDカードとUSBメモリを同時に使用しようとした際に、エラーで使えなかったので、その対策をメモ。
原因は、fatfsの設定でUSBドライブが使用できない場合、ドライブ数の設定が１になっている。
ffconf.hを編集する
/*—————————————————————————/
/ Drive/Volume Configurations
/—————————————————————————*/

#define FF_VOLUMES 2
/* Number of volumes (logical drives) to be used. (1-10) */

FF_VOLUMES の値を1から2に変更するだけ。
Fatfsの設定については、スマートコンフィグレータに組み込むのは諦めたのかなぁ．．．

りばさいどｆａｂの覚え書き

Category : RX64M

Articles

RX64Mでスマートコンフィグレータを使用したアプリの作成

RX64MにSDRAMを追加する

RX64MのEthernet1のみ使用する

RX64MでSD(TF)カードにアクセスする

RX64MでUSBメモリにアクセスする

FATライブラリとT4ライブラリを同時に使用する

SDカードとUSBメモリが同時に使用できない