main.c

   1 /*
   2  * File:   main.c
   3  * sciLogger サブCPU
   4  * PIC24Fj64GA004
   5  * 8MHz
   6  *
   7  * Created on February 9, 2010, 10:53 AM
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <p24FJ64GA004.h>
  13 #include <libpic30.h>
  14 //#include <uart.h>
  15 #include <string.h>
  16 #include "myuart.h"
  17 #include "myspi.h"
  18 #include "debug_print.h"
  19 #include "ublox.h"
  20 #include "myad.h"
  21 #include "delay.h"
  22 #include "ring.h"
  23 #include "byte2var.h"
  24 #include "myint.h"
  25 #include "mysts.h"
  26
  27 _CONFIG1( JTAGEN_OFF & GCP_OFF & GWRP_OFF & COE_OFF & FWDTEN_OFF & ICS_PGx2 )
  28 //_CONFIG2( FCKSM_CSDCMD & OSCIOFNC_ON & POSCMOD_OFF & FNOSC_FRC)
  29 #pragma config FCKSM = CSDCMD, OSCIOFNC = ON, POSCMOD = OFF, FNOSC = FRC, FPBDIV = DIV_8
  30
  31 //#define CPU_CLOCK        10000000                         // クロック[ Hz ]
  32 //#define CPU_PLL          8                                // PLL
  33 //#define CLOCK_FREQUENCY  ( ( CPU_CLOCK * CPU_PLL ) / 4 )  // 動作周波数[ Hz ]
  34 //#define FOSC 4000000L
  35 // UART2 Debug Port
  36 #define BAUDRATE2         9600L
  37 // UART1 GPS
  38 #define BAUDRATE1         9600L
  39
  40 /*** ADバッファ *************************************************
  41  * 50Hzデータ
  42  * 1秒平均データ
  43  * タイムスタンプ
  44  */
  45 #define ADBUF_BYTE  3   // AD 1CH 1sample dataのbyte数
  46
  47 typedef struct {
  48     UbloxNavTimeUtc t;  // タイムスタンプ
  49     long data1sec[AD_CHNUM];  // 1sec平均値
  50     unsigned char data[AD_CHNUM][ADBUF_BYTE*AD_SAMPLE];  // AD_SAMPLE[Hz]のデータ
  51 } ADbufType;
  52 static ADbufType   adbuf[RING_NUM];
  53
  54 // SPI外部送信用バッファ AD_SAMPLE[Hz]
  55 //static char adbuf[RING_NUM][AD_CHNUM][ADBUF_BYTE*AD_SAMPLE];
  56 // 1sec平均値
  57 //static long adbuf_1sec[RING_NUM][AD_CHNUM];
  58 // timestamp
  59 //static UbloxNavTimeUtc adbuf_t[RING_NUM];
  60
  61 #define adbuf_get(buf_no)   (&adbuf[buf_no])
  62 #define adbuf_data_get(buf_no)   (adbuf[buf_no].data)
  63 #define adbuf_1sec_get(buf_no)   (adbuf[buf_no].data1sec)
  64 #define adbuf_time_get(buf_no)   (&(adbuf[buf_no].t))
  65
  66 inline void my_memcpy(void *dest0, void *src0, int len)
  67 {
  68     int i;
  69     char *dest, *src;
  70
  71     dest = (char*)dest0;
  72     src = (char*)src0;
  73     for(i = 0; i < len; i++) {
  74         *dest++ = *src++;
  75     }
  76 }
  77 inline void my_memset(void *dest0, unsigned char data, int len)
  78 {
  79     int i;
  80     char *dest;
  81
  82     dest = (char*)dest0;
  83     for(i = 0; i < len; i++) {
  84         *dest++ = data;
  85     }
  86 }
  87 inline void adbuf_write(unsigned char buf_no, unsigned char ch, int cnt, long *data)
  88 {
  89     unsigned char    *ptr = (unsigned char*)data;
  90     unsigned char   i;
  91
  92     for(i = 0; i < ADBUF_BYTE; i++) {
  93         adbuf->data[ch][ADBUF_BYTE*cnt + i] = *(ptr++);
  94     }
  95 }
  96 // 1
  97 inline void adbuf_1sec_write(char buf_no, long *data)
  98 {
  99     my_memcpy(adbuf_1sec_get(buf_no), data, sizeof(long) * AD_CHNUM);
 100 /*    char ch;
 101     for(ch = 0; ch < AD_CHNUM; ch++)
 102         adbuf_1sec[buf_no][ch] = data[ch];
 103 */
 104 }
 105 inline void adbuf_time_write(char buf_no, UbloxNavTimeUtc *t)
 106 {
 107 //    my_memcpy(&adbuf_t[buf_no], t, sizeof(UbloxNavTimeUtc));
 108     my_memcpy(adbuf_time_get(buf_no), t, sizeof(UbloxNavTimeUtc));
 109 }
 110
 111 /**** ublox *************************************************/
 112
 113 void test_ublox_rcv_mon(void)
 114 {
 115     unsigned char class, id;
 116     unsigned int    len;
 117     unsigned char   payload[128];
 118     char    sz[128];
 119     UbloxNavTimeUtc *gps, gps1;
 120
 121     gps = &gps1;
 122
 123     while(1) {
 124         ublox_rcv_pkt(&class, &id, &len, payload);
 125         sprintf(sz, "CLASS=%02X ID=%02X LEN=%d\r\n", class, id, len);
 126         PDEBUG(sz);
 127         ublox_debug_pkt_out(payload, len);
 128         ublox_decode_nav_timeutc(payload, gps);
 129         sprintf(sz, "%04u/%02d/%02d %02d:%02d:%02d.%09ld %6lums %6luns %02X\r\n",
 130             gps->year, gps->month, gps->day, gps->hour, gps->min, gps->sec, gps->nano,
 131             gps->tow, gps->tacc, gps->valid
 132         );
 133         PDEBUG(sz);
 134
 135     }
 136 }
 137 static UbloxNavTimeUtc gpsNow;
 138 static void ublox_rcv(void)
 139 {
 140     unsigned char class, id;
 141     unsigned int    len;
 142     unsigned char   payload[128];
 143 //    char    sz[128];
 144     UbloxNavTimeUtc *gps = &gpsNow;
 145
 146     ublox_rcv_pkt(&class, &id, &len, payload);
 147 //    sprintf(sz, "CLASS=%02X ID=%02X LEN=%d\r\n", class, id, len);
 148 //    PDEBUG(sz);
 149 //    ublox_debug_pkt_out(payload, len);
 150     if (class == UBX_CLS_NAV && id == UBX_ID_NAV_TIMEUTC && len == UBX_LEN_NAV_TIMEUTC) {
 151         ublox_decode_nav_timeutc(payload, gps);
 152 /*        sprintf(sz, "%04u/%02d/%02d %02d:%02d:%02d.%09ld %6lums %6luns %02X\r\n",
 153             gps->year, gps->month, gps->day, gps->hour, gps->min, gps->sec, gps->nano,
 154             gps->tow, gps->tacc, gps->valid
 155         );
 156         PDEBUG(sz);
 157 */
 158     }
 159 }
 160
 161 /**** INT1/SPI1 ***********************************************/
 162 /*
 163  * INT1 Int及びSPI1 IntでADのデータを取得する
 164  */
 165 #define ADSTS_IDLE  0
 166 #define ADSTS_H 1
 167 #define ADSTS_M 2
 168 #define ADSTS_L 3
 169
 170
 171 static char adint_ch;   // 取得中のCH
 172 static char adint_cnt = 0;  // 0〜AD_SAMPLE-1
 173 static char adint_sts = ADSTS_IDLE;
 174 static long adint_add[AD_CHNUM];    // 1秒平均用加算
 175
 176 /**** 1PPS ********************************************/
 177 static char pps_intf;
 178
 179 #define pps_intf_clear()  pps_intf = 0
 180 #define pps_intf_set()  pps_intf = 1
 181 #define pps_is_intf_enable()    (pps_intf != 0)
 182
 183 /*
 184  * SPI FLAG test
 185  */
 186 void test_spi_flag(void)
 187 {
 188     char    sz[128];
 189     int in;
 190     unsigned char txc = 0;
 191     unsigned char rxc;
 192
 193     spi2_int_disable();
 194     cnint_int_disable();
 195     while(1) {
 196         delay_ms(1000);
 197         sprintf(sz, "SPI2STAT=%04X "
 198                 "SPIBEC=%d SRMPT=%d SPIROV=%d SRXMPT=%d TBF=%d RBF=%d\r\n"
 199                 , SPI2STAT
 200                 , SPI2STATbits.SPIBEC
 201                 , SPI2STATbits.SRMPT
 202                 , SPI2STATbits.SPIROV
 203                 , SPI2STATbits.SRXMPT
 204                 , SPI2STATbits.SPITBF
 205                 , SPI2STATbits.SPIRBF
 206                 );
 207         PDEBUG(sz);
 208         if ((in = uart2_rcvbuf_getc()) >= 0) {
 209             uart2_myputc(in);
 210             uart2_puts("\r\n");
 211
 212             switch(in) {
 213                 case 'r':
 214                     rxc = spi2_getc();
 215                     sprintf(sz, "RX=%02X\r\n", rxc);
 216                     uart2_puts(sz);
 217                     break;
 218                 case 't':
 219                     spi2_putc(txc++);
 220                     sprintf(sz, "TX=%02X\r\n", txc);
 221                     uart2_puts(sz);
 222                     break;
 223                 case 'v':
 224                     spi2_rx_overrun_clear();
 225                     break;
 226                 case 'x':
 227                     SPI2STATbits.SRXMPT = 0;
 228                     break;
 229                 case 'y':
 230                     SPI2STATbits.SRXMPT = 1;
 231                     break;
 232             }
 233         }
 234     }
 235 }
 236 /*
 237  * polling send/rcv
 238  */
 239 void test_spi_send(void)
 240 {
 241     unsigned char txc = 1;
 242     unsigned char rxc;
 243     char    sz[128];
 244
 245     spi2_int_disable();
 246     cnint_int_disable();
 247 //    SPI2BUF = txc++;
 248 //    rxc = SPI2BUF;
 249     while(1) {
 250         while(SPI2STATbits.SPITBF == 0) {
 251             // TX
 252             SPI2BUF = txc++;
 253         }
 254         if (SPI2STATbits.SRXMPT == 0) {
 255             while(SPI2STATbits.SRXMPT == 0) {
 256                 // RX FIFO読み出し
 257                 rxc = SPI2BUF;
 258             }
 259 #if 0
 260             sprintf(sz, "SPI2STAT=%04X "
 261                     "SPIBEC=%d SRMPT=%d SPIROV=%d SRXMPT=%d TBF=%d RBF=%d\r\n"
 262                     , SPI2STAT
 263                     , SPI2STATbits.SPIBEC
 264                     , SPI2STATbits.SRMPT
 265                     , SPI2STATbits.SPIROV
 266                     , SPI2STATbits.SRXMPT
 267                     , SPI2STATbits.SPITBF
 268                     , SPI2STATbits.SPIRBF
 269                     );
 270             PDEBUG(sz);
 271 #endif
 272         }
 273     }
 274
 275 }
 276 /*
 277  * main()
 278  */
 279 int main(int argc, char** argv) {
 280     unsigned int i;
 281     // UART2 DebugPort
 282     const double Baudrate2 = ( double )FCY / ( 16 * BAUDRATE2 ) - 1;
 283     // ボーレートの小数点以下を四捨五入する
 284     unsigned int baudrate2 = ( unsigned int )( Baudrate2 + 0.5 );
 285     // UART1 GPS
 286     const double Baudrate1 = ( double )FCY / ( 16 * BAUDRATE1 ) - 1;
 287     // ボーレートの小数点以下を四捨五入する
 288     unsigned int baudrate1 = ( unsigned int )( Baudrate1 + 0.5 );
 289     char    sz[128];
 290     UbloxNavTimeUtc *gps = &gpsNow;
 291
 292     /**** 割り込み禁止 ****/
 293     SET_CPU_IPL( 7 );
 294     __builtin_write_OSCCONL(OSCCON & 0xbf); //clear the bit 6 of OSCCONL to unlock Pin Re-map
 295     // 割り込みネストenable
 296     int_nest_enable();
 297
 298     // UART1ピン割り当て
 299     RPINR18bits.U1RXR = 6;      // UART1 RX to RP6
 300     RPOR2bits.RP5R =  3;        // UART1 TX(3) to RP5
 301     // UART2ピン割り当て
 302     RPINR19bits.U2RXR = 21;     // UART2 RX to RP21
 303     RPOR10bits.RP20R = 5;       // UART2 TX(5) to RP20
 304     // PIC-RDYピン割り当て
 305     RPOR12bits.RP25R = 0;       // RC9
 306
 307     // DataOut SPI2 pin config
 308     RPINR22bits.SDI2R = 13;     // SPI2 RX to RP13
 309     RPINR22bits.SCK2R = 23;     // SPI2 CLK to RP23
 310     RPINR23bits.SS2R = 24;      // SPI2 SS to RP24
 311     RPOR11bits.RP22R = 10;      // SPI1 SDO2(10) to RP22
 312     // AD SPI1 pin config
 313     RPINR20bits.SDI1R = 18;     // SPI1 RX to RP18
 314     RPOR8bits.RP16R = 8;        // SPI1 SCK1(8) to RP16
 315     RPOR8bits.RP17R = 7;        // SPI1 SDO1(7) to RP17
 316     // TRISx 1=input 0=output
 317     TRISA = 0x0000;             // PortA RA7,8,9 output
 318     //        5432109876543210
 319     TRISB = 0b0011000011000000; // PortB RB13(RP13),RB12,RB7,RB6(RP6) input
 320     TRISC = 0x01A4;             // ポートC RC8(RP24),RC7(RP23),RC5(RP21),RC2(RP18) input
 321     CLKDIV = 0;                 // CPU Peripheral Clock Ratio=1:1
 322     AD1PCFG = 0xFFFF;           // AN1-12input pin = Digital mode
 323
 324     // INT1(RP12 RB12) AD -DRDY0 setup
 325     RPINR0bits.INT1R = 12;  // RP12(RB12)
 326     int1_int_disable();
 327     int1_level_set(4);    // Int priority
 328     int1_edge_neg(); // Negative Edge
 329     // INT0(RB7) GPS +PPS setup
 330     int0_int_disable();
 331     int0_level_set(4);    // INT Priority
 332     int0_edge_pos(); // Positive Edge
 333     // ChangeNotification INT, CN20(RC8), SPI2(Overo) CS0
 334     cnint_int_disable();
 335     CNEN2bits.CN20IE = 1;
 336     CNPU2bits.CN20PUE = 1;  // Pullup ON
 337     cnint_level_set(4);
 338
 339
 340     adint_cnt = 0;
 341     ad_cs_dis();
 342     sts_set(STS_NOSYNC);
 343     pps_intf_clear();
 344
 345     // GPS UART1初期設定　BRGH=Standard mode
 346     // 9600bps 8bit nonparity 1stop nonflowcnt.
 347     //                           5432109876543210
 348     unsigned int U1MODEvalue = 0b1000100000000000;
 349     unsigned int U1STAvalue =  0b0000010000000000;
 350 //    OpenUART1( U1MODEvalue, U1STAvalue, baudrate1);
 351     uart1_init( U1MODEvalue, U1STAvalue, baudrate1);
 352     // DEBUG UART2初期設定　BRGH=Standard mode
 353     // 9600bps 8bit nonparity 1stop nonflowcnt.
 354     //                           5432109876543210
 355     unsigned int U2MODEvalue = 0b1000100000000000;
 356     unsigned int U2STAvalue =  0b0000010000000000;
 357     uart2_init( U2MODEvalue, U2STAvalue, baudrate2);
 358
 359
 360     spi1_init();
 361     spi2_init();
 362     spi1_int_disable();
 363     spi2_int_disable();
 364
 365     PDEBUG("START\r\n");
 366     puts("START debug\r\n");
 367     sprintf(sz, "RPINR20=%04X\r\n", RPINR20);
 368     PDEBUG(sz);
 369     sprintf(sz, "SPI1CON1=%04X\r\n", SPI1CON1);
 370     PDEBUG(sz);
 371     sprintf(sz, "SPI1CON2=%04X\r\n", SPI1CON2);
 372     PDEBUG(sz);
 373     sprintf(sz, "SPI1STAT=%04X\r\n", SPI1STAT);
 374     PDEBUG(sz);
 375
 376     // GPS UART1 受信割り込み許可
 377     uart1_rx_int_enable();
 378     uart1_set_int_level(4);  // 割り込みレベル　デフォルト4
 379     // DebugOut UART2 受信割り込み許可
 380     uart2_rx_int_enable();
 381     uart2_set_int_level(4);  // 割り込みレベル　デフォルト4
 382
 383     //**** 割り込み許可 **************************************************
 384     // CPU割り込み優先レベル デフォルト0　ペリフェラルはデフォルト4
 385 //    SRbits.IPL = 2;
 386     SET_CPU_IPL( 2 );
 387
 388     // UBXプロトコルのみにする
 389     ublox_rcvbuf_clear();
 390     ublox_send_cfg_prt(BAUDRATE1);
 391     ublox_rcv_ack();
 392     // TimePulse2にAD用クロック出力する
 393     ublox_rcvbuf_clear();
 394     ublox_send_cfg_tp5_timepulse2();
 395     ublox_rcv_ack();
 396     // NAV-TIMEUTC出力させる
 397     ublox_send_cfg_msg();
 398     ublox_rcv_ack();
 399
 400     // AD初期化
 401     ad_reset_dis();
 402     ad_start_dis();
 403     ad_cs_dis();
 404     //
 405     ad_reset(); // -AD RESET
 406     // WAIT 2^16 AD system clocks
 407     delay_ms(100);
 408     //
 409     ad_cs_init();
 410     ad_init();
 411     pga_init();
 412
 413     ring_init();
 414     // AD SPI1　割り込み設定のみ　許可しない
 415     // INT1ハンドラ内で有効にされる
 416     spi1_intf_clear();
 417     spi1_set_int_level(4);
 418
 419     // INT1割り込み許可
 420     int1_intf_clear();
 421     int1_int_enable();    // Int enable
 422     // INT0割り込み許可
 423     int0_intf_clear();
 424     int0_int_enable();    // Int enable
 425     // DataOut SPI2　割り込み許可しない CSのCN INTで許可するので
 426     spi2_intf_clear();
 427     spi2_set_int_level(4);
 428 //    spi2_int_enable();
 429     // ChangeNotification INT許可 SPI2(Overo) CS
 430     cnint_intf_clear();
 431     cnint_int_enable();
 432 /****!!!!!!!!!!!!!!!!!!!!!!!!*/
 433 //    test_spi_flag();
 434 test_spi_send();
 435
 436     while(1) {
 437         // GPSから受信してデコード
 438         ublox_rcv();
 439         if (gpsNow.valid == 0x07 && sts_get() == STS_NOSYNC) {
 440             // 時刻有効
 441             sts_set(STS_SYNCNOW0);
 442         }
 443         if (ring_read_get() != ring_write_get()) {
 444             // タイムスタンプget
 445             gps = adbuf_time_get(ring_read_get());
 446             sprintf(sz, "%04u/%02d/%02d %02d:%02d:%02d.%09ld,%6lums,%6luns,%02X",
 447                 gps->year, gps->month, gps->day, gps->hour, gps->min, gps->sec, gps->nano,
 448                 gps->tow, gps->tacc, gps->valid
 449             );
 450             PDEBUG(sz);
 451
 452 #if 1
 453             // AD data get
 454             char ch;
 455             long    *lp;
 456             lp = adbuf_1sec_get(ring_read_get());
 457             for(ch=0; ch<AD_CHNUM; ch++) {
 458                 sprintf(sz, ",%+7ld", lp[ch]);
 459                 PDEBUG(sz);
 460             }
 461             PDEBUG("\r\n");
 462 #endif
 463             ring_read_plus();
 464         }
 465     }
 466 /*
 467         if (pps_is_intf_enable()) {
 468             pps_intf_clear();
 469             PDEBUG("pps\r\n");
 470         }
 471     i = 0;
 472     while(1) {
 473         if (ring_read_get() != ring_write_get()) {
 474             char ch;
 475             for(ch=0; ch<AD_CHNUM; ch++) {
 476                 sprintf(sz, "%+7ld,", adbuf_1sec[ring_read_get()][ch]);
 477                 PDEBUG(sz);
 478             }
 479             PDEBUG("\r\n");
 480
 481             ring_read_plus();
 482         }
 483     }
 484 */
 485
 486     return (EXIT_SUCCESS);
 487 }
 488 /*
 489  * INT0 GPS 1PPS割り込みハンドラ
 490  *
 491  *
 492  */
 493 void __attribute__((interrupt, no_auto_psv)) _INT0Interrupt(void)
 494 {
 495     // AD STARTピン=H
 496     ad_start_ena();
 497
 498     int0_intf_clear();
 499     pps_intf_set();
 500     /****AD同期!!!!!!!!!!!!!!!*/
 501     // AD個数カウンタ=SAMP_FREQ-1
 502     adint_cnt = AD_SAMPLE - 1;
 503
 504     // ADバッファにタイムスタンプ付ける
 505     adbuf_time_write(ring_read_get(), &gpsNow);
 506
 507     // AD START信号による同期
 508     if (sts_get() == STS_SYNCNOW0) {
 509         // AD STARTピン=L
 510         ad_start_dis();
 511         sts_set(STS_SYNCNOW1);
 512     } else if (sts_get() == STS_SYNCNOW1) {
 513         // AD STARTピン=H
 514 //        ad_start_ena();
 515         sts_set(STS_SYNCWAIT);
 516     } else if (sts_get() == STS_SYNCWAIT) {
 517         sts_set(STS_SYNCED);
 518     }
 519 }
 520
 521 /*
 522  * INT1(RP12) AD DRDY0割り込みハンドラ
 523  * Negativ Edge
 524  * SPI1受信開始してSPI1割り込み有効にする
 525  *
 526  */
 527 void __attribute__((interrupt, no_auto_psv)) _INT1Interrupt(void)
 528 //void _ISR _INT1Interrupt(void)
 529 {
 530     int1_intf_clear();
 531     if (!ad_is_drdy0_enable()) {
 532         return;
 533     }
 534
 535     adint_ch = 0;
 536     adint_sts = ADSTS_H;
 537     if (adint_cnt == 0) {
 538         my_memset(adint_add, 0, sizeof(adint_add));
 539     }
 540
 541     ad_cs(adint_ch);    // CSx=L
 542     spi1_rx_overrun_clear();
 543     // 前に受信したデータをクリア
 544     spi1_getc();
 545     // SPI割り込みON
 546     spi1_intf_clear();
 547     spi1_int_enable();
 548     // 送信
 549     spi1_putc(0);
 550 }
 551 /*
 552  * AD SPI1 Interrupt Handler
 553  * ADから受信したデータをADバッファに格納する
 554  * 6CHぶん受信したらSPI1割り込みをOFF
 555  *
 556  */
 557 //void _ISR _SPI1Interrupt(void)
 558 void __attribute__((interrupt, auto_psv)) _SPI1Interrupt(void)
 559 {
 560     static unsigned char in[3];
 561     unsigned char c;
 562     long    l;
 563
 564     spi1_intf_clear();
 565     c = spi1_getc();
 566     spi1_rx_overrun_clear();
 567 //spi1_int_disable();
 568 //ad_cs_dis();
 569 //return;
 570 //c=1;
 571     switch(adint_sts) {
 572         case ADSTS_H:
 573             in[2] = c;
 574             adint_sts = ADSTS_M;
 575             spi1_putc(0);
 576             break;
 577         case ADSTS_M:
 578             in[1] = c;
 579             adint_sts = ADSTS_L;
 580             spi1_putc(0);
 581             break;
 582         case ADSTS_L:
 583             // CSx=H
 584             ad_cs_dis();
 585             in[0] = c;
 586             l = byte3_to_long(in);
 587             // バッファに書きこみ
 588             adbuf_write(ring_write_get(), adint_ch, adint_cnt, &l);
 589             // 1秒平均用加算
 590             adint_add[adint_ch] += l;
 591             // CH進める
 592             adint_ch++;
 593             if (adint_ch >= AD_CHNUM) {
 594                 // 全CHデータgetした
 595                 adint_cnt++;
 596                 if (adint_cnt >= AD_SAMPLE) {
 597                     // 1secぶんのデータgetした
 598                     // 平均してバッファに書きこみ
 599                     char ch;
 600                     for(ch = 0; ch < AD_CHNUM; ch++) {
 601                         adint_add[ch] /= adint_cnt;
 602                     }
 603                     // バッファに書きこみ
 604                     adbuf_1sec_write(ring_write_get(), adint_add);
 605                     // バッファ書き込み位置＋１
 606                     ring_write_plus();
 607                     adint_cnt = 0;
 608                 }
 609                 spi1_int_disable(); // SPI割り込みOFF
 610                 adint_sts = ADSTS_IDLE;
 611             } else {
 612                 // 次のCHへ
 613                 ad_cs(adint_ch);    // CSx=L
 614                 // 送信
 615                 spi1_putc(0);
 616                 adint_sts = ADSTS_H;
 617             }
 618
 619             break;
 620         default:
 621             spi1_int_disable(); // SPI割り込みOFF
 622             adint_sts = ADSTS_IDLE;
 623             break;
 624     }
 625
 626 }
 627
 628 /*
 629  * DataOut SPI2 Interrupt Handler
 630  * TX FIFOに1byteの空きが出来ると発生
 631  */
 632 static unsigned char   spi2c;
 633 void __attribute__((interrupt, auto_psv)) _SPI2Interrupt(void)
 634 {
 635     unsigned char   rx;
 636     static unsigned int txlen = 512;
 637     spi2_intf_clear();
 638 #if 1
 639 //    static unsigned char   c=0;
 640     while(!spi2_tx_fifo_is_full())
 641         spi2_putc(spi2c++);
 642     while(!spi2_rx_fifo_is_empty()) {
 643         rx = spi2_getc();
 644 //        if (rx == '$') c = 0;
 645     }
 646 #endif
 647 #if 0
 648     //spi2c = 123;
 649 // RX FIFOから読み出し
 650 //    while(!spi2_rx_fifo_is_empty() || (!spi2_tx_fifo_is_full() && txlen > 0)) {
 651     while(!spi2_rx_fifo_is_empty()) {
 652         if (!spi2_rx_fifo_is_empty()) {
 653             rx = spi2_getc();
 654             if (rx == '$') {
 655                 spi2c = 0;
 656                 txlen = 3;
 657             }
 658         }
 659         // TX FIFOに書き込み
 660         if (!spi2_tx_fifo_is_full()) {
 661             if (txlen > 0) {
 662                 spi2_putc(spi2c++);
 663                 txlen--;
 664             }
 665         }
 666     }
 667 #endif
 668     // オーバーランエラーならばクリアする
 669     // spi2_rx_is_overrun()
 670     if (SPI2STATbits.SPIROV == 1) SPI2STATbits.SPIROV = 0;
 671
 672     // TODO:Interrupt Flag@IEC Clear
 673 }
 674 /*
 675  * Overo SPI2 CS Input Change Notification
 676  * Interrupt Handler
 677  *
 678  */
 679 #define SPI2CSpin  (PORTCbits.RC8)
 680 void __attribute__((interrupt, auto_psv)) _CNInterrupt(void)
 681 {
 682     cnint_intf_clear();
 683     if (SPI2CSpin == 1) {
 684         // CS=H
 685         // SPI2割り込みOFF
 686         spi2_int_disable();
 687
 688     } else {
 689         // CS=L
 690     // SPI送信の一番最初なので
 691     spi2c = 0;
 692
 693 // SPI2 RX FIFOクリア
 694 // SPI2 TX FIFOクリア
 695 // リングバッファ読み込み位置get?
 696 // SPI2 TX FIFOに送信データ書き込み?
 697         // SPI2割り込みON
 698         spi2_int_enable();
 699     }
 700 }
 701 /*
 702  * CS0〜15順番にenable
 703  */
 704 void test_ad_cs()
 705 {
 706     int i;
 707
 708     while(1) {
 709         delay_ms(1000);
 710         ad_cs(i);
 711         i++;
 712         if (i >= 16) i = 0;
 713     }
 714 }
 715
 716 /*
 717  Dataout SPI2 test
 718  */
 719 void test_spi2()
 720 {
 721     unsigned int    c = 0x12;
 722     unsigned int    rx;
 723     unsigned int    sts = 0;
 724     int i;
 725
 726     i = SPI2BUF;
 727     while(1) {
 728         PORTCbits.RC9 = 1;
 729         delay_ms(100);
 730         PORTCbits.RC9 = 0;
 731         delay_ms(900);
 732
 733 //        while(spi2_tx_fifo_is_full());
 734 //        spi2_putc(c++);
 735 //        while(spi2_rx_fifo_is_empty());
 736 //        rx = spi2_getc();
 737 #if 0
 738         while(spi2STATbits.SPIRBF == 0);
 739         sts = spi2STAT;
 740         if (spi2STATbits.SPITBF == 0) {
 741             spi2BUF = c++;
 742         }
 743 //        while(spi2STATbits.SPIRBF == 1) {
 744             i = spi2BUF;
 745 //        }
 746         if (i == '$') {
 747             c = 0;
 748         }
 749         if (spi2STATbits.SPIROV == 1) spi2STATbits.SPIROV = 0;
 750         sprintf(sz, "%d %04X\r\n", i, sts);
 751         PDEBUG(sz);
 752 #endif
 753 //        while(spi2STATbits.SPITBF == 1);
 754 //        while(spi2STATbits.SPITBF);
 755 /*
 756          while(!spi2_tx_fifo_is_full())
 757             spi2_putc(c++);
 758         while(!spi2_rx_fifo_is_empty()) {
 759             rx = spi2_getc();
 760             if (rx == '$') c = 0;
 761         }
 762 */
 763         //        i = ReadUART1();
 764 //        WriteUART2(i);
 765
 766 //        PDEBUG(mes);
 767 //        delay();
 768     }
 769 }
 770 /*
 771 void test_ad1()
 772 {
 773         unsigned char in[3];
 774         long l[6];
 775         char cs;
 776         while(!ad_is_drdy0_enable());
 777 //        PDEBUG("AD\r\n");
 778         for(cs=0; cs<6; cs++) {
 779             ad_cs(cs);
 780                 in[2] = ad_spi_rcv();
 781                 in[1] = ad_spi_rcv();
 782                 in[0] = ad_spi_rcv();
 783             ad_cs_dis();
 784             l[cs] = byte3_to_long(in);
 785 //            sprintf(sz, "%02X %02X %02X", in[2], in[1], in[0]);
 786 //            PDEBUG(sz);
 787         }
 788         for(cs=0; cs<6; cs++) {
 789             sprintf(sz, "%+7ld,", l[cs]);
 790             PDEBUG(sz);
 791         }
 792         PDEBUG("\r\n");
 793
 794 }
 795  */