void setup() {
DDRD |= 0b01000000; // ������� ���������
PORTD &= 0b10111111; // ������� ���������
DDRD |= 0b00100000; // ����� �������
PORTD &= 0b11011111; // ����� �������
DDRD |= 0b00010000; // ��������� ��
PORTD &= 0b11101111; // ��������� ��
DDRD &= 0b11111011; // ������
PORTD |= 0b00000100; // ������
enableIROut(56);
enableIRIn();
//���������� ��� ���� ISCxx
//����������� �� ������������ INT0 �� ������� ������
MCUCR &= ~( (1<<ISC11)|(1<<ISC10)|(1<<ISC01)|(1<<ISC00) );
//��������� ������� ���������� INT0
GICR |= (1<<INT0);
//���������� ���� ����������� ���������� ����������
PT_INIT(&ptIRReceive);
PT_INIT(&ptWaitForTrigger);
PT_INIT(&ptExplode);
PT_INIT(&ptFinder);
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
}
void MNT_init(void)
{
// init state machine
STM_init(&MNT.stm, &init);
// set the door pins direction
CONE_DDR &= ~_BV(CONE_PIN);
// init the cone state with its opposite value to generate the first event
MNT.cone_state = ~(CONE & _BV(CONE_PIN));
// init fifoes
FIFO_init(&MNT.ev_fifo, MNT.ev_buf, NB_EVENTS, sizeof(mnt_event_t));
FIFO_init(&MNT.cmds_fifo, MNT.cmds_buf, NB_CMDS, sizeof(frame_t));
FIFO_init(&MNT.out_fifo, MNT.out_buf, NB_OUT_FR, sizeof(frame_t));
// register to dispatcher
MNT.interf.channel = 7;
MNT.interf.cmde_mask = _CM(FR_TAKE_OFF) | _CM(FR_MINUT_TIME_OUT) | _CM(FR_STATE) | _CM(FR_APPLI_START);
MNT.interf.queue = &MNT.cmds_fifo;
DPT_register(&MNT.interf);
// init threads
PT_INIT(&MNT.pt_chk_time_out);
PT_INIT(&MNT.pt_chk_cmds);
PT_INIT(&MNT.pt_out);
// prevent any time-out
MNT.time_out = TIME_MAX;
MNT.sampling_rate = SAMPLING_START;
// the application start signal shall be received
MNT.started = 0;
}
int main(int argc, char** argv) {
PT_setup();
// Enable multivector interrupts
INTEnableSystemMultiVectoredInt();
// Initialize threads
PT_INIT(&pt_cap);
PT_INIT(&pt_blink);
PT_INIT(&pt_cap_read)
//init the display
tft_init_hw();
tft_begin();
tft_fillScreen(ILI9340_BLACK);
// Set orientation of the display
tft_setRotation(1);
// Set up pins
PerPinSetup();
while(1){
PT_SCHEDULE(protothread_blink(&pt_blink));
PT_SCHEDULE(protothread_cap(&pt_cap));
PT_SCHEDULE(protothread_cap_read(&pt_cap_read));
}
}
void main(void) //using 0
{
EA = 0;
PLLCON&=PLLCON_VAL;//настройка частоты процессора
if(!BUTTON1)
{
SHOW_VOLTAGE=1;
}
Timer1_Initialize(); //таймер шедулера 200Гц
ADC_Initialize();
ChannelsInit();
UART_Init();
WDT_Init(WDT_250);//включить сторожевой таймер
EA=1;
PT_INIT(&pt_display);
PT_INIT(&pt_led);
PT_INIT(&pt_key);
PT_INIT(&pt_blink);
if(!SHOW_VOLTAGE)
{
if(skd.SKD_Set.SKD_Settings.diap_high>=100.0 || skd.SKD_Set.SKD_Settings.diap_low<-100.0) //передвигаем десятичную точку
{
LED_SetPoint(INDICATOR_1,2);
}
else
{
LED_SetPoint(INDICATOR_1,3);
}
LED_Set_Brightness(INDICATOR_1,0);
//LED_Out_Float(INDICATOR_1,0.0);
}
else
{
LED_SetPoint(INDICATOR_1,4);
LED_Set_Brightness(INDICATOR_1,0);
LED_Out_Float(INDICATOR_1,0.0);
}
Protocol_Init();
while(1)
{
LED_Process(&pt_led);
Display_Out_Process(&pt_display);
Keyboard_Process(&pt_key);
ProtoProcess(&pt_proto);
LED_BlinkTask(&pt_blink);
WDT_Clear();
}
}
/*---------------------------------------------------------------------------*/
static struct uip_conn *
connect(u16_t *host, u16_t port)
{
PSOCK_INIT(&s.sin, s.inputbuf, sizeof(s.inputbuf));
PSOCK_INIT(&s.sout, s.inputbuf, sizeof(s.inputbuf));
PT_INIT(&s.inpt);
PT_INIT(&s.outpt);
return tcp_connect(host, uip_htons(port), NULL);
}
void I2C_Init(void)
{
I2CM=1;//ведущий
PT_INIT(&pt_i2c_read_buf);//инициализация дочерних потоков
PT_INIT(&pt_i2c_write_buf);
PT_INIT(&pt_i2c_read_complete);
return;
}
/*---------------------------------------------------------------------------*/
void
psock_init( struct psock *psock, uint8_t *buffer, uint16_t buffersize)
{
psock->state = STATE_NONE;
psock->readlen = 0;
psock->bufptr = (uint8_t*)buffer;
psock->bufsize = buffersize;
buf_setup(&psock->buf, (uint8_t *)buffer, buffersize);
PT_INIT(&psock->pt);
PT_INIT(&psock->psockpt);
}
void setup() {
Serial.begin(9600);
// initalizeServos();
initalizePWM();
// initializeSD();
initalizeOLED();
initalizeMPU();
PT_INIT(&pt1);
PT_INIT(&pt2);
}
/*---------------------------------------------------------------------------*/
void
psock_init(register struct psock *psock, char *buffer, unsigned int buffersize)
{
psock->state = STATE_NONE;
psock->readlen = 0;
psock->bufptr = buffer;
psock->bufsize = buffersize;
buf_setup(&psock->buf, (unsigned char*)buffer, buffersize);
PT_INIT(&psock->pt);
PT_INIT(&psock->psockpt);
}
/*---------------------------------------------------------------------------*/
void
psock_init(struct psock *psock, u8 *buffer, u32 buffersize)
{
psock->state = STATE_NONE;
psock->readlen = 0;
psock->bufptr = buffer;
psock->bufsize = buffersize;
buf_setup(&psock->buf, (u8 *)(buffer), buffersize);
PT_INIT(&psock->pt);
PT_INIT(&psock->psockpt);
}
// basic module initialization
void BSC_init(void)
{
frame_t fr;
// fifoes init
FIFO_init(&BSC.in_fifo, &BSC.in_buf, NB_IN_FRAMES, sizeof(frame_t));
FIFO_init(&BSC.out_fifo, &BSC.out_buf, NB_OUT_FRAMES, sizeof(frame_t));
// thread init
PT_INIT(&BSC.in_pt);
PT_INIT(&BSC.out_pt);
// reset time-out
BSC.time_out = 0;
BSC.is_running = FALSE;
// register own call-back for specific commands
BSC.interf.channel = 0;
BSC.interf.cmde_mask = _CM(FR_NO_CMDE)
| _CM(FR_RAM_READ)
| _CM(FR_RAM_WRITE)
| _CM(FR_EEP_READ)
| _CM(FR_EEP_WRITE)
| _CM(FR_FLH_READ)
| _CM(FR_FLH_WRITE)
| _CM(FR_SPI_READ)
| _CM(FR_SPI_WRITE)
| _CM(FR_WAIT)
| _CM(FR_CONTAINER);
BSC.interf.queue = &BSC.in_fifo;
DPT_register(&BSC.interf);
// drivers init
SLP_init();
EEP_init();
SPI_init(SPI_MASTER, SPI_THREE, SPI_MSB, SPI_DIV_16);
// read reset frame
EEP_read(0x00, (u8*)&fr, sizeof(frame_t));
while ( ! EEP_is_fini() )
;
// check if the frame is valid
if ( fr.dest == 0xff || fr.orig == 0xff || fr.cmde == 0xff || fr.status == 0xff ) {
return;
}
// enqueue the reset frame
FIFO_put(&BSC.out_fifo, &fr);
// lock the dispatcher to be able to treat the frame
DPT_lock(&BSC.interf);
}
/*---------------------------------------------------------------------------*/
void
psock_init(CC_REGISTER_ARG struct psock *psock,
uint8_t *buffer, unsigned int buffersize)
{
psock->state = STATE_NONE;
psock->readlen = 0;
psock->bufptr = buffer;
psock->bufsize = buffersize;
buf_setup(&psock->buf, buffer, buffersize);
PT_INIT(&psock->pt);
PT_INIT(&psock->psockpt);
}
int main(void)
{
// === config the uart, DMA, SPI ===========
PT_setup();
// == SPI ==
//enable SPI at 10 MHz clock to meet digital potentiometer specifications
SpiChnOpen(spiChn, SPI_OPEN_ON | SPI_OPEN_MODE16 | SPI_OPEN_MSTEN | SPI_OPEN_CKE_REV , spiClkDiv);
// === setup system wide interrupts ====================
INTEnableSystemMultiVectoredInt();
// === set up i/o port pin ===============================
//Port B bits, 3,7,8, and 9 are used to select digital output
//Port B bit 4 is used as chip select for treble digital potentiometer
//Port B bit 13 is used as a select signal for output effect selection multiplexer
//Additional functionality would use the TFT to display which output was being
//selected
mPORTBSetPinsDigitalOut(BIT_4 | BIT_3|BIT_7 | BIT_8 | BIT_9 |BIT_13); //Set port as output
//Port A Bits 0,2,and 3 are used to configure digital potentiometers (chip selects). Port A bit 4 is used
//for multiplexing whether to have input from Digital effector chip, distortion,
//or pure tonestack sound
mPORTASetPinsDigitalOut(BIT_0 | BIT_2 | BIT_3 | BIT_4);
// === now the threads ===================================
// init the threads
PT_INIT(&pt_cmd);
PT_INIT(&pt_time);
//==Digipot spi stuff
// SCK2 is pin 26
// SDO1 (MOSI) is in PPS output group 1, could be connected to RB5 which is pin 14
PPSOutput(2, RPB5, SDO1);
// control CS for DAC
//mPORTBSetPinsDigitalOut(BIT_4); //CS
mPORTBSetBits(BIT_4 | BIT_6);
//===
mPORTASetBits(BIT_0 | BIT_2 | BIT_3 | BIT_4); //CS pins active high
mPORTAClearBits(BIT_4);
mPORTBClearBits(BIT_13);
mPORTBSetBits(BIT_13);
// schedule the threads
while(1) {
//cmd used as command center for all effects
PT_SCHEDULE(protothread_cmd(&pt_cmd));
}
} // main
int main(void)
{
// === config the uart, DMA, vref, timer5 ISR =============
PT_setup();
// === setup system wide interrupts ====================
INTEnableSystemMultiVectoredInt();
// === set up i/o port pin ===============
mPORTASetBits(BIT_0 | BIT_1 ); //Clear bits to ensure light is off.
mPORTASetPinsDigitalOut(BIT_0 | BIT_1 ); //Set port as output
mPORTBSetBits(BIT_0 ); //Clear bits to ensure light is off.
mPORTBSetPinsDigitalOut(BIT_0 ); //Set port as output
// === now the threads ====================
// init the thread control semaphores
PT_SEM_INIT(&control_t1, 0); // start blocked
PT_SEM_INIT(&control_t2, 1); // start unblocked
PT_SEM_INIT(&send_sem, 1); // start with ready to send
// init the threads
PT_INIT(&pt1);
PT_INIT(&pt2);
PT_INIT(&pt3);
PT_INIT(&pt4);
PT_INIT(&pt5);
// init the optional rate scheduler
PT_RATE_INIT();
// schedule the threads
while(1) {
PT_RATE_LOOP(); // not necessary if you use PT_SCHEDULE
PT_RATE_SCHEDULE(protothread1(&pt1), t1_rate);
if (run_t4) PT_RATE_SCHEDULE(protothread4(&pt4), t4_rate); //run always
PT_RATE_SCHEDULE(protothread2(&pt2), t1_rate);
if (cmd[0] != 'k') PT_RATE_SCHEDULE(protothread3(&pt3),t3_rate);
PT_SCHEDULE(protothread5(&pt5));
/*
// alternate scheme
PT_SCHEDULE(protothread1(&pt1));
if (run_t4) PT_SCHEDULE(protothread4(&pt4));
PT_SCHEDULE(protothread2(&pt2));
if (run_t4) PT_SCHEDULE(protothread4(&pt4));
if (cmd[0] != 'k') PT_SCHEDULE(protothread3(&pt3));
*/
}
} // main
PROCESS_THREAD(ieee_process, ev, data)
{
static void (*ieee_mlmehandler)(MAC_MlmeDcfmInd_s*);
static void (*ieee_mcpshandler)(MAC_McpsDcfmInd_s*);
PROCESS_BEGIN();
PUTS("ieee_process: starting\n");
ieee_init();
ieee_serial_init();
PT_INIT(&ieee_mlme); ieee_mlmehandler = ieee_mlmept;
PT_INIT(&ieee_mcps); ieee_mcpshandler = ieee_mcpspt;
/* start the mlme thread by requesting a scan. */
req_scan(MAC_MLME_SCAN_TYPE_ACTIVE,0);
PUTS("ieee_process: started\n");
/* run until this process is exiting */
while(true)
{
size_t i;
MAC_DcfmIndHdr_s *macev;
for(i=0; i<RX_QUEUE_SIZE && (macev=rxq_peek())!=NULL; i++)
{
if(rxq_peektype()==MLME) {
//ieee_serial_mlme((MAC_MlmeDcfmInd_s*) macev);
ieee_mlmehandler((MAC_MlmeDcfmInd_s*) macev);
}
else if(rxq_peektype()==MCPS) {
//ieee_serial_mcps((MAC_McpsDcfmInd_s*) macev);
ieee_mcpshandler((MAC_McpsDcfmInd_s*) macev);
}
rxq_dequeue();
}
if (ev==ieee_event && data == IEEE_STARTED)
ieee_started = true;
PROCESS_YIELD();
}
PUTS("ieee_process: exiting\n");
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
void
httpd_appcall(void)
{
struct httpd_state *s = (struct httpd_state *)&(uip_conn->appstate);
if(uip_closed() || uip_aborted() || uip_timedout()) {
} else if(uip_connected()) {
PSOCK_INIT(&s->sin, s->inputbuf, sizeof(s->inputbuf) - 1);
PSOCK_INIT(&s->sout, s->inputbuf, sizeof(s->inputbuf) - 1);
PT_INIT(&s->outputpt);
s->state = STATE_WAITING;
/* timer_set(&s->timer, CLOCK_SECOND * 100);*/
s->timer = 0;
handle_connection(s);
} else if(s != NULL) {
if(uip_poll()) {
++s->timer;
if(s->timer >= 20) {
uip_abort();
}
} else {
s->timer = 0;
}
handle_connection(s);
} else {
uip_abort();
}
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_output(struct httpd_state *s))
{
char *ptr;
PT_BEGIN(&s->outputpt);
if(!httpd_fs_open(s->filename, &s->file)) {
strcpy(s->filename, ip64_webserver_http_404_html);
httpd_fs_open(s->filename, &s->file);
PT_WAIT_THREAD(&s->outputpt,
send_headers(s,
ip64_webserver_http_header_404));
PT_WAIT_THREAD(&s->outputpt,
send_file(s));
} else {
PT_WAIT_THREAD(&s->outputpt,
send_headers(s,
ip64_webserver_http_header_200));
ptr = strrchr(s->filename, ISO_period);
if(ptr != NULL && strncmp(ptr, ip64_webserver_http_shtml, 6) == 0) {
PT_INIT(&s->scriptpt);
PT_WAIT_THREAD(&s->outputpt, handle_script(s));
} else {
PT_WAIT_THREAD(&s->outputpt,
send_file(s));
}
}
PSOCK_CLOSE(&s->sout);
PT_END(&s->outputpt);
}
/*---------------------------------------------------------------------------*/
int
http_socket_get(struct http_socket *s,
const char *url,
int64_t pos,
uint64_t length,
http_socket_callback_t callback,
void *callbackptr)
{
init();
strncpy(s->url, url, sizeof(s->url));
s->pos = pos;
s->length = length;
s->postdata = NULL;
s->postdatalen = 0;
s->timeout_timer_started = 0;
PT_INIT(&s->pt);
tcp_socket_register(&s->s, s,
s->inputbuf, sizeof(s->inputbuf),
s->outputbuf, sizeof(s->outputbuf),
input, event);
s->callback = callback;
s->callbackptr = callbackptr;
list_add(socketlist, s);
return start_request(s);
}
/*---------------------------------------------------------------------------*/
int
http_socket_post(struct http_socket *s,
const char *url,
const void *postdata,
uint16_t postdatalen,
const char *content_type,
http_socket_callback_t callback,
void *callbackptr)
{
init();
strncpy(s->url, url, sizeof(s->url));
s->pos = 0;
s->length = 0;
s->postdata = postdata;
s->postdatalen = postdatalen;
s->content_type = content_type;
s->timeout_timer_started = 0;
PT_INIT(&s->pt);
tcp_socket_register(&s->s, s,
s->inputbuf, sizeof(s->inputbuf),
s->outputbuf, sizeof(s->outputbuf),
input, event);
s->callback = callback;
s->callbackptr = callbackptr;
list_add(socketlist, s);
return start_request(s);
}
/*---------------------------------------------------------------------*/
static void
uipcall(void *state)
{
if(uip_udpconnection()) {
recv_udpthread(&s.recv_udpthread_pt);
send_udpthread(&s.udpthread_pt);
} else {
if(uip_conn->lport == HTONS(CODEPROP_DATA_PORT)) {
if(uip_connected()) {
if(state == NULL) {
s.addr = 0;
s.count = 0;
PT_INIT(&s.tcpthread_pt);
process_poll(&codeprop_process);
tcp_markconn(uip_conn, &s);
/* process_post(PROCESS_BROADCAST, codeprop_event_quit, */
/* (process_data_t)NULL); */
} else {
PRINTF(("codeprop: uip_connected() and state != NULL\n"));
uip_abort();
}
}
recv_tcpthread(&s.tcpthread_pt);
if(uip_closed() || uip_aborted() || uip_timedout()) {
PRINTF(("codeprop: connection down\n"));
tcp_markconn(uip_conn, NULL);
}
}
}
}
/*---------------------------------------------------------------------------*/
void
process_start(struct process *p, const char *arg)
{
struct process *q;
/* First make sure that we don't try to start a process that is
already running. */
for(q = process_list; q != p && q != NULL; q = q->next);
/* If we found the process on the process list, we bail out. */
if(q == p) {
return;
}
/* Put on the procs list.*/
p->next = process_list;
process_list = p;
p->state = PROCESS_STATE_RUNNING;
PT_INIT(&p->pt);
PRINTF("process: starting '%s'\n", PROCESS_NAME_STRING(p));
/* Post a synchronous initialization event to the process. */
process_post_synch(p, PROCESS_EVENT_INIT, (process_data_t)arg);
}
/*
=======================================================================================================================
=======================================================================================================================
*/
static PT_THREAD(handle_output (struct httpd_state *s))
{
/*~~~~~~~~~*/
char *ptr;
/*~~~~~~~~~*/
PT_BEGIN(&s->outputpt);
if(!httpd_fs_open(s->filename, &s->file))
{
httpd_fs_open(http_404_html, &s->file);
strcpy(s->filename, http_404_html);
PT_WAIT_THREAD(&s->outputpt, send_headers(s, http_header_404));
PT_WAIT_THREAD(&s->outputpt, send_file(s));
}
else
{
PT_WAIT_THREAD(&s->outputpt, send_headers(s, http_header_200));
ptr = strchr(s->filename, ISO_period);
if(ptr != NULL && strncmp(ptr, http_shtml, 6) == 0)
{
vProcessInput( s->filename );
PT_INIT(&s->scriptpt);
PT_WAIT_THREAD(&s->outputpt, handle_script(s));
}
else
{
PT_WAIT_THREAD(&s->outputpt, send_file(s));
}
}
PSOCK_CLOSE(&s->sout);
PT_END(&s->outputpt);
}
/*---------------------------------------------------------------------------*/
void
ip64_dhcpc_init(const void *mac_addr, int mac_len)
{
/* Although this is DHCPv4, we explicitly bind the socket to an IPv6
address so that it can operate over the ip64 bridge. */
uip_ip6addr_t v6addr;
uip_ip4addr_t v4addr;
struct uip_udp_conn *conn2;
s.mac_addr = mac_addr;
s.mac_len = mac_len;
s.state = STATE_INITIAL;
uip_ipaddr(&v4addr, 255,255,255,255);
ip64_addr_4to6(&v4addr, &v6addr);
s.conn = udp_new(&v6addr, UIP_HTONS(IP64_DHCPC_SERVER_PORT), NULL);
conn2 = udp_new(NULL, UIP_HTONS(IP64_DHCPC_SERVER_PORT), NULL);
if(s.conn != NULL) {
udp_bind(s.conn, UIP_HTONS(IP64_DHCPC_CLIENT_PORT));
}
if(conn2 != NULL) {
udp_bind(conn2, UIP_HTONS(IP64_DHCPC_CLIENT_PORT));
}
PT_INIT(&s.pt);
}
static
PT_THREAD(handle_output(struct httpd_state *s))
{
char *ptr;
PT_BEGIN(&s->outputpt);
#if DEBUGLOGIC
httpd_strcpy(s->filename,httpd_indexfn);
#endif
if(!httpd_fs_open(s->filename, &s->file)) {
httpd_strcpy(s->filename, httpd_404fn);
httpd_fs_open(s->filename, &s->file);
PT_WAIT_THREAD(&s->outputpt, send_headers(s, httpd_404notf));
PT_WAIT_THREAD(&s->outputpt, send_file(s));
} else {
PT_WAIT_THREAD(&s->outputpt, send_headers(s, httpd_200ok));
ptr = strchr(s->filename, ISO_period);
if((ptr != NULL && httpd_strncmp(ptr, httpd_shtml, 6) == 0) || httpd_strcmp(s->filename,httpd_indexfn)==0) {
PT_INIT(&s->scriptpt);
PT_WAIT_THREAD(&s->outputpt, handle_script(s));
} else {
PT_WAIT_THREAD(&s->outputpt, send_file(s));
}
}
PSOCK_CLOSE(&s->sout);
PT_END(&s->outputpt);
}
/******************************************************************************
* Name : uint8 Task_PT_Demo_Process(uint8 u8Evt, void *pPara)
* Function : A demo task for PT application
* Input : uint8 u8Evt 1~254 Event for the task
* void *pPara Pointer of parameter
* Output: : None
* Return : SW_OK Successful operation
* : SW_ERR Failed operation
* 1~254 Event which is not processed.
* description: To be done
* Version : V1.00
* Author : Ian
* Date : 8th Jul 2016
******************************************************************************/
uint8 Task_PT_Demo_Process(uint8 u8Evt, void *pPara)
{
PT_INIT();
PT_BEGIN();
/******************************************************************/
MOE_MANDATORY_INIT(); /* Mandatory init, shout call it here only */
/******************************************************************/
while(1)
{
TASK_PT_DEMO_LED_On(LED_RED);
PT_DELAY(1000);
TASK_PT_DEMO_LED_Off(LED_RED);
TASK_PT_DEMO_LED_On(LED_GREEN);
PT_DELAY(1000);
TASK_PT_DEMO_LED_Off(LED_GREEN);
TASK_PT_DEMO_LED_On(LED_BLUE);
PT_DELAY(1000);
TASK_PT_DEMO_LED_Off(LED_BLUE);
}
PT_END();
return SW_OK;
}
/*---------------------------------------------------------------------------*/
void
tr1001_init(void)
{
PT_INIT(&rxhandler_pt);
onoroff = OFF;
UCTL0 = CHAR; /* 8-bit character */
UTCTL0 = SSEL1; /* UCLK = SMCLK */
tr1001_set_speed(TR1001_19200);
ME1 |= UTXE0 + URXE0; /* Enable USART0 TXD/RXD */
/* Turn on receive interrupt. */
IE1 |= URXIE0;
timer_set(&rxtimer, CLOCK_SECOND / 4);
tr1001_on();
tr1001_set_txpower(100);
/* Reset reception state. */
rxclear();
process_start(&tr1001_process, NULL);
}
/*---------------------------------------------------------------------------*/
static void
plb_init(void)
{
PRINTF("plb_init\n");
is_init = 1;
PT_INIT(&pt);
// init value
is_plb_on = 0;
is_radio_on = 0;
has_data = 0;
send_req = 0;
wait_packet = 0;
c_wait = 0;
dataptr_temp=(uint8_t*)malloc(sizeof(uint8_t)*temp_len); // need to be free JJH3
// set address
addr_next.u8[0] = rimeaddr_node_addr.u8[0]+1;
if(rimeaddr_node_addr.u8[0] > 0){
addr_prev.u8[0] = rimeaddr_node_addr.u8[0]-1;
}
else{
addr_prev.u8[0] = 0;
}
return;
}
void
dhcpc_renew(void)
{
uip_ipaddr_t addr;
#if defined PORT_APP_MAPPER
if (dhcpc_running)
return;
dhcpc_running = 1;
#else
if (s.state != STATE_CONFIG_RECEIVED)
{
return;
}
#endif
//sendString("\r\ndhcpc renew called");
// if no server ip then we have to do a full request
if (s.serverid[0] == 0)
{
dhcpc_init(s.mac_addr, s.mac_len);
return;
}
// unicast to dhcp server
uip_ipaddr(addr, s.serverid[0], s.serverid[1], s.serverid[2], s.serverid[3]);
s.conn = uip_udp_new(&addr, HTONS(DHCPC_SERVER_PORT));
if(s.conn != NULL) {
uip_udp_bind(s.conn, HTONS(DHCPC_CLIENT_PORT));
}
s.state = STATE_RENEW;
PT_INIT(&s.pt);
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_output(struct httpd_state *s))
{
char *ptr;
PT_BEGIN(&s->outputpt);
if(!httpd_fs_open(s->filename, &s->file)) {
httpd_fs_open(http_404_html, &s->file);
PT_WAIT_THREAD(&s->outputpt,
send_headers(s,
http_header_404));
PT_WAIT_THREAD(&s->outputpt,
send_file(s));
} else {
PT_WAIT_THREAD(&s->outputpt,
send_headers(s,
http_header_200));
ptr = strchr(s->filename, ISO_period);
#if HTTPD_CONF_SCRIPT
if(ptr != NULL && strncmp(ptr, http_shtml, 6) == 0) {
PT_INIT(&s->scriptpt);
PT_WAIT_THREAD(&s->outputpt, handle_script(s));
} else {
PT_WAIT_THREAD(&s->outputpt,
send_file(s));
}
#else /* HTTPD_CONF_SCRIPT */
PT_WAIT_THREAD(&s->outputpt,
send_file(s));
#endif /* HTTPD_CONF_SCRIPT */
}
PSOCK_CLOSE(&s->sout);
PT_END(&s->outputpt);
}
void main(void) //using 0
{
EA = 0;
PLLCON&=PLLCON_VAL;//настройка частоты процессора
RestoreCalibrate();
RestoreSettings();
// ChannelsInit();//инициализация настроек каналов
Protocol_Init();
Timer1_Initialize(); //таймер шедулера 200Гц
ADC_Initialize();
UART_Init();
WDT_Init(WDT_2000);//включить сторожевой таймер
PT_INIT(&pt_sort);
startMenu();
EA=1;
while(1)
{
ulongsort_process(&pt_sort);
DisplayProcess(&pt_display);
WDT_Process(&pt_wdt);
KeyboardProcess(&pt_keyboard);
}
}
