// init one call
void light_init(void)
{
dbg_printf("Initializing LIGHT...");
pin_on(OPIN_TR_EN );//включить выходные регистры
LIGHT_STA=LIGHT_WORK;// machine stat
light_machine.work = FALSE; // stop machine
//
setStatusRestart(true);// перезагрузка
//
BOOL is_init;
dk_num=0;
//
GREEN_PORT_CONF = 0;
RED_PORT_CONF = 0;
YEL_PORT_CONF = 0;
//
for (int i_dk=0; i_dk<DK_N; i_dk++)
{
CUR_DK = i_dk;
for (int i_try=0; i_try<3; i_try++)
{
is_init = ligh_load_init(2-i_try);
if (is_init)
{
dk_num++;
break;
}
}
//
if (!is_init)
break;
}
if (dk_num)
light_machine.work = TRUE; // start machine
/*create event*/
if (tn_event_create(&g_light_evt, TN_EVENT_ATTR_SINGLE | TN_EVENT_ATTR_CLR, 0) != TERR_NO_ERR){
dbg_puts("tn_event_create(&g_light_evt) error");
dbg_trace();
tn_halt();
}
/*create task_light_func*/
if (tn_task_create(&task_light_tcb, &task_light_func, TASK_LIGHT_PRI,
&task_light_stk[TASK_LIGHT_STK_SZ - 1], TASK_LIGHT_STK_SZ, 0,
TN_TASK_START_ON_CREATION) != TERR_NO_ERR){
dbg_puts("tn_task_create(&task_light_tcb) error");
dbg_trace();
tn_halt();
}
dbg_puts("[done]");
}
void hw_timer0a_init(TN_EVENT* evt, unsigned evt_pattern)
{
if (evt == NULL || evt_pattern == 0)
{
dbg_puts("evt == NULL || evt_pattern == 0");
dbg_trace();
tn_halt();
}
g_timer0a_evt = evt;
g_timer0a_evt_pattern = evt_pattern;
// TIMER_0_A32
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
MAP_SysCtlPeripheralReset(SYSCTL_PERIPH_TIMER0);
MAP_TimerDisable(TIMER0_BASE, TIMER_A);
MAP_TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER); // periodic mode
MAP_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//MAP_IntPrioritySet(INT_TIMER0A, 0); // 0 - max pri 7 - min pri
MAP_IntEnable(INT_TIMER0A);
/*
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER3);
MAP_TimerDisable(TIMER3_BASE, TIMER_A);
MAP_TimerConfigure(TIMER3_BASE, TIMER_CFG_32_BIT_OS);
MAP_TimerEnable(TIMER3_BASE, TIMER_A);
*/
}
/*-----------------------Start system-----------------------------------------*/
void tn_app_init()
{
tn_cpu_int_disable(); // прерывания включаются обратно после выхода из tn_app_init();
// start
startup();
// for static IP
struct ip_addr ipaddr = { pref_get_long(PREF_L_NET_IP) };
struct ip_addr netmask = { pref_get_long(PREF_L_NET_MSK) };
struct ip_addr gw = { pref_get_long(PREF_L_NET_GW) };
//ip_addr_debug_print(buf, ipaddr);
ethernet_init((enum net_mode)pref_get_long(PREF_L_NET_MODE), &ipaddr, &netmask, &gw);
cmd_ch_init(); // init cmd for ethernet
// creat task_leds_func
if (tn_task_create(&task_leds_tcb, &task_leds_func, TASK_LEDS_PRI, &task_leds_stk[TASK_LEDS_STK_SZ - 1],
TASK_LEDS_STK_SZ, 0, TN_TASK_START_ON_CREATION) != TERR_NO_ERR)
{
dbg_puts("tn_task_create(&task_leds_tcb) error");
goto err;
}
//time_init=true;
return;
err:
dbg_trace();
tn_halt();
}
void hw_timer0a_set_timeout(unsigned long uS)
{
#ifdef DEBUG
if (uS > 1000000)
{
dbg_puts("uS > 1000000");
dbg_trace();
tn_halt();
}
#endif // DEBUG
MAP_TimerLoadSet(TIMER0_BASE, TIMER_A, MAP_SysCtlClockGet() / 1000000 * uS);
}
void hw_timer1a_start_once(unsigned long uS)
{
#ifdef DEBUG
if (uS > 1000000)
{
dbg_puts("uS > 1000000");
dbg_trace();
tn_halt();
}
#endif // DEBUG
MAP_TimerLoadSet(TIMER1_BASE, TIMER_A, MAP_SysCtlClockGet() / 1000000 * uS);
MAP_TimerEnable(TIMER1_BASE, TIMER_A);
}
/*----------------------------------------------------------------------------*/
void hw_watchdog_int_handler()
{
//MAP_WatchdogIntClear(WATCHDOG0_BASE);
if (g_watchdog_clear)
{
MAP_WatchdogIntClear(WATCHDOG0_BASE);
g_watchdog_clear = FALSE;
}else
{
#ifdef DEBUG
dbg_trace();
#endif // DEBUG
tn_reset();
}
}
void GPS_init()
{
dbg_printf("Initializing GPS module...");
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART);
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
MAP_UARTConfigSetExpClk(UART_BASE, MAP_SysCtlClockGet(), UART_SPEED, UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE);
MAP_UARTDisable(UART_BASE);
MAP_UARTTxIntModeSet(UART_BASE, UART_TXINT_MODE_EOT);
MAP_UARTIntEnable(UART_BASE, UART_INT_RX | UART_INT_TX);
MAP_IntEnable(INT_UART);
MAP_UARTEnable(UART_BASE);
MAP_UARTFIFODisable(UART_BASE);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
//
MAP_IntEnable(INT_GPIOG);
// Настроить прерывания на PPS
MAP_GPIOIntTypeSet(GPIO_PORTG_BASE, GPIO_PIN_7, GPIO_FALLING_EDGE);
MAP_GPIOPinIntEnable(GPIO_PORTG_BASE, GPIO_PIN_7);
//
if (tn_task_create(&task_GPS_tcb, &task_GPS_func, TASK_GPS_PRI,
&task_GPS_stk[TASK_GPS_STK_SZ - 1], TASK_GPS_STK_SZ, 0,
TN_TASK_START_ON_CREATION) != TERR_NO_ERR)
{
dbg_puts("tn_task_create(&task_GPS_tcb) error");
goto err;
}
// Настроить прерывания на PPS
//MAP_IntEnable(INT_GPIOG);
//MAP_GPIOIntTypeSet(GPIO_PORTG_BASE, GPIO_PIN_7, GPIO_FALLING_EDGE);
//MAP_GPIOPinIntEnable(GPIO_PORTG_BASE, GPIO_PIN_7);
dbg_puts("[done]");
return;
err:
dbg_trace();
tn_halt();
}
static void dlt645_DbgOut(uint_t nType, const void *pBuf, uint_t nLen)
{
const uint8_t *pData, *pEnd;
char str[DBG_BUF_SIZE];
pData = (const uint8_t *)pBuf;
pEnd = pData + nLen;
if (nType)
nLen = sprintf(str, "<645T>");
else
nLen = sprintf(str, "<645R>");
while ((pData < pEnd) && (nLen < (sizeof(str) - 3)))
nLen += sprintf(&str[nLen], " %02X", *pData++);
dbg_trace(str);
}
void USBPT_Work()
{
if (USBPT_Has_Dev == 0)
{
if (HCD_IsDeviceConnected(&USB_OTG_Core_host) != 0)
{
USBPT_printf("USBPT Device Connecting \r\n");
if (USBH_Open_Channel( &USB_OTG_Core_host,
&(USBPT_Dev->Control.hc_num_in),
0x80,
USBPT_Dev->device_prop.address, // still 0 at this point
USBPT_Dev->device_prop.speed,
EP_TYPE_CTRL,
USBPT_Dev->Control.ep0size) == HC_OK
&&
USBH_Open_Channel( &USB_OTG_Core_host,
&(USBPT_Dev->Control.hc_num_out),
0x00,
USBPT_Dev->device_prop.address, // still 0 at this point
USBPT_Dev->device_prop.speed,
EP_TYPE_CTRL,
USBPT_Dev->Control.ep0size) == HC_OK
) {
DCD_DevConnect(&USB_OTG_Core_dev);
USBPT_Has_Dev = 1;
}
else
{
dbg_printf(DBGMODE_ERR, "USBPT Unable to allocate control EP HC \r\n");
}
}
else
{
return;
}
}
else
{
if (HCD_IsDeviceConnected(&USB_OTG_Core_host) == 0)
{
USBPT_printf("USBPT Device Disconnecting \r\n");
USBD_DeInit(&USB_OTG_Core_dev);
DCD_DevDisconnect(&USB_OTG_Core_dev);
USBPT_Has_Dev = 0;
for (uint8_t i = 0; i < USBPTH_MAX_LISTENERS; i++)
{
USBH_Free_Channel(&USB_OTG_Core_host, &(USBPTH_Listeners[i].hc));
}
USBH_Free_Channel(&USB_OTG_Core_host, &(USBPT_Dev->Control.hc_num_out));
USBH_Free_Channel(&USB_OTG_Core_host, &(USBPT_Dev->Control.hc_num_in));
}
}
for (uint8_t i = 0; i < USBPTH_MAX_LISTENERS; i++)
{
USBPTH_HC_EP_t* pl = &USBPTH_Listeners[i];
int8_t hc = USBPTH_Listeners[i].hc;
if (hc >= 0) // if listener is actually allocated
{
USBH_EpDesc_TypeDef* epDesc = pl->epDesc;
uint8_t epnum = epDesc->bEndpointAddress;
uint8_t epType = 0;
USBPT_GeneralInDataLen = epDesc->wMaxPacketSize;
// try to send read tokens only on even frames
if (USB_OTG_IsEvenFrame(&USB_OTG_Core_host) == 0) continue;
dbg_trace();
// attempt to start the read, check the read type first
if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_INTR) {
epType = EP_TYPE_INTR;
USBH_InterruptReceiveData(&USB_OTG_Core_host, USBPT_GeneralInData, USBPT_GeneralInDataLen, hc);
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_BULK) {
epType = EP_TYPE_BULK;
USBH_BulkReceiveData(&USB_OTG_Core_host, USBPT_GeneralInData, USBPT_GeneralInDataLen, hc);
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_ISOC) {
epType = EP_TYPE_ISOC;
USBH_IsocReceiveData(&USB_OTG_Core_host, USBPT_GeneralInData, USBPT_GeneralInDataLen, hc);
}
// now we wait for a reply, or maybe there isn't one
USBH_Status status;
char sent = 0;
delay_1ms_cnt = 100;
do
{
URB_STATE us = HCD_GetURB_State(&USB_OTG_Core_host, hc);
if (us == URB_DONE)
{
// data was indeed received
// print it to the serial port for monitoring
USBPT_printf("USBPT:IN:EP0x%02X:", epnum);
for (uint16_t c = 0; c < USBPT_GeneralInDataLen; c++) {
USBPT_printf(" 0x%02X", USBPT_GeneralInData[c]);
}
USBPT_printf("\r\n");
// relay the data to the host
DCD_EP_Tx(&USB_OTG_Core_dev, epnum, USBPT_GeneralInData, USBPT_GeneralInDataLen);
sent = 1;
break;
}
else if (us == URB_ERROR) {
dbg_printf(DBGMODE_ERR, "DataIn Error on EP 0x%02X \r\n", epnum);
break;
}
else if (us == URB_STALL) {
dbg_printf(DBGMODE_ERR, "DataIn Stalled EP 0x%02X \r\n", epnum);
break;
}
else if (us == URB_NOTREADY) {
// NAK, no data
break;
}
}
while (delay_1ms_cnt > 0);
if (delay_1ms_cnt == 0) {
dbg_printf(DBGMODE_ERR, "DataIn Read Timed Out EP 0x%02X \r\n", epnum);
}
}
}
}
void tn_halt()
{
tn_cpu_int_disable();
dbg_trace();
tn_halt_boot();
}
