static int int_gpio_negedge_set_status( elua_int_resnum resnum, int status )
{
unsigned long portbase = pio_base[ PLATFORM_IO_GET_PORT( resnum ) ];
u8 pinmask = 1 << PLATFORM_IO_GET_PIN( resnum );
int prev = int_gpio_posedge_get_status( resnum );
int crtstat = inth_gpio_get_int_status( resnum );
if( status == PLATFORM_CPU_ENABLE )
{
// If already configured for rising edge, set both edges
// Otherwise set only negedge
if( crtstat & GPIO_INT_POSEDGE_ENABLED )
HWREG( portbase + GPIO_O_IBE ) |= pinmask;
else
HWREG( portbase + GPIO_O_IEV ) &= ( u8 )~pinmask;
MAP_GPIOPinIntEnable( portbase, pinmask );
}
else
{
// If configured for both, enable only rising edge
// Otherwise disable interrupts completely
if( crtstat == GPIO_INT_BOTH_ENABLED )
{
HWREG( portbase + GPIO_O_IBE ) &= ( u8 )~pinmask;
HWREG( portbase + GPIO_O_IEV ) |= pinmask;
}
else if( crtstat == GPIO_INT_NEGEDGE_ENABLED )
MAP_GPIOPinIntDisable( portbase, pinmask );
}
return prev;
}
void task_ads()
{
if(HWREGBITW(&g_ulFlags, FLAG_ADS_INT) == 1)
{
HWREGBITW(&g_ulFlags, FLAG_ADS_INT) = 0;
ADS_START_CLR();
Ads_Read();
ADS_START();
ROM_GPIOPinIntClear(ADS_DRY_PORT, 0xff);
MAP_IntEnable(INT_GPIOC);
MAP_GPIOPinIntEnable(ADS_DRY_PORT, ADS_DRY_PIN);
}
}
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();
}
void systick_init()
{
//
// Configure SysTick for a periodic interrupt.
//
MAP_SysTickPeriodSet(MAP_SysCtlClockGet() / SYSTICKHZ);
MAP_SysTickEnable();
MAP_SysTickIntEnable();
//MAP_IntEnable(INT_GPIOA);
MAP_IntEnable(INT_GPIOE);
MAP_IntMasterEnable();
MAP_SysCtlPeripheralClockGating(false);
MAP_GPIOIntTypeSet(GPIO_PORTE_BASE, ENC_INT, GPIO_FALLING_EDGE);
MAP_GPIOPinIntClear(GPIO_PORTE_BASE, ENC_INT);
MAP_GPIOPinIntEnable(GPIO_PORTE_BASE, ENC_INT);
UARTprintf("int enabled\n");
}
void pio_init()
{
// Board Initialization start
//
//
// The FPU should be enabled because some compilers will use floating-
// point registers, even for non-floating-point code. If the FPU is not
// enabled this will cause a fault. This also ensures that floating-
// point operations could be added to this application and would work
// correctly and use the hardware floating-point unit. Finally, lazy
// stacking is enabled for interrupt handlers. This allows floating-
// point instructions to be used within interrupt handlers, but at the
// expense of extra stack usage.
//
FPUEnable();
FPULazyStackingEnable();
//Init the device with 16 MHz clock.
initClk();
/* Configure the system peripheral bus that IRQ & EN pin are map to */
MAP_SysCtlPeripheralEnable( SYSCTL_PERIPH_IRQ_PORT);
//
// Disable all the interrupts before configuring the lines
//
MAP_GPIOPinIntDisable(SPI_GPIO_IRQ_BASE, 0xFF);
//
// Cofigure WLAN_IRQ pin as input
//
MAP_GPIOPinTypeGPIOInput(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN);
GPIOPadConfigSet(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
//
// Setup the GPIO interrupt for this pin
//
MAP_GPIOIntTypeSet(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN, GPIO_FALLING_EDGE);
//
// Configure WLAN chip
//
MAP_GPIOPinTypeGPIOOutput(SPI_GPIO_IRQ_BASE, SPI_EN_PIN);
MAP_GPIODirModeSet( SPI_GPIO_IRQ_BASE, SPI_EN_PIN, GPIO_DIR_MODE_OUT );
MAP_GPIOPadConfigSet( SPI_GPIO_IRQ_BASE, SPI_EN_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD );
MAP_GPIOPinWrite(SPI_GPIO_IRQ_BASE, SPI_EN_PIN, PIN_LOW);
SysCtlDelay(600000);
SysCtlDelay(600000);
SysCtlDelay(600000);
//
// Disable WLAN CS with pull up Resistor
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI_PORT);
MAP_GPIOPinTypeGPIOOutput(SPI_CS_PORT, SPI_CS_PIN);
GPIOPadConfigSet(SPI_CS_PORT, SPI_CS_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOPinWrite(SPI_CS_PORT, SPI_CS_PIN, PIN_HIGH);
//
// Enable interrupt for WLAN_IRQ pin
//
MAP_GPIOPinIntEnable(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN);
//
// Clear interrupt status
//
SpiCleanGPIOISR();
MAP_IntEnable(INT_GPIO_SPI);
//init LED
initLEDs();
}
void WlanInterruptEnable()
{
MAP_GPIOPinIntEnable(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN);
}
void main(void) {
static struct uip_eth_addr eth_addr;
uip_ipaddr_t ipaddr;
cpu_init();
uart_init();
printf("Welcome\n");
spi_init();
enc28j60_comm_init();
printf("Welcome\n");
enc_init(mac_addr);
//
// Configure SysTick for a periodic interrupt.
//
MAP_SysTickPeriodSet(MAP_SysCtlClockGet() / SYSTICKHZ);
MAP_SysTickEnable();
MAP_SysTickIntEnable();
//MAP_IntEnable(INT_GPIOA);
MAP_IntEnable(INT_GPIOE);
MAP_IntMasterEnable();
MAP_SysCtlPeripheralClockGating(false);
printf("int enabled\n");
MAP_GPIOIntTypeSet(GPIO_PORTE_BASE, ENC_INT, GPIO_FALLING_EDGE);
MAP_GPIOPinIntClear(GPIO_PORTE_BASE, ENC_INT);
MAP_GPIOPinIntEnable(GPIO_PORTE_BASE, ENC_INT);
uip_init();
eth_addr.addr[0] = mac_addr[0];
eth_addr.addr[1] = mac_addr[1];
eth_addr.addr[2] = mac_addr[2];
eth_addr.addr[3] = mac_addr[3];
eth_addr.addr[4] = mac_addr[4];
eth_addr.addr[5] = mac_addr[5];
uip_setethaddr(eth_addr);
#define DEFAULT_IPADDR0 10
#define DEFAULT_IPADDR1 0
#define DEFAULT_IPADDR2 0
#define DEFAULT_IPADDR3 201
#define DEFAULT_NETMASK0 255
#define DEFAULT_NETMASK1 255
#define DEFAULT_NETMASK2 255
#define DEFAULT_NETMASK3 0
#undef STATIC_IP
#ifdef STATIC_IP
uip_ipaddr(ipaddr, DEFAULT_IPADDR0, DEFAULT_IPADDR1, DEFAULT_IPADDR2,
DEFAULT_IPADDR3);
uip_sethostaddr(ipaddr);
printf("IP: %d.%d.%d.%d\n", DEFAULT_IPADDR0, DEFAULT_IPADDR1,
DEFAULT_IPADDR2, DEFAULT_IPADDR3);
uip_ipaddr(ipaddr, DEFAULT_NETMASK0, DEFAULT_NETMASK1, DEFAULT_NETMASK2,
DEFAULT_NETMASK3);
uip_setnetmask(ipaddr);
#else
uip_ipaddr(ipaddr, 0, 0, 0, 0);
uip_sethostaddr(ipaddr);
printf("Waiting for IP address...\n");
uip_ipaddr(ipaddr, 0, 0, 0, 0);
uip_setnetmask(ipaddr);
#endif
httpd_init();
#ifndef STATIC_IP
dhcpc_init(mac_addr, 6);
dhcpc_request();
#endif
long lPeriodicTimer, lARPTimer;
lPeriodicTimer = lARPTimer = 0;
int i; // = MAP_GPIOPinRead(GPIO_PORTA_BASE, ENC_INT) & ENC_INT;
while(true) {
//MAP_IntDisable(INT_UART0);
MAP_SysCtlSleep();
//MAP_IntEnable(INT_UART0);
//i = MAP_GPIOPinRead(GPIO_PORTA_BASE, ENC_INT) & ENC_INT;
/*while(i != 0 && g_ulFlags == 0) {
i = MAP_GPIOPinRead(GPIO_PORTA_BASE, ENC_INT) & ENC_INT;
}*/
if( HWREGBITW(&g_ulFlags, FLAG_ENC_INT) == 1 ) {
HWREGBITW(&g_ulFlags, FLAG_ENC_INT) = 0;
enc_action();
}
if(HWREGBITW(&g_ulFlags, FLAG_SYSTICK) == 1) {
HWREGBITW(&g_ulFlags, FLAG_SYSTICK) = 0;
lPeriodicTimer += SYSTICKMS;
lARPTimer += SYSTICKMS;
//printf("%d %d\n", lPeriodicTimer, lARPTimer);
}
if( lPeriodicTimer > UIP_PERIODIC_TIMER_MS ) {
lPeriodicTimer = 0;
int l;
for(l = 0; l < UIP_CONNS; l++) {
uip_periodic(l);
//
// If the above function invocation resulted in data that
// should be sent out on the network, the global variable
// uip_len is set to a value > 0.
//
if(uip_len > 0) {
uip_arp_out();
enc_send_packet(uip_buf, uip_len);
uip_len = 0;
}
}
for(l = 0; l < UIP_UDP_CONNS; l++) {
uip_udp_periodic(l);
if( uip_len > 0) {
uip_arp_out();
enc_send_packet(uip_buf, uip_len);
uip_len = 0;
}
}
}
if( lARPTimer > UIP_ARP_TIMER_MS) {
lARPTimer = 0;
uip_arp_timer();
}
}
}
BOOL ds1390_init(void)
{
//BOOL b_init=false;
//unsigned char test;
unsigned BOOL time_error = TRUE;
DS1390_DATA_BUF ds1390_data_buf;
DS1390_TIME ds1390_temp;
dbg_printf("Initializing DS1390u...");
g_ds1390_spi_bitrate = DS1390_BITRATE;
/*
//Пробуем писать и читать
for (int i=0; i<10; i++)
{
ds1390_wr_b(DS1390_REG_ALARM_100THS, 0x5A);
if (ds1390_rd_b(DS1390_REG_ALARM_100THS) != 0x5A)
{
continue;
//dbg_puts("[false]");
//return (BOOL)FALSE;
}
else
{
b_init = true;
break;
}
}
////////
if (!b_init)
{
dbg_puts("[false]");
return (BOOL)FALSE;
}
*/
//////////
ds1390_rd((unsigned char*)&ds1390_data_buf);
/*
do
{
test = ds1390_data_buf.sec;
ds1390_rd((unsigned char*)&ds1390_data_buf);
}
while(test != ds1390_data_buf.sec);
*/
if (ds1390_data_buf.control & 0x18)
{
dbg_printf("first start...");
ds1390_wr_b(DS1390_REG_CONTROL, 0x00);
time_error = FALSE;
}
if (ds1390_data_buf.status & 0x80)
{
dbg_printf("the clock was stoped...");
ds1390_wr_b(DS1390_REG_STATUS, 0x00); // запустим часики
time_error = FALSE;
}
if (time_BCD_to_char(&ds1390_data_buf , &ds1390_temp))
{
ds1390_time_true = TRUE;
}else
{
ds1390_time_true = FALSE;
time_error = FALSE;
}
if (!time_error)
{
dbg_printf("reset time to 1.1.2014-00:00:00...");
ds1390_temp.msec = 0;
ds1390_temp.sec = 0;
ds1390_temp.min = 0;
ds1390_temp.hour = 0;
ds1390_temp.date = 1;
ds1390_temp.month = 1;
ds1390_temp.year = 2014;
SetTime_DS1390(&ds1390_temp);
}
if (ds1390_data_buf.trickle_charger != 0xA9)
ds1390_wr_b(DS1390_REG_TRICKLE, 0xA9); // включим подзарядку батарейки
// Настроить прерывания на DS1390
MAP_IntEnable(INT_GPIOA);
MAP_GPIOIntTypeSet(GPIO_PORTA_BASE, GPIO_PIN_7, GPIO_RISING_EDGE);
MAP_GPIOPinIntEnable(GPIO_PORTA_BASE, GPIO_PIN_7);
dbg_puts("[done]");
return (BOOL)TRUE;
}
