忘備録-備忘録

技術的な備忘録

i2c通信関数

2015-03-26 07:37:56 | RX62N
RX62N用のi2c通信プログラムです。割り込みを利用しません。

  1. /*
  2.    Interface 2011年6月号を参考にして作成したIIC通信プログラム
  3.      割込みを使用しない
  4. */
  6. #include "iodefine.h"
  8. /*
  9.    RIICの初期化
  10.    引数　　無し
  11.    戻り値　無し
  12. */
  13. void initRIIC0(void)
  14. {
  15.     MSTP(RIIC0) = 0;            // モジュールスタンバイ解除
  17.     RIIC0.ICCR1.BIT.ICE = 0;
  18.     /* set port direction to input */
  19.     PORT1.DDR.BIT.B3 = 0;            // SDA0
  20.     PORT1.DDR.BIT.B2 = 0;            // SCL0
  21.     /* enable input buffer */
  22.     PORT1.ICR.BIT.B3 = 1;            // SDA0
  23.     PORT1.ICR.BIT.B2 = 1;            // SCL0
  24.     /* オープンドレイン設定 いらない？*/
  25.     PORT1.ODR.BIT.B3 = 1;
  26.     PORT1.ODR.BIT.B2 = 1;
  27.     /* RIIC disable for RIIC initial */
  28.     RIIC0.ICCR1.BIT.ICE = 0;
  29.     RIIC0.ICCR1.BIT.IICRST = 1;        // リセットパルス発生
  30.     RIIC0.ICCR1.BIT.IICRST = 0;
  31.     
  32.     /* Set baud rate */
  33.     RIIC0.ICMR1.BIT.CKS = 4;        // IIC phi = PCLK/8 clock
  34.     RIIC0.ICBRH.BIT.BRH = 25;        // 100kbps (PCLK = 48MHz)
  35.     RIIC0.ICBRL.BIT.BRL = 25;
  36.     /* disable all address detection. Master mode only. */
  37.     RIIC0.ICSER.BYTE = 0x00;
  38.     /* ACKWP is protect bit for ACKBT */
  39.     RIIC0.ICMR3.BIT.ACKWP = 1;        // disable protect for ACKBT
  40.     RIIC0.ICCR1.BIT.ICE = 1;        // enable RIIC
  41. }
  43. /*
  44.    バスフリーの確認
  45.    引数　　無し
  46.    戻り値　無し
  47. */
  48. inline void i2cBusFree(void)
  49. {
  50.     while(RIIC0.ICCR2.BIT.BBSY == 1);
  51. }
  53. /*
  54.    バス・スタートを実行
  55.    引数　　無し
  56.    戻り値　無し
  57. */
  58. inline void i2cStart(void)
  59. {
  60.     RIIC0.ICCR2.BIT.ST = 1;
  61.     while(RIIC0.ICSR2.BIT.START != 1);
  62.     RIIC0.ICSR2.BIT.START = 0;
  63. }
  65. /*
  66.    バスがBusy中にバス・スタート
  67.    引数　　無し
  68.    戻り値　無し
  69. */
  70. inline void i2cReStart(void)
  71. {
  72.     RIIC0.ICCR2.BIT.RS = 1;
  73.     while(RIIC0.ICSR2.BIT.START != 1);
  74.     RIIC0.ICSR2.BIT.START = 0;
  75. }
  77. /*
  78.    バス・ストップを実行
  79.    引数　　無し
  80.    戻り値　無し
  81. */
  82. inline void i2cStop(void)
  83. {
  84.     RIIC0.ICSR2.BIT.STOP = 0;
  85.     RIIC0.ICCR2.BIT.SP = 1;
  86.     while(RIIC0.ICSR2.BIT.STOP != 1);
  87.     RIIC0.ICSR2.BIT.STOP = 0;
  88.     RIIC0.ICSR2.BIT.NACKF = 0;
  89. }
  91. /*
  92.    デバイスに1byteデータ転送
  93.    引数　　送信データ
  94.    戻り値　無し
  95. */
  96. inline void i2cSendByte(unsigned char data)
  97. {
  98.     while(RIIC0.ICSR2.BIT.TDRE != 1);
  99.     RIIC0.ICDRT = data;
  100. }
  102. /*
  103.    データの転送完了を確認
  104.    引数　　無し
  105.    戻り値　無し
  106. */
  107. inline void i2cCheckTEND(void)
  108. {
  109.     while(RIIC0.ICSR2.BIT.TEND != 1);
  110. }
  112. /*
  113.    デバイスから1byte読み取りバスストップを実行
  114.    引数　　　無し
  115.    戻り値　　デバイスから読み取ったデータ
  116. */
  117. unsigned char i2cReceiveByteStop(void)
  118. {
  119.     unsigned char rdt;
  120.     while(RIIC0.ICSR2.BIT.RDRF != 1);
  121.     RIIC0.ICMR3.BIT.WAIT = 1;
  122.     RIIC0.ICMR3.BIT.ACKBT = 1;
  123.     rdt = RIIC0.ICDRR;                //dummy read
  124.     while(RIIC0.ICSR2.BIT.RDRF != 1);
  125.     RIIC0.ICSR2.BIT.STOP = 0;
  126.     RIIC0.ICCR2.BIT.SP = 1;            //stop
  127.     rdt = RIIC0.ICDRR;                //data read
  128.     RIIC0.ICMR3.BIT.WAIT = 0;
  129.     while(RIIC0.ICSR2.BIT.STOP != 1);
  130.     RIIC0.ICSR2.BIT.STOP = 0;
  131.     RIIC0.ICSR2.BIT.NACKF = 0;
  132.     return rdt;
  133. }
  135. /*
  136.    スレーブ・アドレスを指定してデバイスのレジスタ・メモリにデータを書き込む
  137.    引数　　　sadr　:　スレーブ・アドレス
  138.    　　　　　madr　:　レジスタ・メモリアドレス
  139.    　　　　　data　:　書き込むデータ
  140.    戻り値　　無し
  141. */
  142. void i2cDevWrite(unsigned char sadr, unsigned char madr, unsigned char data)
  143. {
  144.     i2cBusFree();
  145.     i2cStart();
  146.     i2cSendByte(sadr);
  147.     i2cSendByte(madr);
  148.     i2cSendByte(data);
  149.     i2cCheckTEND();
  150.     i2cStop();
  151. }
  153. /*
  154.   スレーブアドレスとデバイスのレジスタ・アドレスを指定してデバイスからデータを読み込む
  155.   引数　　　sadr　:　スレーブ・アドレス
  156.   　　　　　madr　:　レジスタ・メモリアドレス
  157.   戻り値　　読み込んだデバイスのデータ
  158. */
  159. unsigned char i2cDevRead(unsigned char sadr, unsigned char madr)
  160. {
  161.     unsigned char rdt;
  162.     i2cBusFree();
  163.     i2cStart();
  164.     i2cSendByte(sadr);
  165.     i2cSendByte(madr);
  166.     i2cCheckTEND();
  167.     i2cReStart();
  168.     i2cSendByte(sadr | 0x01);
  169.     rdt = i2cReceiveByteStop();
  170.     return rdt;
  171. }
  173. /*
  174.    スレーブアドレスを指定して複数byteのデータを送信する
  175.    引数　　sadr : スレーブアドレス
  176.    　　　　databuff: 送信するデータの入った配列
  177.    　　　　datanum : 送信するデータ数
  178.    戻り値　0 : 送信完了　　-1 : 送信エラー
  179. */
  180. int i2cSendData(unsigned char sadr, const unsigned char databuff[], int datanum)
  181. {
  182.     int senddata=-1,ret=-1;
  183.     
  184.     i2cBusFree();
  185.     i2cStart();
  186.     while(senddata<datanum) {
  187.         if(RIIC0.ICSR2.BIT.NACKF != 0) goto sendstop;    //送信エラー
  188.         if(RIIC0.ICSR2.BIT.TDRE != 1) continue;
  189.         if(senddata < 0) {
  190.             RIIC0.ICDRT = sadr;            //最初にアドレスを送信
  191.         } else {
  192.             RIIC0.ICDRT = databuff[senddata];
  193.         }
  194.         senddata++;
  195.     }
  196.     i2cCheckTEND();
  197.     ret = 0;        //送信完了
  199. sendstop:
  200.     i2cStop();
  201.     return ret;
  202. }
  204. /*
  205.    スレーブアドレスを指定して複数byteのデータを受信する
  206.    引数　　sadr : スレーブアドレス
  207.    　　　　databuff: 受信したデータを入れる配列
  208.    　　　　datanum : 受信するデータ数
  209.    戻り値　0 : 受信完了　　-1 : 受信エラー
  210. */
  211. int i2cReceiveData(unsigned char sadr, unsigned char databuff[], int datanum)
  212. {
  213.     int recvdata=0,ret=-1;
  214.     unsigned char dummy;
  215.     
  216.     i2cBusFree();
  217.     i2cStart();
  218.     i2cSendByte(sadr | 0x01);        // アドレス送信 受信設定(|0x01)
  219.     i2cCheckTEND();
  220.     if(datanum == 1 ) {
  221.         databuff[0] = i2cReceiveByteStop();
  222.         return 0;
  223.     }
  224.     if(RIIC0.ICSR2.BIT.NACKF == 0) {
  225.     /* データ受信処理 */
  226.         dummy = RIIC0.ICDRR;                //dummy read
  227.         while(recvdata < datanum) {
  228.             if(RIIC0.ICSR2.BIT.RDRF != 1) continue;
  229.             if(recvdata == (datanum-2) ) break;
  230.             if(recvdata == (datanum-3) ) {
  231.                 RIIC0.ICMR3.BIT.WAIT = 1;
  232.             }
  233.             databuff[recvdata++] = RIIC0.ICDRR;
  234.         }
  235.         RIIC0.ICMR3.BIT.ACKBT = 1;
  236.         databuff[recvdata++] = RIIC0.ICDRR;
  237.         while(RIIC0.ICSR2.BIT.RDRF != 1);
  238.         RIIC0.ICSR2.BIT.STOP = 0;
  239.         RIIC0.ICCR2.BIT.SP = 1;
  240.         databuff[recvdata++] = RIIC0.ICDRR;
  241.         RIIC0.ICMR3.BIT.WAIT = 0;
  242.         ret = 0;
  243.     } else {
  244.     /* 受信エラー */
  245.         RIIC0.ICSR2.BIT.STOP = 0;
  246.         RIIC0.ICCR2.BIT.SP = 1;
  247.         dummy = RIIC0.ICDRR;        //dummy read
  248.     }    
  249.     while(RIIC0.ICSR2.BIT.STOP != 1);
  250.     RIIC0.ICSR2.BIT.STOP = 0;
  251.     RIIC0.ICSR2.BIT.NACKF = 0;
  252.     
  253.     return ret;
  254. }

RX210のクロックをPLLに切り替えるプログラム

2015-03-26 07:17:08 | RX210
RX210のクロックをPLLに切り替えるプログラムです。ルネサスエレクトロニクスのサンプルコードを単純化したものです。水晶振動子の発振周波数が20MHzの時にCPUの動作クロックが50MHzとなり周辺機器のクロックが25MHzとなります。

  1. /* RX210 cpuのクロックをPLLに切り替えるプログラム */
  2. /* 水晶振動子の発振周波数が20MHzの時にCPUの動作クロックが50MHzとなり周辺機器のクロックが25MHzとなる。 */
  3.                                                                           
  4. #include "iodefine.h"
  5. #include <machine.h>
  7. void change_oscillation_PLL(void)
  8. {
  9.     unsigned int i;
  11.     /* ---- Enable write protection ---- */
  12.     /* PRCR - Protect Register
  13.     b15:b8 PRKEY - PRC Key Code - A5h
  14.                   (The write value should be A5h to permission writing PRCi bit)
  15.     b7:b4 Reserved - The write value should be 0.
  16.     b3 PRC3 - Protect Bit 3 - Write disabled
  17.     b2 PRC2 - Protect Bit 2 - Write enabled
  18.     b1 PRC1 - Protect Bit 1 - Write enabled
  19.     b0 PRC0 - Protect Bit 0 - Write enabled */
  20.     SYSTEM.PRCR.WORD = 0xA507;
  22.     /* ---- Set the VRCR register ---- */
  23.     SYSTEM.VRCR = 0x00;
  25.     /* ---- Set the main clock oscillator drive capability ---- */
  26.     /* MOFCR - Main Clock Oscillator Forced Oscillation Control Register
  27.     b7 Reserved - The write value should be 0.
  28.     b6 MOSEL - Main Clock Oscillator Switch - Resonator
  29.     b5:b4 MODRV2 - Main Clock Oscillator Drive Capability Switch 2
  30.                       - 16 MHz to 20 MHz
  31.     b3:b1 MODRV - Main Clock Oscillator Drive Capability Switch
  32.                       - 16 MHz to 20 MHz non-lead type ceramic resonator
  33.     b0 Reserved - The write value should be 0. */
  34.     SYSTEM.MOFCR.BYTE = (0x30);    /* Drive capability : 20 MHz crystal resonator */
  36.     /* ---- Set wait time until the main clock oscillator stabilizes ---- */
  37.     /* MOSCWTCR - Main Clock Oscillator Wait Control Register
  38.     b7:b5 Reserved - The write value should be 0.
  39.     b4:b0 MSTS - Main Clock Oscillator Waiting Time
  40.                       - Wait time is 131072 cycles (approx. 6.55 ms). */
  41.     SYSTEM.MOSCWTCR.BYTE = (0x0D);    /* Wait control register : 131072 cycles (approx. 6.55 ms) */
  43.     /* ---- Operate the main clock oscillator ---- */
  44.     /* MOSCCR - Main Clock Oscillator Control Register
  45.     b7:b1 Reserved - The write value should be 0.
  46.     b0 MOSTP - Main Clock Oscillator Stop - Main clock oscillator is operating. */
  47.     SYSTEM.MOSCCR.BYTE = 0x00;
  49.     while (0x00 != SYSTEM.MOSCCR.BYTE)
  50.     {
  51.         /* Confirm that the written value can be read correctly. */
  52.     }
  55.     /* ---- Wait processing for the clock oscillation stabilization ---- */
  56.     for(i=0;i<100;i++) nop();</li>
  58.     /* ---- Set the PLL division ratio and multiplication factor ---- */
  59.     /* PLLCR - PLL Control Register
  60.     b15:b13 Reserved - The write value should be 0.
  61.     b12:b8 STC - Frequency Multiplication Factor Select
  62.                       - Frequency multiplication factor is multiply-by-10.
  63.     b7:b2 Reserved - The write value should be 0.
  64.     b1:b0 PLIDIV - PLL Input Frequency Division Ratio Select
  65.                       - PLL input division ratio is divide-by-2. */
  66.     SYSTEM.PLLCR.WORD = (0x0901);    /* Division ratio and multiplication factor : divide-by-2, multiply-by-10 */
  68.     /* ---- Set wait time until the PLL clock oscillator stabilizes ---- */
  69.     /* PLLWTCR - PLL Wait Control Register
  70.     b7:b5 Reserved - The write value should be 0.
  71.     b4:b0 PSTS - PLL Waiting Time
  72.                       - Wait time is 65536 cycles (approx. 655.36 us). */
  73.     SYSTEM.PLLWTCR.BYTE = (0x09);    /* Wait control register : 65536 cycles (approx. 655.36 us) */
  75.     /* ---- Operate the PLL clock oscillator ---- */
  76.     /* PLLCR2 - PLL Control Register 2
  77.     b7:b1 Reserved - The write value should be 0.
  78.     b0 PLLEN - PLL Stop Control - PLL is operating. */
  79.     SYSTEM.PLLCR2.BYTE = 0x00;
  81.     /* ---- Wait processing for the clock oscillation stabilization ---- */
  82.     for(i=0;i<100;i++) nop();</li>
  84.     /* ---- Set the operating power control mode ---- */
  85.     /* OPCCR - Operating Power Control Register
  86.     b7:b5 Reserved - The write value should be 0.
  87.     b4 OPCMTSF - Operating Power Control Mode Transition Status Flag
  88.     b3 Reserved - The write value should be 0.
  89.     b2:b0 OPCM - Operating Power Control Mode Select - High-speed operating mode */
  90.     SYSTEM.OPCCR.BYTE = (0x00); /* High-speed operating mode */
  92.     while (0 != SYSTEM.OPCCR.BIT.OPCMTSF)
  93.     {
  94.         /* Confirm that the operation power control mode transition completed. */
  95.     }
  97.     /* ---- Set the internal clock division ratio ---- */
  98.     /* SCKCR - System Clock Control Register
  99.     b31:b28 FCK - FlashIF Clock(FCLK) Select - divide-by-4
  100.     b27:b24 ICK - System Clock (ICLK) Select - divide-by-2
  101.     b23 PSTOP1 - BCLK Pin Output Control - disabled. (Fixed high)
  102.     b22:b20 Reserved - The write value should be 0.
  103.     b19:b16 BCK - External Bus Clock (BCLK) Select - divide-by-4
  104.     b15:b12 Reserved - The write value should be 0001b.
  105.     b10:b8 PCLKB - Peripheral Module Clock B(PCLKB) Select - divide-by-4
  106.     b7:b4 Reserved - The write value should be 0001b.
  107.     b3:b0 PCLKD - Peripheral Module Clock D(PCLKD) Select - divide-by-2 */
  108.     SYSTEM.SCKCR.LONG = 0x21821211;    /* ICLK,PCLKD: divide-by-2 PCLKB,BCLK,FCLK: divide-by-4 */
  110.     while (0x21821211 != SYSTEM.SCKCR.LONG)
  111.     {
  112.          /* Confirm that the written value can be read correctly. */
  113.     }
  115.     /* ---- Set the BCLK pin output ---- */
  116.     /* BCKCR - External Bus Clock Control Register
  117.     b7:b1 Reserved - The write value should be 0.
  118.     b0 BCLKDIV - BCLK Pin Output Select - divide-by-2 */
  119.     SYSTEM.BCKCR.BYTE = 0x01;
  121.     while (0x01 != SYSTEM.BCKCR.BYTE)
  122.     {
  123.         /* Confirm that the written value can be read correctly. */
  124.     }
  126.     /* ---- Set the internal clock source ---- */
  127.     /* SCKCR3 - System Clock Control Register 3
  128.     b15:b11 Reserved - The write value should be 0.
  129.     b10:b8 CKSEL - Clock Source Select - PLL circuit is selected.
  130.     b7:b1 Reserved - The write value should be 0. */
  131.     SYSTEM.SCKCR3.WORD = (0x0400);    /* PLL */
  133.     while ((0x0400) != SYSTEM.SCKCR3.WORD)
  134.     {
  135.         /* Confirm that the written value can be read correctly. */
  136.     }
  138.     /* ---- Disable write protection ---- */
  139.     /* PRCR - Protect Register
  140.     b15:b8 PRKEY - PRC Key Code - A5h
  141.                   (The write value should be A5h to permission writing PRCi bit)
  142.     b2 PRC2 - Protect Bit 2 - Write disabled
  143.     b1 PRC1 - Protect Bit 1 - Write disabled
  144.     b0 PRC0 - Protect Bit 0 - Write disabled */
  145.     SYSTEM.PRCR.WORD = 0xA500;
  147. }
  150. void main(void)
  151. {
  152.     unsigned int i;
  154.     change_oscillation_PLL();            //クロックソースPLL
  156.     PORTC.PDR.BYTE = 0xFF;
  157.     PORTC.PODR.BYTE = 0x00;
  158.     PORTA.PDR.BYTE = 0xFF;
  159.     PORTA.PODR.BYTE =0x00;
  160.     PORTB.PDR.BYTE = 0xFF;
  161.     PORTB.PODR.BYTE = 0xFF;
  163.     while(1) {
  164.         PORTC.PODR.BYTE = ~PORTC.PODR.BYTE;
  165.         PORTA.PODR.BYTE = ~PORTA.PODR.BYTE;
  166.         PORTB.PODR.BYTE = ~PORTB.PODR.BYTE;
  167.         for(i=0;i<500000;i++) nop();</li>
  168.     }
  170. }

RX210のクロックを内蔵高速クロックに切り替えるプログラム

2015-03-26 07:00:27 | RX210
RX210のクロックを内蔵高速クロックに切り替えるプログラムです。ルネサスエレクトロニクスのサンプルコードを単純化したものです。 change_oscillation_HOCO()関数の引数でクロック周波数を変更できます。

  1. /* RX210 cpuのクロックを内蔵高速クロックに切り替えるプログラム */
  2.                                                                            
  3.                                                                           
  4. #include "iodefine.h"
  5. #include <machine.h>
  8. #define FREQ_32MHz (0x00) /* 32 MHz */
  9. #define FREQ_36MHz (0x01) /* 36.864 MHz */
  10. #define FREQ_40MHz (0x02) /* 40 MHz */
  11. #define FREQ_50MHz (0x03) /* 50 MHz */
  14. void change_oscillation_HOCO(unsigned char cpufreq) // <--引数にOSCの周波数を設定
  15. {
  16.     unsigned char reg_hocwtcr2;
  17.     unsigned int i;
  19.     cpufreq &= 0x03;
  21.     if(cpufreq == FREQ_50MHz) {
  22.         reg_hocwtcr2 = 0x03;        /* 50 MHz : 9216 cycles */
  23.     } else {
  24.         reg_hocwtcr2 = 0x02;        /* 32 MHz, 36.864 MHz, 40 MHz : 7168 cycles */
  25.     }
  27.     /* ---- Enable write protection ---- */
  28.     /* PRCR - Protect Register
  29.     b15:b8 PRKEY - PRC Key Code - A5h
  30.                   (The write value should be A5h to permission writing PRCi bit)
  31.     b7:b4 Reserved - The write value should be 0.
  32.     b3 PRC3 - Protect Bit 3 - Write disabled
  33.     b2 PRC2 - Protect Bit 2 - Write enabled
  34.     b1 PRC1 - Protect Bit 1 - Write enabled
  35.     b0 PRC0 - Protect Bit 0 - Write enabled */
  36.     SYSTEM.PRCR.WORD = 0xA507;
  38.     /* ---- Set the VRCR register ---- */
  39.     SYSTEM.VRCR = 0x00;
  41.     /* ---- Set the HOCO frequency ---- */
  42.     /* HOCOCR2 - High-Speed On-Chip Oscillator Control Register 2
  43.     b7:b2 Reserved - The write value should be 0.
  44.     b1:b0 HCFRQ - HOCO Frequency Setting - 50 MHz */
  45.     SYSTEM.HOCOCR2.BYTE = cpufreq;
  47.     /* ---- Set wait time until the HOCO oscillator stabilizes ---- */
  48.     /* HOCOWTCR2 - HOCO Wait Control Register 2
  49.     b7:b4 Reserved - The write value should be 0.
  50.     b3:b0 HSTS2 - HOCO Wait Time Select 2
  51.                       - Wait time is 9216 cycles (approx. 184.32 us). */
  52.     SYSTEM.HOCOWTCR2.BYTE = reg_hocwtcr2;
  54.     //SYSTEM.SCKCR.BIT.BCK = 1;            //BCK　2分周
  56.     /* ---- Operate the HOCO clock ---- */
  57.     /* HOCOCR - High-Speed On-Chip Oscillator Control Register
  58.     b7:b1 Reserved - The write value should be 0.
  59.     b0 HCSTP - the HOCO is operating. */
  60.     SYSTEM.HOCOCR.BYTE = 0x00;
  62.     /* ---- Wait processing for the clock oscillation stabilization ---- */
  63.     for(i=0;i<100;i++) nop();
  65.     /* ---- Set the internal clock division ratio ---- */
  66.     /* SCKCR - System Clock Control Register
  67.     b31:b28 FCK - FlashIF Clock(FCLK) Select - divide-by-4
  68.     b27:b24 ICK - System Clock (ICLK) Select - divide-by-2
  69.     b23 PSTOP1 - BCLK Pin Output Control - disabled. (Fixed high)
  70.     b22:b20 Reserved - The write value should be 0.
  71.     b19:b16 BCK - External Bus Clock (BCLK) Select - divide-by-4
  72.     b15:b12 Reserved - The write value should be 0001b.
  73.     b10:b8 PCLKB - Peripheral Module Clock B(PCLKB) Select - divide-by-4
  74.     b7:b4 Reserved - The write value should be 0001b.
  75.     b3:b0 PCLKD - Peripheral Module Clock D(PCLKD) Select - divide-by-2 */
  76.     SYSTEM.SCKCR.LONG = 0x10811110;    /* ICLK,PCLKD: no division PCLKB,BCLK,FCLK: divide-by-2 */
  78.     while (0x10811110 != SYSTEM.SCKCR.LONG)
  79.     {
  80.          /* Confirm that the written value can be read correctly. */
  81.     }
  83.     /* ---- Set the BCLK pin output ---- */
  84.     /* BCKCR - External Bus Clock Control Register
  85.     b7:b1 Reserved - The write value should be 0.
  86.     b0 BCLKDIV - BCLK Pin Output Select - divide-by-2 */
  87.     SYSTEM.BCKCR.BYTE = 0x01;
  89.     while (0x01 != SYSTEM.BCKCR.BYTE)
  90.     {
  91.         /* Confirm that the written value can be read correctly. */
  92.     }
  94.     /* ---- Set the internal clock source ---- */
  95.     /* SCKCR3 - System Clock Control Register 3
  96.     b15:b11 Reserved - The write value should be 0.
  97.     b10:b8 CKSEL - Clock Source Select - PLL circuit is selected.
  98.     b7:b1 Reserved - The write value should be 0. */
  99.     SYSTEM.SCKCR3.WORD = 0x0100;
  101.     while (0x0100 != SYSTEM.SCKCR3.WORD)
  102.     {
  103.         /* Confirm that the written value can be read correctly. */
  104.     }
  106.     /* ---- Disable write protection ---- */
  107.     /* PRCR - Protect Register
  108.     b15:b8 PRKEY - PRC Key Code - A5h
  109.                   (The write value should be A5h to permission writing PRCi bit)
  110.     b2 PRC2 - Protect Bit 2 - Write disabled
  111.     b1 PRC1 - Protect Bit 1 - Write disabled
  112.     b0 PRC0 - Protect Bit 0 - Write disabled */
  113.     SYSTEM.PRCR.WORD = 0xA500;
  115. }
  118. void main(void)
  119. {
  120.     unsigned int i;
  122.     change_oscillation_HOCO(FREQ_50MHz);            //クロック変更
  124.     PORTC.PDR.BYTE = 0xFF;
  125.     PORTC.PODR.BYTE = 0x00;
  126.     PORTA.PDR.BYTE = 0xFF;
  127.     PORTA.PODR.BYTE =0x00;
  128.     PORTB.PDR.BYTE = 0xFF;
  129.     PORTB.PODR.BYTE = 0xFF;
  131.     while(1) {
  132.         PORTC.PODR.BYTE = ~PORTC.PODR.BYTE;
  133.         PORTA.PODR.BYTE = ~PORTA.PODR.BYTE;
  134.         PORTB.PODR.BYTE = ~PORTB.PODR.BYTE;
  135.         for(i=0;i<500000;i++) nop();
  136.     }
  138. }