//C18でコンパイル
/** INCLUDES *******************************************************/
#include "./USB/usb.h"
#include "./USB/usb_function_cdc.h"

#include "HardwareProfile.h"

/** CONFIGURATION **************************************************/
#pragma config CPUDIV = NOCLKDIV
#pragma config USBDIV = OFF
#pragma config FOSC   = HS
#pragma config PLLEN  = ON
#pragma config FCMEN  = OFF
#pragma config IESO   = OFF
#pragma config PWRTEN = OFF
#pragma config BOREN  = ON
#pragma config BORV   = 30
#pragma config WDTEN  = OFF
#pragma config WDTPS  = 32768
#pragma config MCLRE  = OFF
#pragma config HFOFST = OFF
#pragma config STVREN = ON
#pragma config LVP    = OFF
#pragma config XINST  = OFF
#pragma config BBSIZ  = OFF
#pragma config CP0    = OFF
#pragma config CP1    = OFF
#pragma config CPB    = OFF
#pragma config WRT0   = OFF
#pragma config WRT1   = OFF
#pragma config WRTB   = OFF
#pragma config WRTC   = OFF
#pragma config EBTR0  = OFF
#pragma config EBTR1  = OFF
#pragma config EBTRB  = OFF       

/** I N C L U D E S **********************************************************/

#include "GenericTypeDefs.h"
#include "Compiler.h"
#include "usb_config.h"
#include "USB/usb_device.h"
#include "USB/usb.h"

#include "HardwareProfile.h"

#include <delays.h>
#include <timers.h>

/** V A R I A B L E S ********************************************************/
#if defined(__18CXX)
    #pragma udata
#endif

char USB_In_Buffer[64];
char USB_Out_Buffer[64];

char Buffer[5] = {0,0,0,0,0};
char goflag=0;//開始フラグ

/** P R I V A T E  P R O T O T Y P E S ***************************************/
static void InitializeSystem(void);
void ProcessIO(void);
void USBDeviceTasks(void);
void YourHighPriorityISRCode();
void YourLowPriorityISRCode();
void USBCBSendResume(void);
void UserInit(void);
void toHEX(unsigned char data, char *buffer);
void mcp3551_init(void);
long mcp3551_read(void);

/** VECTOR REMAPPING ***********************************************/
#if defined(__18CXX)
	#define REMAPPED_RESET_VECTOR_ADDRESS			0x1000
	#define REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS	0x1008
	#define REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS	0x1018
	#define APP_VERSION_ADDRESS                     0x1016
	#define APP_SIGNATURE_ADDRESS                   0x1006
    #define APP_FIRMWARE_VERSION_MAJOR  1
    #define APP_FIRMWARE_VERSION_MINOR  0
	
	#pragma romdata AppVersionAndSignatureSection = APP_VERSION_ADDRESS
	ROM unsigned char AppVersion[2] = {APP_FIRMWARE_VERSION_MINOR, APP_FIRMWARE_VERSION_MAJOR};
	#pragma romdata AppSignatureSection = APP_SIGNATURE_ADDRESS
	ROM unsigned short int SignaturePlaceholder = 0xFFFF;
	
	#pragma code HIGH_INTERRUPT_VECTOR = 0x08
	void High_ISR (void)
	{
	     _asm goto REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS _endasm
	}
	#pragma code LOW_INTERRUPT_VECTOR = 0x18
	void Low_ISR (void)
	{
	     _asm goto REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS _endasm
	}
	extern void _startup (void);        // See c018i.c in your C18 compiler dir
	#pragma code REMAPPED_RESET_VECTOR = REMAPPED_RESET_VECTOR_ADDRESS
	void _reset (void)
	{
	    _asm goto _startup _endasm
	}
	#pragma code REMAPPED_HIGH_INTERRUPT_VECTOR = REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS
	void Remapped_High_ISR (void)
	{
	     _asm goto YourHighPriorityISRCode _endasm
	}
	#pragma code REMAPPED_LOW_INTERRUPT_VECTOR = REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS
	void Remapped_Low_ISR (void)
	{
	     _asm goto YourLowPriorityISRCode _endasm
	}
	#pragma code
	#pragma interrupt YourHighPriorityISRCode
	void YourHighPriorityISRCode()
	{
        #if defined(USB_INTERRUPT)
	        USBDeviceTasks();
        #endif
	
	}
	#pragma interruptlow YourLowPriorityISRCode
	void YourLowPriorityISRCode(){}

#endif

/** DECLARATIONS ***************************************************/
#if defined(__18CXX)
    #pragma code
#endif
#if defined(__18CXX)
void main(void)
#else
int main(void)
#endif
{   
    InitializeSystem();

    while(1)
    {
        #if defined(USB_INTERRUPT)
            if(USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE))
            {
                USBDeviceAttach();
            }
        #endif

        #if defined(USB_POLLING)
        USBDeviceTasks();
        #endif
        ProcessIO();        
    }
}
static void InitializeSystem(void)
{
    UserInit();
    USBDeviceInit();
}

void UserInit(void)
{
	ANSEL=0x00;
	ANSELH=0x00;
	TRISB=0x20;
	ADCON0=0;
	ADCON1=0x0F;
	mcp3551_init();
}

void ProcessIO(void)
{   
    BYTE numBytesRead;
	char rch,byte_data[3];

    if(USBUSARTIsTxTrfReady())
    {
		BYTE i,j;
		long k;
		unsigned char data,g;
        j=0;
		numBytesRead = getsUSBUSART(USB_Out_Buffer,64);
		if(numBytesRead != 0)
		{
			for(i=0;i<numBytesRead;i++)
			{
				switch(USB_Out_Buffer[i])
				{
					case 'S':
					case 's':
						goflag=0;//停止
						break;
					case 'C':
					case 'c':
						goflag=1;
						break;
					default:
						break;
				}
			}
		}
		if(goflag==1){
			k = mcp3551_read();
			toHEX(k >> 16 & 0xff, Buffer);	//紫外線用
			USB_In_Buffer[j++] = Buffer[0];
			USB_In_Buffer[j++] = Buffer[1];
			toHEX(k >> 8 & 0xff, Buffer);
			USB_In_Buffer[j++] = Buffer[0];
			USB_In_Buffer[j++] = Buffer[1];
			toHEX(k & 0xff, Buffer);
			USB_In_Buffer[j++] = Buffer[0];
			USB_In_Buffer[j++] = Buffer[1];
			USB_In_Buffer[j++] = 0xd;
			USB_In_Buffer[j++] = 0xa;
			if(j>0){
				putUSBUSART(USB_In_Buffer,j);
			}
		}
	}

    CDCTxService();
}
////16進数変換
void toHEX(unsigned char data, char *buffer){
	*buffer = '0' + ((char)(data >> 4) & 0x0F);
	if(((data >> 4) & 0x0F) > 9)
		*buffer += 7;
	buffer++;
	*buffer = '0' + ((char)(data) & 0x0F);
	if(((data) & 0x0F) > 9)
		*buffer += 7;
}

void    mcp3551_init()
{
        CS = 1;
        SCK = 1;
}
//**********************************************************************
long    mcp3551_read()
{
        long    dat;
        short   cnt;
        //
        dat = 0;
        CS = 0;
        while (SDO == 1)
                ;
        for (cnt = 0; cnt < 24; cnt++) {
                SCK = 0;
                SCK = 1;
				Delay10TCYx(10);
                if (PORTBbits.RB5) {
                        dat |= 0x01;
                }
                dat <<= 1;
        }
        CS = 1;
        return (dat & 0b001111111111111111111111);
}

////以下usb関係
void USBCBSuspend(void){}
void USBCBWakeFromSuspend(void){}
void USBCB_SOF_Handler(void){}
void USBCBErrorHandler(void){}
void USBCBCheckOtherReq(void)
{
    USBCheckCDCRequest();
}
void USBCBStdSetDscHandler(void){}
void USBCBInitEP(void)
{
    CDCInitEP();
}
void USBCBSendResume(void)
{
    static WORD delay_count;
    if(USBGetRemoteWakeupStatus() == TRUE) 
    {
        if(USBIsBusSuspended() == TRUE)
        {
            USBMaskInterrupts();
            
            USBCBWakeFromSuspend();
            USBSuspendControl = 0; 
            USBBusIsSuspended = FALSE;
            delay_count = 3600U;        
            do
            {
                delay_count--;
            }while(delay_count);
            
            USBResumeControl = 1;
            delay_count = 1800U;
            do
            {
                delay_count--;
            }while(delay_count);
            USBResumeControl = 0;

            USBUnmaskInterrupts();
        }
    }
}

#if defined(ENABLE_EP0_DATA_RECEIVED_CALLBACK)
void USBCBEP0DataReceived(void)
{
}
#endif

BOOL USER_USB_CALLBACK_EVENT_HANDLER(int event, void *pdata, WORD size)
{
    switch( event )
    {
        case EVENT_TRANSFER:
            break;
        case EVENT_SOF:
            USBCB_SOF_Handler();
            break;
        case EVENT_SUSPEND:
            USBCBSuspend();
            break;
        case EVENT_RESUME:
            USBCBWakeFromSuspend();
            break;
        case EVENT_CONFIGURED: 
            USBCBInitEP();
            break;
        case EVENT_SET_DESCRIPTOR:
            USBCBStdSetDscHandler();
            break;
        case EVENT_EP0_REQUEST:
            USBCBCheckOtherReq();
            break;
        case EVENT_BUS_ERROR:
            USBCBErrorHandler();
            break;
        case EVENT_TRANSFER_TERMINATED:
            break;
        default:
            break;
    }      
    return TRUE; 
}


/** EOF main.c *************************************************/