void MSC_ActiveDMA(uint32_t u32Addr, uint32_t u32Len)
{
/* Enable BUS interrupt */
UBSD_ENABLE_BUS_INT(USBD_BUSINTEN_DMADONEIEN_Msk|USBD_BUSINTEN_SUSPENDIEN_Msk|USBD_BUSINTEN_RSTIEN_Msk|USBD_BUSINTEN_VBUSDETIEN_Msk);
USBD_SET_DMA_ADDR(u32Addr);
USBD_SET_DMA_LEN(u32Len);
g_usbd_DmaDone = 0;
USBD_ENABLE_DMA();
while(g_u8MscStart) {
if (g_usbd_DmaDone)
break;
if (!USBD_IS_ATTACHED())
break;
}
}
void MSC_ReceiveCBW(uint32_t u32Buf)
{
uint32_t volatile i, receive_len;
uint8_t *ptr = (uint8_t *)u32Buf;
/* bulk out, dma write, epnum = 2 */
USBD_SET_DMA_WRITE(BULK_OUT_EP_NUM);
/* disable buffer */
g_u8MscOutShortPacket = 1;
USBD->EPBRSPCTL = USBD_EPRSPCTL_DISBUF_Msk;
UBSD_ENABLE_EP_INT(EPB, USBD_EPINTEN_SHORTRXIEN_Msk);
/* Enable BUS interrupt */
UBSD_ENABLE_BUS_INT(USBD_BUSINTEN_DMADONEIEN_Msk|USBD_BUSINTEN_SUSPENDIEN_Msk|USBD_BUSINTEN_RSTIEN_Msk|USBD_BUSINTEN_VBUSDETIEN_Msk);
USBD_SET_DMA_ADDR(u32Buf);
USBD_SET_DMA_LEN(EPB_MAX_PKT_SIZE);
g_usbd_DmaDone = 0;
USBD_ENABLE_DMA();
while(g_u8MscStart) {
if (g_u8MscOutShortPacket == 0)
break;
if (!USBD_IS_ATTACHED())
break;
}
/* get data from FIFO */
receive_len = USBD->EPBDATCNT & 0xffff;
if (receive_len == 31) {
if (g_u8BulkState == BULK_OUT)
g_u8BulkState = BULK_CBW;
}
for (i=0; i<receive_len; i++)
*(ptr+i) = USBD->EPBDAT_BYTE;
// reset DMA
USBD->DMACTL = 0x80;
USBD->DMACTL = 0x00;
USBD->EPBRSPCTL = 0;
}
/*---------------------------------------------------------------------------------------------------------*/
int32_t main (void)
{
sysInitializeUART();
sysprintf("\n");
sysprintf("=========================\n");
sysprintf(" NUC970 USB VCOM \n");
sysprintf("=========================\n");
sysDisableCache();
sysInvalidCache();
sysSetMMUMappingMethod(MMU_DIRECT_MAPPING);
sysEnableCache(CACHE_WRITE_BACK);
sysInstallISR(HIGH_LEVEL_SENSITIVE|IRQ_LEVEL_1, USBD_IRQn, (PVOID)USBD_IRQHandler);
/* enable CPSR I bit */
sysSetLocalInterrupt(ENABLE_IRQ);
USBD_Open(&gsInfo, VCOM_ClassRequest, NULL);
/* Endpoint configuration */
VCOM_Init();
sysEnableInterrupt(USBD_IRQn);
/* Start transaction */
while(1) {
if (USBD_IS_ATTACHED()) {
USBD_Start();
break;
}
}
while(1) {
VCOM_TransferData();
}
}
/*--------------------------------------------------------------------------*/
void USBD_IRQHandler(void)
{
uint32_t u32IntSts = USBD_GET_INT_FLAG();
uint32_t u32State = USBD_GET_BUS_STATE();
//------------------------------------------------------------------
if (u32IntSts & USBD_INTSTS_FLDET)
{
// Floating detect
USBD_CLR_INT_FLAG(USBD_INTSTS_FLDET);
if (USBD_IS_ATTACHED())
{
/* USB Plug In */
USBD_ENABLE_USB();
}
else
{
/* USB Un-plug */
USBD_DISABLE_USB();
}
}
//------------------------------------------------------------------
if (u32IntSts & USBD_INTSTS_BUS)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_BUS);
if (u32State & USBD_STATE_USBRST)
{
/* Bus reset */
USBD_ENABLE_USB();
USBD_SwReset();
}
if (u32State & USBD_STATE_SUSPEND)
{
/* Enable USB but disable PHY */
USBD_DISABLE_PHY();
}
if (u32State & USBD_STATE_RESUME)
{
/* Enable USB and enable PHY */
USBD_ENABLE_USB();
}
}
//------------------------------------------------------------------
if(u32IntSts & USBD_INTSTS_WAKEUP)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_WAKEUP);
}
if (u32IntSts & USBD_INTSTS_USB)
{
// USB event
if (u32IntSts & USBD_INTSTS_SETUP)
{
// Setup packet
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_SETUP);
/* Clear the data IN/OUT ready flag of control end-points */
USBD_STOP_TRANSACTION(EP0);
USBD_STOP_TRANSACTION(EP1);
USBD_ProcessSetupPacket();
}
// EP events
if (u32IntSts & USBD_INTSTS_EP0)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP0);
// control IN
USBD_CtrlIn();
}
if (u32IntSts & USBD_INTSTS_EP1)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP1);
// control OUT
USBD_CtrlOut();
}
if (u32IntSts & USBD_INTSTS_EP2)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP2);
}
if (u32IntSts & USBD_INTSTS_EP3)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP3);
// Bulk Out -> receive printer data
PTR_Data_Receive();
}
if (u32IntSts & USBD_INTSTS_EP4)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP4);
}
if (u32IntSts & USBD_INTSTS_EP5)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP5);
// Interrupt IN
EP5_Handler();
}
if (u32IntSts & USBD_INTSTS_EP6)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP6);
// Interrupt OUT
EP6_Handler();
}
if (u32IntSts & USBD_INTSTS_EP7)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP7);
}
}
}
void USBD_IRQHandler(void)
{
uint32_t u32IntSts = USBD_GET_INT_FLAG();
uint32_t u32State = USBD_GET_BUS_STATE();
//------------------------------------------------------------------
if (u32IntSts & USBD_INTSTS_FLDET)
{
// Floating detect
USBD_CLR_INT_FLAG(USBD_INTSTS_FLDET);
if (USBD_IS_ATTACHED())
{
/* USB Plug In */
USBD_ENABLE_USB();
}
else
{
/* USB Un-plug */
USBD_DISABLE_USB();
}
}
//------------------------------------------------------------------
if (u32IntSts & USBD_INTSTS_BUS)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_BUS);
if (u32State & USBD_STATE_USBRST)
{
/* Bus reset */
USBD_ENABLE_USB();
USBD_SwReset();
}
if (u32State & USBD_STATE_SUSPEND)
{
/* Enable USB but disable PHY */
USBD_DISABLE_PHY();
}
if (u32State & USBD_STATE_RESUME)
{
/* Enable USB and enable PHY */
USBD_ENABLE_USB();
}
}
//------------------------------------------------------------------
if(u32IntSts & USBD_INTSTS_WAKEUP)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_WAKEUP);
}
if (u32IntSts & USBD_INTSTS_USB)
{
extern uint8_t g_usbd_SetupPacket[];
// USB event
if (u32IntSts & USBD_INTSTS_SETUP)
{
// Setup packet
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_SETUP);
/* Clear the data IN/OUT ready flag of control end-points */
USBD_STOP_TRANSACTION(EP0);
USBD_STOP_TRANSACTION(EP1);
USBD_ProcessSetupPacket();
}
// EP events
if (u32IntSts & USBD_INTSTS_EP0)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP0);
// control IN
USBD_CtrlIn();
}
if (u32IntSts & USBD_INTSTS_EP1)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP1);
// control OUT
USBD_CtrlOut();
if(g_usbd_SetupPacket[1] == SET_LINE_CODE)
{
if(g_usbd_SetupPacket[4] == 0) /* VCOM-1 */
VCOM_LineCoding(0); /* Apply UART settings */
}
}
if (u32IntSts & USBD_INTSTS_EP2)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP2);
// Bulk IN
EP2_Handler();
}
if (u32IntSts & USBD_INTSTS_EP3)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP3);
// Bulk OUT
EP3_Handler();
}
if (u32IntSts & USBD_INTSTS_EP4)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP4);
}
if (u32IntSts & USBD_INTSTS_EP5)
{
/* Clear event flag */
USBD_CLR_INT_FLAG(USBD_INTSTS_EP5);
// Interrupt IN
EP5_Handler();
}
}
}
/**
* USB virtual COM interrupt handler.
* This is an internal function.
*/
static void USB_VirtualCOM_IRQHandler() {
uint32_t intSts, busState;
intSts = USBD_GET_INT_FLAG();
busState = USBD_GET_BUS_STATE();
if(intSts & USBD_INTSTS_FLDET) {
if(USBD_IS_ATTACHED()) {
// USB plugged in
USBD_ENABLE_USB();
}
else {
// USB unplugged
USBD_DISABLE_USB();
}
}
else if(intSts & USBD_INTSTS_BUS) {
if(busState & USBD_STATE_USBRST) {
// Bus reset
USBD_ENABLE_USB();
USBD_SwReset();
}
else if(busState & USBD_STATE_SUSPEND) {
// Suspend: USB enabled, PHY disabled
USBD_DISABLE_PHY();
}
else if(busState & USBD_STATE_RESUME) {
// Resume: USB enabled, PHY enabled
USBD_ENABLE_USB();
}
}
else if(intSts & USBD_INTSTS_USB) {
if(intSts & USBD_INTSTS_SETUP) {
// Clear IN/OUT data ready flag for control endpoints
USBD_STOP_TRANSACTION(USB_VCOM_CTRL_IN_EP);
USBD_STOP_TRANSACTION(USB_VCOM_CTRL_OUT_EP);
// Handle setup packet
USBD_ProcessSetupPacket();
}
else if(intSts & USB_VCOM_CTRL_IN_INTSTS) {
// Handle control IN
USBD_CtrlIn();
}
else if(intSts & USB_VCOM_CTRL_OUT_INTSTS) {
// Handle control OUT
USBD_CtrlOut();
}
else if(intSts & USB_VCOM_BULK_IN_INTSTS) {
// Handle bulk IN
USB_VirtualCOM_HandleBulkIn();
}
else if(intSts & USB_VCOM_BULK_OUT_INTSTS) {
// Handle bulk OUT
USB_VirtualCOM_HandleBulkOut();
}
}
// Clear flag
USBD_CLR_INT_FLAG(intSts);
}
void USBD_IRQHandler(void)
{
__IO uint32_t IrqStL, IrqSt;
IrqStL = USBD->GINTSTS & USBD->GINTEN; /* get interrupt status */
if (!IrqStL) return;
/* USB interrupt */
if (IrqStL & USBD_GINTSTS_USBIF_Msk) {
IrqSt = USBD->BUSINTSTS & USBD->BUSINTEN;
if (IrqSt & USBD_BUSINTSTS_SOFIF_Msk)
USBD_CLR_BUS_INT_FLAG(USBD_BUSINTSTS_SOFIF_Msk);
if (IrqSt & USBD_BUSINTSTS_RSTIF_Msk) {
USBD_SwReset();
g_u8MscStart = 0;
g_u8BulkState = BULK_NORMAL;
USBD_ResetDMA();
USBD->EPARSPCTL = USBD_EPRSPCTL_FLUSH_Msk;
USBD->EPBRSPCTL = USBD_EPRSPCTL_FLUSH_Msk;
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_SETUPPKIEN_Msk);
USBD_SET_ADDR(0);
UBSD_ENABLE_BUS_INT(USBD_BUSINTEN_RSTIEN_Msk|USBD_BUSINTEN_RESUMEIEN_Msk|USBD_BUSINTEN_SUSPENDIEN_Msk);
USBD_CLR_BUS_INT_FLAG(USBD_BUSINTSTS_RSTIF_Msk);
USBD_CLR_CEP_INT_FLAG(0x1ffc);
}
if (IrqSt & USBD_BUSINTSTS_RESUMEIF_Msk) {
UBSD_ENABLE_BUS_INT(USBD_BUSINTEN_RSTIEN_Msk|USBD_BUSINTEN_SUSPENDIEN_Msk);
USBD_CLR_BUS_INT_FLAG(USBD_BUSINTSTS_RESUMEIF_Msk);
}
if (IrqSt & USBD_BUSINTSTS_SUSPENDIF_Msk) {
UBSD_ENABLE_BUS_INT(USBD_BUSINTEN_RSTIEN_Msk | USBD_BUSINTEN_RESUMEIEN_Msk);
USBD_CLR_BUS_INT_FLAG(USBD_BUSINTSTS_SUSPENDIF_Msk);
}
if (IrqSt & USBD_BUSINTSTS_HISPDIF_Msk) {
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_SETUPPKIEN_Msk);
USBD_CLR_BUS_INT_FLAG(USBD_BUSINTSTS_HISPDIF_Msk);
}
if (IrqSt & USBD_BUSINTSTS_DMADONEIF_Msk) {
g_usbd_DmaDone = 1;
USBD_CLR_BUS_INT_FLAG(USBD_BUSINTSTS_DMADONEIF_Msk);
if (!(USBD->DMACTL & USBD_DMACTL_DMARD_Msk)) {
// if (g_u8BulkState == BULK_OUT)
// g_u8BulkState = BULK_CBW;
UBSD_ENABLE_EP_INT(EPB, USBD_EPINTEN_RXPKIEN_Msk);
}
if (USBD->DMACTL & USBD_DMACTL_DMARD_Msk) {
if (g_usbd_ShortPacket == 1) {
USBD->EPARSPCTL = USB_EP_RSPCTL_SHORTTXEN; // packet end
g_usbd_ShortPacket = 0;
}
}
}
if (IrqSt & USBD_BUSINTSTS_PHYCLKVLDIF_Msk)
USBD_CLR_BUS_INT_FLAG(USBD_BUSINTSTS_PHYCLKVLDIF_Msk);
if (IrqSt & USBD_BUSINTSTS_VBUSDETIF_Msk) {
if (USBD_IS_ATTACHED()) {
/* USB Plug In */
USBD_ENABLE_USB();
} else {
/* USB Un-plug */
USBD_DISABLE_USB();
}
USBD_CLR_BUS_INT_FLAG(USBD_BUSINTSTS_VBUSDETIF_Msk);
}
}
if (IrqStL & USBD_GINTSTS_CEPIF_Msk) {
IrqSt = USBD->CEPINTSTS & USBD->CEPINTEN;
if (IrqSt & USBD_CEPINTSTS_SETUPTKIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_SETUPTKIF_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_SETUPPKIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_SETUPPKIF_Msk);
USBD_ProcessSetupPacket();
return;
}
if (IrqSt & USBD_CEPINTSTS_OUTTKIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_OUTTKIF_Msk);
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_STSDONEIEN_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_INTKIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_INTKIF_Msk);
if (!(IrqSt & USBD_CEPINTSTS_STSDONEIF_Msk)) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_TXPKIF_Msk);
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_TXPKIEN_Msk);
USBD_CtrlIn();
} else {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_TXPKIF_Msk);
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_TXPKIEN_Msk|USBD_CEPINTEN_STSDONEIEN_Msk);
}
return;
}
if (IrqSt & USBD_CEPINTSTS_PINGIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_PINGIF_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_TXPKIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_STSDONEIF_Msk);
USBD_SET_CEP_STATE(USB_CEPCTL_NAKCLR);
if (g_usbd_CtrlInSize) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_INTKIF_Msk);
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_INTKIEN_Msk);
} else {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_STSDONEIF_Msk);
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_SETUPPKIEN_Msk|USBD_CEPINTEN_STSDONEIEN_Msk);
}
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_TXPKIF_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_RXPKIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_RXPKIF_Msk);
USBD_SET_CEP_STATE(USB_CEPCTL_NAKCLR);
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_SETUPPKIEN_Msk|USBD_CEPINTEN_STSDONEIEN_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_NAKIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_NAKIF_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_STALLIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_STALLIF_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_ERRIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_ERRIF_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_STSDONEIF_Msk) {
USBD_UpdateDeviceState();
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_STSDONEIF_Msk);
UBSD_ENABLE_CEP_INT(USBD_CEPINTEN_SETUPPKIEN_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_BUFFULLIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_BUFFULLIF_Msk);
return;
}
if (IrqSt & USBD_CEPINTSTS_BUFEMPTYIF_Msk) {
USBD_CLR_CEP_INT_FLAG(USBD_CEPINTSTS_BUFEMPTYIF_Msk);
return;
}
}
/* bulk in */
if (IrqStL & USBD_GINTSTS_EPAIF_Msk) {
IrqSt = USBD->EPAINTSTS & USBD->EPAINTEN;
UBSD_ENABLE_EP_INT(EPA, 0);
USBD_CLR_EP_INT_FLAG(EPA, IrqSt);
}
/* bulk out */
if (IrqStL & USBD_GINTSTS_EPBIF_Msk) {
IrqSt = USBD->EPBINTSTS & USBD->EPBINTEN;
if (IrqSt & USBD_EPINTSTS_SHORTRXIF_Msk)
g_u8MscOutShortPacket = 0;
UBSD_ENABLE_EP_INT(EPB, 0);
USBD_CLR_EP_INT_FLAG(EPB, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPCIF_Msk) {
IrqSt = USBD->EPCINTSTS & USBD->EPCINTEN;
USBD_CLR_EP_INT_FLAG(EPC, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPDIF_Msk) {
IrqSt = USBD->EPDINTSTS & USBD->EPDINTEN;
USBD_CLR_EP_INT_FLAG(EPD, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPEIF_Msk) {
IrqSt = USBD->EPEINTSTS & USBD->EPEINTEN;
USBD_CLR_EP_INT_FLAG(EPE, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPFIF_Msk) {
IrqSt = USBD->EPFINTSTS & USBD->EPFINTEN;
USBD_CLR_EP_INT_FLAG(EPF, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPGIF_Msk) {
IrqSt = USBD->EPGINTSTS & USBD->EPGINTEN;
USBD_CLR_EP_INT_FLAG(EPG, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPHIF_Msk) {
IrqSt = USBD->EPHINTSTS & USBD->EPHINTEN;
USBD_CLR_EP_INT_FLAG(EPH, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPIIF_Msk) {
IrqSt = USBD->EPIINTSTS & USBD->EPIINTEN;
USBD_CLR_EP_INT_FLAG(EPI, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPJIF_Msk) {
IrqSt = USBD->EPJINTSTS & USBD->EPJINTEN;
USBD_CLR_EP_INT_FLAG(EPJ, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPKIF_Msk) {
IrqSt = USBD->EPKINTSTS & USBD->EPKINTEN;
USBD_CLR_EP_INT_FLAG(EPK, IrqSt);
}
if (IrqStL & USBD_GINTSTS_EPLIF_Msk) {
IrqSt = USBD->EPLINTSTS & USBD->EPLINTEN;
USBD_CLR_EP_INT_FLAG(EPL, IrqSt);
}
}
//=============================================================================
//----- (00004B34) ------------------------------------------------------------
// Called at 100Hz
__myevic__ void GetUserInput()
{
UserInputs = 14;
if ( !PE0 && PD2 && PD3 )
{
UserInputs = 1;
}
else
{
if ( gFlags.firing )
{
if ( LastInputs == 1 )
StopFire();
gFlags.user_idle = 1;
LastInputs = -1;
KeyPressTime = 0;
return;
}
if ( !FireClickTimer && FireClicksEvent )
{
Event = FireClicksEvent;
FireClicksEvent = 0;
}
if ( !(dfStatus.off) || Screen == 59 )
{
if ( !PD2 ) UserInputs = 2;
if ( !PD3 ) UserInputs = 3;
}
if ( !PD2 && !PD3 ) UserInputs = 4;
if ( !PE0 && !PD2 ) UserInputs = 5;
if ( !PE0 && !PD3 ) UserInputs = 6;
if ( USBD_IS_ATTACHED() )
{
if ( !(gFlags.usb_attached) )
{
UserInputs = 10;
byte_20000048 = 0;
}
}
else
{
if ( gFlags.usb_attached )
{
UserInputs = 11;
}
}
if ( gFlags.usb_attached )
{
if ( !PD7 && !(gFlags.battery_charging) )
{
if ( !byte_20000048 || byte_20000048 >= 50 )
{
UserInputs = 12;
byte_20000048 = 0;
}
}
else if ( PD7 && gFlags.battery_charging )
{
UserInputs = 13;
byte_20000048 = 1;
}
}
}
if ( UserInputs >= 14 )
{
if ( LastInputs == 1 )
StopFire();
gFlags.user_idle = 1;
LastInputs = -1;
KeyPressTime = 0;
return;
}
if ( UserInputs != LastInputs )
{
LastInputs = UserInputs;
KeyPressTime = 0;
gFlags.user_idle = 0;
return;
}
++KeyPressTime;
// A keypress must be stable during at least
// 60 milliseconds before an event is emitted.
if ( KeyPressTime == 6 )
{
gFlags.user_idle = 0;
if ( UserInputs == 4
|| UserInputs == 5
|| UserInputs == 6
|| UserInputs == 7
|| UserInputs == 8
|| UserInputs == 9
)
return;
Event = UserInputs;
if ( UserInputs == 1 )
{
FireClickTimer = 40;
++FireClickCount;
FireClicksEvent = 0;
Event = 0;
if ( FireClickCount == 1 )
{
FireClicksEvent = 15; // single click
if ( !EditModeTimer || EditItemIndex != 4 )
{
Event = 1; // fire
}
}
else if ( FireClickCount == 2 )
{
FireClicksEvent = EVENT_DOUBLE_FIRE; // show date
}
else if ( FireClickCount == 3 )
{
FireClicksEvent = 16; // edit mode
}
else if ( FireClickCount == 4 )
{
FireClicksEvent = EVENT_QUAD_FIRE; // debug mode
}
else if ( FireClickCount == 5 )
{
FireClicksEvent = 17; // Switch On/Off
}
else if ( FireClickCount == 10 )
{
FireClicksEvent = 31; // board temp screen
}
else if ( FireClickCount == 20 )
{
Event = 29; // firmware version screen
}
}
else if ( UserInputs == 2 )
{
if ( dfStatus.keylock && !EditModeTimer
&& Screen != 51 && Screen != 59 && Screen != 82 && Screen != 83
&& Screen < 100 )
{
Event = 30; // key lock violation
}
else
{
Event = 2; // + button
}
}
else if ( UserInputs == 3 )
{
if ( dfStatus.keylock && !EditModeTimer
&& Screen != 51 && Screen != 59 && Screen != 82 && Screen != 83
&& Screen < 100 )
{
Event = 30; // key lock violation
}
else
{
Event = 3; // - button
}
}
}
else if ( KeyPressTime == 20 )
{
if ( UserInputs == 1 )
{
FireClicksEvent = 0;
}
}
else if ( KeyPressTime == 200 )
{
if ( UserInputs == 1 )
{
if ( Screen == 59 )
{
UpdateDataFlash();
gFlags.refresh_display = 1;
Screen = 0;
}
}
else if ( UserInputs == 4 )
{
if ( !EditModeTimer )
{
if ( dfStatus.off )
Event = 18; // flip display
else
Event = 4; // key (un)lock
}
else
{
EditModeTimer = 1000;
if ( EditItemIndex == 4 )
{
if ( dfAPT == 1 )
Event = 22; // puff reset
if ( dfAPT == 2 )
Event = 23; // time reset
}
}
}
else if ( UserInputs == 5 )
{
MenuPage = 1;
if ( !(dfStatus.off) )
{
if ( !(gFlags.playing_fb) )
{
Event = EVENT_ENTER_MENUS; // new menus
// Event = 40; // old menus
}
else
{
gFlags.playing_fb = 0;
Event = -1;
fbInitTimeouts();
MainView();
}
}
}
else if ( UserInputs == 6 )
{
if ( !(dfStatus.off) )
{
Event = 6; // stealth on/off
}
}
}
else if ( KeyPressTime == 500 )
{
if ( UserInputs == 5 )
{
if ( dfStatus.off )
{
Event = 39; // tcr set menu
}
}
else if ( UserInputs == 6 )
{
if ( dfStatus.off )
{
Event = 34; // battery voltage screen
}
}
}
else if ( ( KeyPressTime & 0x8000 ) || ( KeyPressTime & 0x7fff ) >= 210 )
{
if ( UserInputs == 1 )
{
if ( KeyPressTime > 1100 )
{
KeyPressTime = 1100;
gFlags.user_idle = 1;
}
else if ( FireDuration > 99 )
{
Event = 24; // 10s protection
}
}
else if ( KeyPressTime & 0x8000 )
{
KeyPressTime = 6;
}
}
}
