//********************************************************************************
/*
　　＜簡易ＡＤロガー(FAT32)Ｖ２＞ 
　・アナログ入力８チャネル 
　・ＳＤＣ(FAT32) 
*/
//********************************************************************************
#define BYTE    unsigned        short
#define WORD    unsigned        int
#define DWORD   unsigned        long
//
#define FAT32
//
#ifdef  FAT32
#include "__Lib_FAT32.h"
#endif
//
sbit    SW_START        at      RA7_bit;
sbit    SW_STOP         at      RA6_bit;
//
sbit    SW_MODE_0       at      RB4_bit;
sbit    SW_MODE_1       at      RB5_bit;
sbit    SW_MODE_2       at      RB6_bit;
sbit    SW_MODE_3       at      RB7_bit;
//
sbit    LED             at      RB0_bit;
//********************************************************************************
extern  void    main();
extern  void    measurement();
//
extern  void    init_osc();
extern  void    init_port();
extern  void    init_comparator();
extern  void    init_adc();
extern  void    init_sdc_fat32();
extern  void    init_sdc();
extern  void    init_timer();
//
extern  DWORD   get_clock();
extern  void    set_clock(DWORD clock);
extern  void    clock2str(DWORD clock, char *str);
extern  void    clock2timedate(DWORD clock, __TIME *tm);
extern  long    wait_trigger(short mode);
extern  WORD    ADC_Get_Sample_Average(BYTE channel, short sampling_count);
extern  short   get_cycle_mode();
extern  short   get_average_cnt();
//********************************************************************************
char    buf[64];
char    *file_name = "log_0000.txt";
WORD    file_id = 0;
#ifdef  FAT32
__HANDLE        fileHandle;
__TIME          TimeDate;
#endif
//********************************************************************************
//■メイン関数 
void    main()
{
        DWORD   clock;
        short   cnt;
        //
        init_osc();
        init_comparator();
        init_port();
        init_adc();
#ifdef  FAT32
        init_sdc_fat32();
#else
        init_sdc();
#endif
        init_timer();
        //
        for (cnt = 0; cnt < 3; cnt++) {
                LED = 1;
                Delay_ms(500);
                LED = 0;
                Delay_ms(500);
        }
        //
        while (1) {
                if (SW_START != 0) {
                        continue;
                }
                //
                LED = 1;
                //
                file_id++;
                WordToStr(file_id, buf);
                file_name[4] = (buf[1] == ' ') ? '0' : buf[1];
                file_name[5] = (buf[2] == ' ') ? '0' : buf[2];
                file_name[6] = (buf[3] == ' ') ? '0' : buf[3];
                file_name[7] = (buf[4] == ' ') ? '0' : buf[4];
#ifdef  FAT32
                clock2timedate(get_clock(), &TimeDate);
                FAT32_SetTime(&TimeDate);
                FAT32_Delete(file_name);
                fileHandle = FAT32_Open(file_name, FILE_WRITE);
                FAT32_Write(fileHandle, "$START\r\n", 8);
#else
                Mmc_Fat_Assign(file_name, 0);
                Mmc_Fat_Delete();
                Mmc_Fat_Set_File_Date(2012, 12, 27, 12, 34, 56);
                Mmc_Fat_Assign(file_name, 0xA0);
                Mmc_Fat_Rewrite();
                Mmc_Fat_Write("$START\r\n", 8);
#endif
                measurement();
#ifdef  FAT32
                FAT32_Write(fileHandle, "$STOP\r\n", 7);
                FAT32_Close(fileHandle);
#else
                Mmc_Fat_Write("$STOP\r\n", 7);
#endif
                LED = 0;
        }
}
//********************************************************************************
void    measurement()
{
        double  ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8;
        long    clock;
        short   cnt;
        //
        cnt = get_average_cnt();
        //
        while (SW_STOP != 0) {
                clock = wait_trigger(get_cycle_mode());
                if (clock == -1) {
                        break;
                }
                //
                clock2str(clock, buf);
                //
                ch1 = ADC_Get_Sample_Average(0, cnt);
                ch2 = ADC_Get_Sample_Average(1, cnt);
                ch3 = ADC_Get_Sample_Average(2, cnt);
                ch4 = ADC_Get_Sample_Average(3, cnt);
                ch5 = ADC_Get_Sample_Average(4, cnt);
                ch6 = ADC_Get_Sample_Average(8, cnt);
                ch7 = ADC_Get_Sample_Average(9, cnt);
                ch8 = ADC_Get_Sample_Average(10, cnt);
                //
                ch1 *= 0.8056640625;
                ch2 *= 0.8056640625;
                ch3 *= 0.8056640625;
                ch4 *= 0.8056640625;
                ch5 *= 0.8056640625;
                ch6 *= 0.8056640625;
                ch7 *= 0.8056640625;
                ch8 *= 0.8056640625;
                //
                WordToStr(ch1, &buf[12]);
                WordToStr(ch2, &buf[17]);
                WordToStr(ch3, &buf[22]);
                WordToStr(ch4, &buf[27]);
                WordToStr(ch5, &buf[32]);
                WordToStr(ch6, &buf[37]);
                WordToStr(ch7, &buf[42]);
                WordToStr(ch8, &buf[47]);
                buf[52] = '\r';
                buf[53] = '\n';
                //
#ifdef  FAT32
                FAT32_Write(fileHandle, buf, 54);
#else
                Mmc_Fat_Write(buf, 54);
#endif
        }
}
//********************************************************************************
short   get_cycle_mode()
{
        if ((SW_MODE_1 == 0) && (SW_MODE_0 == 0)) {
                return (0);
        }
        if ((SW_MODE_1 == 0) && (SW_MODE_0 == 1)) {
                return (1);
        }
        if ((SW_MODE_1 == 1) && (SW_MODE_0 == 0)) {
                return (2);
        }
        if ((SW_MODE_1 == 1) && (SW_MODE_0 == 1)) {
                return (3);
        }
}
//********************************************************************************
short   get_average_cnt()
{
        if ((SW_MODE_3 == 0) && (SW_MODE_2 == 0)) {
                return (1);
        }
        if ((SW_MODE_3 == 0) && (SW_MODE_2 == 1)) {
                return (10);
        }
        if ((SW_MODE_3 == 1) && (SW_MODE_2 == 0)) {
                return (100);
        }
        if ((SW_MODE_3 == 1) && (SW_MODE_2 == 1)) {
                return (100);
        }
}
//********************************************************************************
long    wait_trigger(short mode)
{
        long    clock;
        //
        switch (mode) {
        case 0: //100msec
                while (1) {
                        clock = get_clock();
                        if ((clock % 10) == 0) {
                                return(clock);
                        }
                        if (SW_STOP == 0) {
                                return(-1);
                        }
                }
                break;
        case 1: //1sec
                while (1) {
                        clock = get_clock();
                        if ((clock % 100) == 0) {
                                return(clock);
                        }
                        if (SW_STOP == 0) {
                                return(-1);
                        }
                }
                break;
        case 2: //1min
                while (1) {
                        clock = get_clock();
                        if ((clock % 6000) == 0) {
                                return(clock);
                        }
                        if (SW_STOP == 0) {
                                return(-1);
                        }
                }
                break;
        case 3: //10min
                while (1) {
                        clock = get_clock();
                        if ((clock % 60000) == 0) {
                                return(clock);
                        }
                        if (SW_STOP == 0) {
                                return(-1);
                        }
                }
                break;
        }
        return (-1);
}
//********************************************************************************
WORD    ADC_Get_Sample_Average(BYTE channel, short sampling_count)
{
        int     cnt;
        DWORD   ad;
        //
        ad = 0;
        for (cnt = 0; cnt < sampling_count; cnt++) {
                ad += ADC_Get_Sample(channel);
        }
        return (ad / sampling_count);
}
//********************************************************************************
void    clock2str(DWORD clock, char *str) //"00:00:00:000"
{
        BYTE    hh, mm, ss, ms;
        char    tmp[4];
        //
        hh = (clock % 8640000) / 360000;
        mm = (clock % 360000) / 6000;
        ss = (clock % 6000) / 100;
        ms = clock % 100;
        //
        ByteToStr(hh, tmp);
        str[0] = (tmp[1] == ' ') ? '0' : tmp[1];
        str[1] = tmp[2];
        str[2] = ':';
        ByteToStr(mm, tmp);
        str[3] = (tmp[1] == ' ') ? '0' : tmp[1];
        str[4] = tmp[2];
        str[5] = ':';
        ByteToStr(ss, tmp);
        str[6] = (tmp[1] == ' ') ? '0' : tmp[1];
        str[7] = tmp[2];
        str[8] = ':';
        ByteToStr(ms, tmp);
        str[9] = (tmp[1] == ' ') ? '0' : tmp[1];
        str[10] = tmp[2];
        str[11] = '0';
        str[12] = 0x00;
}
//********************************************************************************
void    clock2timedate(DWORD clock, __TIME *tm)
{
        tm->Year   = 2012;
        tm->Month  = 12;
        tm->Day    = 27;
        tm->Hour   = (clock % 8640000) / 360000;
        tm->Minute = (clock % 360000) / 6000;
        tm->Second = (clock % 6000) / 100;
}
//********************************************************************************
DWORD   clock = 0;
DWORD   clock_tmp = 0;
short   clock_flg = 0;
//
void    interrupt()
{
        if (PIR1.CCP1IF == 1) {
                PIR1.CCP1IF = 0;
                //
                clock++;
                switch (clock_flg) {
                case 1:
                        clock_flg = 0;
                        clock_tmp = clock;
                        break;
                case 2:
                        clock_flg = 0;
                        clock = clock_tmp;
                        break;
                }
        }
}
//********************************************************************************
DWORD   get_clock()
{
        clock_flg = 1;
        while (clock_flg == 1) {
        }
        return (clock_tmp);
}
//********************************************************************************
void    set_clock(DWORD clock)
{
        clock_tmp = clock;
        clock_flg = 2;
        while (clock_flg == 2) {
        }
}
//********************************************************************************
//■周期割り込み設定関数(10msec) 
void    init_timer()
{
        // CCPの設定
        PIE1.CCP1IE = 1;
        PIR1.CCP1IF = 0;
        CCP1CON.CCP1M3 = 1;
        CCP1CON.CCP1M2 = 0;
        CCP1CON.CCP1M1 = 1;
        CCP1CON.CCP1M0 = 1;
        CCPR1L = 0x10;        // 10msec...クロックが32Mhzの時
        CCPR1H = 0x27;        // 10msec...(1÷32000000)*4*8*10000(0x2710)
        // TIMER1の設定
        PIE1.TMR1IE = 0;
        PIR1.TMR1IF = 0;
        TMR1L = 0;
        TMR1H = 0;
        T1CON.TMR1CS = 0;
        T1CON.T1CKPS0 = 1;
        T1CON.T1CKPS1 = 1;
        T1CON.TMR1ON = 1;
        //
        INTCON.PEIE = 1;
        INTCON.GIE = 1;
}
//********************************************************************************
//■ＳＤＣを初期化する関数です。 
#ifdef  FAT32
sfr  sbit  Mmc_Chip_Select            at  RC2_bit;
sfr  sbit  Mmc_Chip_Select_Direction  at  TRISC2_bit;
//
void    init_sdc_fat32()
{
        SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV64, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
        while (FAT32_Init() < 0) {
                LED = 1;
                Delay_ms(50);
                LED = 0;
                Delay_ms(50);
        }
        SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV4, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
}
#endif
//********************************************************************************
//■ＳＤＣを初期化する関数です。 
#ifdef  FAT16
sfr  sbit  Mmc_Chip_Select            at  RC2_bit;
sfr  sbit  Mmc_Chip_Select_Direction  at  TRISC2_bit;
//
void    init_sdc()
{
        //ＳＤＣ（ＭＭＣ）の初期化 
        SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV64, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
        if (Mmc_Fat_Init()) {
                while (1) {
                        LED = 1;
                        Delay_ms(50);
                        LED = 0;
                        Delay_ms(50);
                }
        }        
        SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV16, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
}
#endif
//********************************************************************************
void    init_osc()
{
        OSCCON.IRCF2 = 1;
        OSCCON.IRCF1 = 1;
        OSCCON.IRCF0 = 1;
        OSCTUNE.PLLEN = 1;
}
//********************************************************************************
void    init_adc()
{
        ADCON1.PCFG3 = 0;
        ADCON1.PCFG2 = 1;
        ADCON1.PCFG1 = 0;
        ADCON1.PCFG0 = 0;
        ADCON1.VCFG1 = 0;
        ADCON1.VCFG0 = 0;
        //
        ADC_Init();
}
//********************************************************************************
void    init_port()
{
        TRISA = 0b11111111;
        TRISB = 0b11111110;
        TRISC = 0b11111111;
        //
        LED = 0;
}
//********************************************************************************
void    init_comparator()
{
        CMCON.CM2 = 1;
        CMCON.CM1 = 1;
        CMCON.CM0 = 1;
}
//********************************************************************************