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