void openwsn_init() {
// drivers
openserial_init();
// stack
// cross-layer
idmanager_init(); // call first since initializes e.g. EUI64
openqueue_init();
openrandom_init();
opentimers_init();
// 02a-TSCH
ieee154e_init();
// 02b-RES
schedule_init();
res_init();
neighbors_init();
nf_init(); //noise floor module
// 03a-IPHC
openbridge_init();
iphc_init();
// 03b-IPv6
forwarding_init();
icmpv6_init();
icmpv6echo_init();
icmpv6router_init();
icmpv6rpl_init();
// 04-TRAN
opentcp_init();
openudp_init();
opencoap_init(); // initialize before any of the CoAP clients
// 07-App
//--CoAP
//rwellknown_init();
//rreg_init();
//rinfo_init();
//rleds_init();
//rt_init();
//rex_init();
//rheli_init();
//rrube_init();
//rxl1_init();
//layerdebug_init();
//--UDP
/*udpecho_init();
udpinject_init();
udpprint_init();*/
//udprand_init();
//udpstorm_init();
//--TCP
/*ohlone_init();
tcpecho_init();
tcpinject_init();
tcpprint_init();*/
//--misc
//heli_init();
//imu_init();
//bbk_init();
//hdl_init();
}
void openstack_init(void) {
//===== drivers
openserial_init();
//===== stack
//-- cross-layer
idmanager_init(); // call first since initializes EUI64 and isDAGroot
openqueue_init();
openrandom_init();
opentimers_init();
//-- 02a-TSCH
adaptive_sync_init();
ieee154e_init();
//-- 02b-RES
schedule_init();
sixtop_init();
neighbors_init();
//===== applications
openapps_init();
openserial_printInfo(
COMPONENT_OPENWSN,ERR_BOOTED,
(errorparameter_t)0,
(errorparameter_t)0
);
}
void setup_software(void){
/*********************************************
* Scheduler Initialization. Do not modify. *
*********************************************/
schedule_init(schedule,SCHEDULE_TICK_DIVIDER,SCHEDULE_TICKS_PER_MS);
/*********************************************
* Put user initialization code below here. *
*********************************************/
set_heartbeat_period_ms(250);
//initialize SSP ring buffer
can_ring_init(&csr_ssp_tx_ring,csr_ssp_tx_frame_buf,CSR_SSP_TX_FRAME_BUF_LEN); //SSP main transmit ring buffer
csr_ssp_tx_ring_ptr_set(&csr_ssp_tx_ring);
//initialize CAN ring buffers
can_ring_init(&rx_ring,rx_frame_buf,RX_FRAME_BUF_LEN);
can_rx_set_chan_cfg(CHAN_CAN1, (volatile unsigned long *)0xE0044000, &rx_ring, CAN_DISPATCH_MANUAL); //CAN controller 1
can_rx_set_chan_cfg(CHAN_CAN2, (volatile unsigned long *)0xE0048000, &rx_ring, CAN_DISPATCH_MANUAL); //CAN controller 2
can_rx_set_chan_cfg(CHAN_CAN3, (volatile unsigned long *)0xE004C000, &rx_ring, CAN_DISPATCH_MANUAL); //CAN controller 3
can_rx_set_chan_cfg(CHAN_CAN4, (volatile unsigned long *)0xE0050000, &rx_ring, CAN_DISPATCH_MANUAL); //CAN controller 4
can_ring_init(&tx1_ring,tx1_frame_buf,TX_FRAME_BUF_LEN); //CAN controller 1 transmit
can_ring_init(&tx2_ring,tx2_frame_buf,TX_FRAME_BUF_LEN); //CAN controller 2 transmit
can_ring_init(&tx3_ring,tx3_frame_buf,TX_FRAME_BUF_LEN); //CAN controller 3 transmit
can_ring_init(&tx4_ring,tx4_frame_buf,TX_FRAME_BUF_LEN); //CAN controller 4 transmit
can_tx_set_chan_cfg(CHAN_CAN1, (volatile unsigned long *)0xE0044000, &tx1_ring); //CAN controller 1
can_tx_set_chan_cfg(CHAN_CAN2, (volatile unsigned long *)0xE0048000, &tx2_ring); //CAN controller 2
can_tx_set_chan_cfg(CHAN_CAN3, (volatile unsigned long *)0xE004C000, &tx3_ring); //CAN controller 3
can_tx_set_chan_cfg(CHAN_CAN4, (volatile unsigned long *)0xE0050000, &tx4_ring); //CAN controller 4
////////////////////////////////////////////////////////////////////
//Enable interrupts
////////////////////////////////////////////////////////////////////
//Timer0 interrupt setup
VICVectAddr0 = (unsigned long)timer0_isr;
VICVectCntl0 = 0x20 | 4; /* Timer1 Interrupt */
VICIntEnable = 1 << 4; /* Enable Timer1 Interrupt */
/*
//SSP interrupt setup IRQ
VICVectAddr2 = (unsigned long)csr_ssp_isr;
VICVectCntl2 = 0x20 | 11; // SSP Interrupt, set to level 2
VICIntEnable = 1 << 11; // Enable SSP interrupt
*/
//SSP interrupt setup FIQ
VICIntSelect |= 1 << 11; //Enable FIQ interrupts for SSP
VICIntEnable = 1 << 11; // Enable SSP interrupt
//UART0 interrupt setup
//VICVectCntl3 = (1<<5) + 6; //Enable vectored interrupt slot 3 and set it to UART0 (interrupt source 6)
// VICIntSelect &= ~(1<<6); //Clear bit 6 - use IRQ interrupts for UART0, not FIQ.
//VICIntEnable = 1<<6; //Enable UART0 interrupt at vectored interrupt controller (VIC)
}
static void do_start(struct cardstate *cs)
{
gigaset_free_channels(cs);
if (cs->mstate != MS_LOCKED)
schedule_init(cs, MS_INIT);
cs->isdn_up = 1;
gigaset_isdn_start(cs);
cs->waiting = 0;
wake_up(&cs->waitqueue);
}
static int do_unlock(struct cardstate *cs)
{
if (cs->mstate != MS_LOCKED)
return -EINVAL;
cs->mstate = MS_UNINITIALIZED;
cs->mode = M_UNKNOWN;
gigaset_free_channels(cs);
if (cs->connected)
schedule_init(cs, MS_INIT);
return 0;
}
void openstack_init(OpenMote* self) {
//===== drivers
openserial_init(self);
//===== stack
//-- cross-layer
idmanager_init(self); // call first since initializes EUI64 and isDAGroot
openqueue_init(self);
openrandom_init(self);
opentimers_init(self);
//-- 02a-TSCH
adaptive_sync_init(self);
ieee154e_init(self);
//-- 02b-RES
schedule_init(self);
sixtop_init(self);
neighbors_init(self);
//-- 03a-IPHC
openbridge_init(self);
iphc_init(self);
//-- 03b-IPv6
forwarding_init(self);
icmpv6_init(self);
icmpv6echo_init(self);
icmpv6rpl_init(self);
//-- 04-TRAN
opentcp_init(self);
openudp_init(self);
opencoap_init(self); // initialize before any of the CoAP applications
//===== applications
openapps_init(self);
openserial_printInfo(self,
COMPONENT_OPENWSN,ERR_BOOTED,
(errorparameter_t)0,
(errorparameter_t)0
);
}
/* Entering cid mode or getting a cid failed:
* try to initialize the device and try again.
*
* channel >= 0: getting cid for the channel failed
* channel < 0: entering cid mode failed
*
* returns 0 on success, <0 on failure
*/
static int reinit_and_retry(struct cardstate *cs, int channel)
{
int i;
if (--cs->retry_count <= 0)
return -EFAULT;
for (i = 0; i < cs->channels; ++i)
if (cs->bcs[i].at_state.cid > 0)
return -EBUSY;
if (channel < 0)
dev_warn(cs->dev,
"Could not enter cid mode. Reinit device and try again.\n");
else {
dev_warn(cs->dev,
"Could not get a call id. Reinit device and try again.\n");
cs->bcs[channel].at_state.pending_commands |= PC_CID;
}
schedule_init(cs, MS_INIT);
return 0;
}
int main(void)
{
#ifdef CONFIG_INITCALL
int ret;
initcall_t *initcall;
for (initcall = __rnk_initcalls_start; initcall < __rnk_initcalls_end; initcall++) {
debug_printk("initcall-> %pS\n", *initcall);
ret = (*initcall)();
if (ret < 0)
error_printk("initcall %pS failed: %d\n", *initcall, ret);
}
#endif /* CONFIG_INITCALL */
printk("Welcome to rnk\r\n");
printk("- Initialise scheduler...\r\n");
#ifndef CONFIG_INITCALL
schedule_init();
time_init();
#endif /* CONFIG_INITCALL */
#ifdef CONFIG_UNWIND
unwind_init();
#endif /* CONFIG_UNWIND */
printk("- Add thread to scheduler\r\n");
add_thread(&loading_thread, 1);
printk("- Start scheduling...\r\n");
start_schedule();
while(1)
;
return 0; //Never reach
}
static void process_command_flags(struct cardstate *cs)
{
struct at_state_t *at_state = NULL;
struct bc_state *bcs;
int i;
int sequence;
unsigned long flags;
cs->commands_pending = 0;
if (cs->cur_at_seq) {
gig_dbg(DEBUG_EVENT, "not searching scheduled commands: busy");
return;
}
gig_dbg(DEBUG_EVENT, "searching scheduled commands");
sequence = SEQ_NONE;
/* clear pending_commands and hangup channels on shutdown */
if (cs->at_state.pending_commands & PC_SHUTDOWN) {
cs->at_state.pending_commands &= ~PC_CIDMODE;
for (i = 0; i < cs->channels; ++i) {
bcs = cs->bcs + i;
at_state = &bcs->at_state;
at_state->pending_commands &=
~(PC_DLE1 | PC_ACCEPT | PC_DIAL);
if (at_state->cid > 0)
at_state->pending_commands |= PC_HUP;
if (at_state->pending_commands & PC_CID) {
at_state->pending_commands |= PC_NOCID;
at_state->pending_commands &= ~PC_CID;
}
}
}
/* clear pending_commands and hangup channels on reset */
if (cs->at_state.pending_commands & PC_INIT) {
cs->at_state.pending_commands &= ~PC_CIDMODE;
for (i = 0; i < cs->channels; ++i) {
bcs = cs->bcs + i;
at_state = &bcs->at_state;
at_state->pending_commands &=
~(PC_DLE1 | PC_ACCEPT | PC_DIAL);
if (at_state->cid > 0)
at_state->pending_commands |= PC_HUP;
if (cs->mstate == MS_RECOVER) {
if (at_state->pending_commands & PC_CID) {
at_state->pending_commands |= PC_NOCID;
at_state->pending_commands &= ~PC_CID;
}
}
}
}
/* only switch back to unimodem mode if no commands are pending and
* no channels are up */
spin_lock_irqsave(&cs->lock, flags);
if (cs->at_state.pending_commands == PC_UMMODE
&& !cs->cidmode
&& list_empty(&cs->temp_at_states)
&& cs->mode == M_CID) {
sequence = SEQ_UMMODE;
at_state = &cs->at_state;
for (i = 0; i < cs->channels; ++i) {
bcs = cs->bcs + i;
if (bcs->at_state.pending_commands ||
bcs->at_state.cid > 0) {
sequence = SEQ_NONE;
break;
}
}
}
spin_unlock_irqrestore(&cs->lock, flags);
cs->at_state.pending_commands &= ~PC_UMMODE;
if (sequence != SEQ_NONE) {
schedule_sequence(cs, at_state, sequence);
return;
}
for (i = 0; i < cs->channels; ++i) {
bcs = cs->bcs + i;
if (bcs->at_state.pending_commands & PC_HUP) {
if (cs->dle) {
cs->curchannel = bcs->channel;
schedule_sequence(cs, &cs->at_state, SEQ_DLE0);
return;
}
bcs->at_state.pending_commands &= ~PC_HUP;
if (bcs->at_state.pending_commands & PC_CID) {
/* not yet dialing: PC_NOCID is sufficient */
bcs->at_state.pending_commands |= PC_NOCID;
bcs->at_state.pending_commands &= ~PC_CID;
} else {
schedule_sequence(cs, &bcs->at_state, SEQ_HUP);
return;
}
}
if (bcs->at_state.pending_commands & PC_NOCID) {
bcs->at_state.pending_commands &= ~PC_NOCID;
cs->curchannel = bcs->channel;
schedule_sequence(cs, &cs->at_state, SEQ_NOCID);
return;
} else if (bcs->at_state.pending_commands & PC_DLE0) {
bcs->at_state.pending_commands &= ~PC_DLE0;
cs->curchannel = bcs->channel;
schedule_sequence(cs, &cs->at_state, SEQ_DLE0);
return;
}
}
list_for_each_entry(at_state, &cs->temp_at_states, list)
if (at_state->pending_commands & PC_HUP) {
at_state->pending_commands &= ~PC_HUP;
schedule_sequence(cs, at_state, SEQ_HUP);
return;
}
if (cs->at_state.pending_commands & PC_INIT) {
cs->at_state.pending_commands &= ~PC_INIT;
cs->dle = 0;
cs->inbuf->inputstate = INS_command;
schedule_sequence(cs, &cs->at_state, SEQ_INIT);
return;
}
if (cs->at_state.pending_commands & PC_SHUTDOWN) {
cs->at_state.pending_commands &= ~PC_SHUTDOWN;
schedule_sequence(cs, &cs->at_state, SEQ_SHUTDOWN);
return;
}
if (cs->at_state.pending_commands & PC_CIDMODE) {
cs->at_state.pending_commands &= ~PC_CIDMODE;
if (cs->mode == M_UNIMODEM) {
cs->retry_count = 1;
schedule_sequence(cs, &cs->at_state, SEQ_CIDMODE);
return;
}
}
for (i = 0; i < cs->channels; ++i) {
bcs = cs->bcs + i;
if (bcs->at_state.pending_commands & PC_DLE1) {
bcs->at_state.pending_commands &= ~PC_DLE1;
cs->curchannel = bcs->channel;
schedule_sequence(cs, &cs->at_state, SEQ_DLE1);
return;
}
if (bcs->at_state.pending_commands & PC_ACCEPT) {
bcs->at_state.pending_commands &= ~PC_ACCEPT;
schedule_sequence(cs, &bcs->at_state, SEQ_ACCEPT);
return;
}
if (bcs->at_state.pending_commands & PC_DIAL) {
bcs->at_state.pending_commands &= ~PC_DIAL;
schedule_sequence(cs, &bcs->at_state, SEQ_DIAL);
return;
}
if (bcs->at_state.pending_commands & PC_CID) {
switch (cs->mode) {
case M_UNIMODEM:
cs->at_state.pending_commands |= PC_CIDMODE;
gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
cs->commands_pending = 1;
return;
case M_UNKNOWN:
schedule_init(cs, MS_INIT);
return;
}
bcs->at_state.pending_commands &= ~PC_CID;
cs->curchannel = bcs->channel;
cs->retry_count = 2;
schedule_sequence(cs, &cs->at_state, SEQ_CID);
return;
}
}
}
static void do_action(int action, struct cardstate *cs,
struct bc_state *bcs,
struct at_state_t **p_at_state, char **pp_command,
int *p_genresp, int *p_resp_code,
struct event_t *ev)
{
struct at_state_t *at_state = *p_at_state;
struct bc_state *bcs2;
unsigned long flags;
int channel;
unsigned char *s, *e;
int i;
unsigned long val;
switch (action) {
case ACT_NOTHING:
break;
case ACT_TIMEOUT:
at_state->waiting = 1;
break;
case ACT_INIT:
cs->at_state.pending_commands &= ~PC_INIT;
cs->cur_at_seq = SEQ_NONE;
cs->mode = M_UNIMODEM;
spin_lock_irqsave(&cs->lock, flags);
if (!cs->cidmode) {
spin_unlock_irqrestore(&cs->lock, flags);
gigaset_free_channels(cs);
cs->mstate = MS_READY;
break;
}
spin_unlock_irqrestore(&cs->lock, flags);
cs->at_state.pending_commands |= PC_CIDMODE;
gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
cs->commands_pending = 1;
break;
case ACT_FAILINIT:
dev_warn(cs->dev, "Could not initialize the device.\n");
cs->dle = 0;
init_failed(cs, M_UNKNOWN);
cs->cur_at_seq = SEQ_NONE;
break;
case ACT_CONFIGMODE:
init_failed(cs, M_CONFIG);
cs->cur_at_seq = SEQ_NONE;
break;
case ACT_SETDLE1:
cs->dle = 1;
/* cs->inbuf[0].inputstate |= INS_command | INS_DLE_command; */
cs->inbuf[0].inputstate &=
~(INS_command | INS_DLE_command);
break;
case ACT_SETDLE0:
cs->dle = 0;
cs->inbuf[0].inputstate =
(cs->inbuf[0].inputstate & ~INS_DLE_command)
| INS_command;
break;
case ACT_CMODESET:
if (cs->mstate == MS_INIT || cs->mstate == MS_RECOVER) {
gigaset_free_channels(cs);
cs->mstate = MS_READY;
}
cs->mode = M_CID;
cs->cur_at_seq = SEQ_NONE;
break;
case ACT_UMODESET:
cs->mode = M_UNIMODEM;
cs->cur_at_seq = SEQ_NONE;
break;
case ACT_FAILCMODE:
cs->cur_at_seq = SEQ_NONE;
if (cs->mstate == MS_INIT || cs->mstate == MS_RECOVER) {
init_failed(cs, M_UNKNOWN);
break;
}
if (reinit_and_retry(cs, -1) < 0)
schedule_init(cs, MS_RECOVER);
break;
case ACT_FAILUMODE:
cs->cur_at_seq = SEQ_NONE;
schedule_init(cs, MS_RECOVER);
break;
case ACT_HUPMODEM:
/* send "+++" (hangup in unimodem mode) */
if (cs->connected) {
struct cmdbuf_t *cb;
cb = kmalloc(sizeof(struct cmdbuf_t) + 3, GFP_ATOMIC);
if (!cb) {
dev_err(cs->dev, "%s: out of memory\n",
__func__);
return;
}
memcpy(cb->buf, "+++", 3);
cb->len = 3;
cb->offset = 0;
cb->next = NULL;
cb->wake_tasklet = NULL;
cs->ops->write_cmd(cs, cb);
}
break;
case ACT_RING:
/* get fresh AT state structure for new CID */
at_state = get_free_channel(cs, ev->parameter);
if (!at_state) {
dev_warn(cs->dev,
"RING ignored: could not allocate channel structure\n");
break;
}
/* initialize AT state structure
* note that bcs may be NULL if no B channel is free
*/
at_state->ConState = 700;
for (i = 0; i < STR_NUM; ++i) {
kfree(at_state->str_var[i]);
at_state->str_var[i] = NULL;
}
at_state->int_var[VAR_ZCTP] = -1;
spin_lock_irqsave(&cs->lock, flags);
at_state->timer_expires = RING_TIMEOUT;
at_state->timer_active = 1;
spin_unlock_irqrestore(&cs->lock, flags);
break;
case ACT_ICALL:
handle_icall(cs, bcs, at_state);
break;
case ACT_FAILSDOWN:
dev_warn(cs->dev, "Could not shut down the device.\n");
/* fall through */
case ACT_FAKESDOWN:
case ACT_SDOWN:
cs->cur_at_seq = SEQ_NONE;
finish_shutdown(cs);
break;
case ACT_CONNECT:
if (cs->onechannel) {
at_state->pending_commands |= PC_DLE1;
cs->commands_pending = 1;
break;
}
bcs->chstate |= CHS_D_UP;
gigaset_isdn_connD(bcs);
cs->ops->init_bchannel(bcs);
break;
case ACT_DLE1:
cs->cur_at_seq = SEQ_NONE;
bcs = cs->bcs + cs->curchannel;
bcs->chstate |= CHS_D_UP;
gigaset_isdn_connD(bcs);
cs->ops->init_bchannel(bcs);
break;
case ACT_FAKEHUP:
at_state->int_var[VAR_ZSAU] = ZSAU_NULL;
/* fall through */
case ACT_DISCONNECT:
cs->cur_at_seq = SEQ_NONE;
at_state->cid = -1;
if (!bcs) {
disconnect_nobc(p_at_state, cs);
} else if (cs->onechannel && cs->dle) {
/* Check for other open channels not needed:
* DLE only used for M10x with one B channel.
*/
at_state->pending_commands |= PC_DLE0;
cs->commands_pending = 1;
} else {
disconnect_bc(at_state, cs, bcs);
}
break;
case ACT_FAKEDLE0:
at_state->int_var[VAR_ZDLE] = 0;
cs->dle = 0;
/* fall through */
case ACT_DLE0:
cs->cur_at_seq = SEQ_NONE;
bcs2 = cs->bcs + cs->curchannel;
disconnect_bc(&bcs2->at_state, cs, bcs2);
break;
case ACT_ABORTHUP:
cs->cur_at_seq = SEQ_NONE;
dev_warn(cs->dev, "Could not hang up.\n");
at_state->cid = -1;
if (!bcs)
disconnect_nobc(p_at_state, cs);
else if (cs->onechannel)
at_state->pending_commands |= PC_DLE0;
else
disconnect_bc(at_state, cs, bcs);
schedule_init(cs, MS_RECOVER);
break;
case ACT_FAILDLE0:
cs->cur_at_seq = SEQ_NONE;
dev_warn(cs->dev, "Error leaving DLE mode.\n");
cs->dle = 0;
bcs2 = cs->bcs + cs->curchannel;
disconnect_bc(&bcs2->at_state, cs, bcs2);
schedule_init(cs, MS_RECOVER);
break;
case ACT_FAILDLE1:
cs->cur_at_seq = SEQ_NONE;
dev_warn(cs->dev,
"Could not enter DLE mode. Trying to hang up.\n");
channel = cs->curchannel;
cs->bcs[channel].at_state.pending_commands |= PC_HUP;
cs->commands_pending = 1;
break;
case ACT_CID: /* got cid; start dialing */
cs->cur_at_seq = SEQ_NONE;
channel = cs->curchannel;
if (ev->parameter > 0 && ev->parameter <= 65535) {
cs->bcs[channel].at_state.cid = ev->parameter;
cs->bcs[channel].at_state.pending_commands |=
PC_DIAL;
cs->commands_pending = 1;
break;
}
/* bad cid: fall through */
case ACT_FAILCID:
cs->cur_at_seq = SEQ_NONE;
channel = cs->curchannel;
if (reinit_and_retry(cs, channel) < 0) {
dev_warn(cs->dev,
"Could not get a call ID. Cannot dial.\n");
bcs2 = cs->bcs + channel;
disconnect_bc(&bcs2->at_state, cs, bcs2);
}
break;
case ACT_ABORTCID:
cs->cur_at_seq = SEQ_NONE;
bcs2 = cs->bcs + cs->curchannel;
disconnect_bc(&bcs2->at_state, cs, bcs2);
break;
case ACT_DIALING:
case ACT_ACCEPTED:
cs->cur_at_seq = SEQ_NONE;
break;
case ACT_ABORTACCEPT: /* hangup/error/timeout during ICALL procssng */
if (bcs)
disconnect_bc(at_state, cs, bcs);
else
disconnect_nobc(p_at_state, cs);
break;
case ACT_ABORTDIAL: /* error/timeout during dial preparation */
cs->cur_at_seq = SEQ_NONE;
at_state->pending_commands |= PC_HUP;
cs->commands_pending = 1;
break;
case ACT_REMOTEREJECT: /* DISCONNECT_IND after dialling */
case ACT_CONNTIMEOUT: /* timeout waiting for ZSAU=ACTIVE */
case ACT_REMOTEHUP: /* DISCONNECT_IND with established connection */
at_state->pending_commands |= PC_HUP;
cs->commands_pending = 1;
break;
case ACT_GETSTRING: /* warning: RING, ZDLE, ...
are not handled properly anymore */
at_state->getstring = 1;
break;
case ACT_SETVER:
if (!ev->ptr) {
*p_genresp = 1;
*p_resp_code = RSP_ERROR;
break;
}
s = ev->ptr;
if (!strcmp(s, "OK")) {
/* OK without version string: assume old response */
*p_genresp = 1;
*p_resp_code = RSP_NONE;
break;
}
for (i = 0; i < 4; ++i) {
val = simple_strtoul(s, (char **) &e, 10);
if (val > INT_MAX || e == s)
break;
if (i == 3) {
if (*e)
break;
} else if (*e != '.')
break;
else
s = e + 1;
cs->fwver[i] = val;
}
if (i != 4) {
*p_genresp = 1;
*p_resp_code = RSP_ERROR;
break;
}
cs->gotfwver = 0;
break;
case ACT_GOTVER:
if (cs->gotfwver == 0) {
cs->gotfwver = 1;
gig_dbg(DEBUG_EVENT,
"firmware version %02d.%03d.%02d.%02d",
cs->fwver[0], cs->fwver[1],
cs->fwver[2], cs->fwver[3]);
break;
}
/* fall through */
case ACT_FAILVER:
cs->gotfwver = -1;
dev_err(cs->dev, "could not read firmware version.\n");
break;
case ACT_ERROR:
gig_dbg(DEBUG_ANY, "%s: ERROR response in ConState %d",
__func__, at_state->ConState);
cs->cur_at_seq = SEQ_NONE;
break;
case ACT_DEBUG:
gig_dbg(DEBUG_ANY, "%s: resp_code %d in ConState %d",
__func__, ev->type, at_state->ConState);
break;
case ACT_WARN:
dev_warn(cs->dev, "%s: resp_code %d in ConState %d!\n",
__func__, ev->type, at_state->ConState);
break;
case ACT_ZCAU:
dev_warn(cs->dev, "cause code %04x in connection state %d.\n",
ev->parameter, at_state->ConState);
break;
/* events from the LL */
case ACT_DIAL:
if (!ev->ptr) {
*p_genresp = 1;
*p_resp_code = RSP_ERROR;
break;
}
start_dial(at_state, ev->ptr, ev->parameter);
break;
case ACT_ACCEPT:
start_accept(at_state);
break;
case ACT_HUP:
at_state->pending_commands |= PC_HUP;
gig_dbg(DEBUG_EVENT, "Scheduling PC_HUP");
cs->commands_pending = 1;
break;
/* hotplug events */
case ACT_STOP:
do_stop(cs);
break;
case ACT_START:
do_start(cs);
break;
/* events from the interface */
case ACT_IF_LOCK:
cs->cmd_result = ev->parameter ? do_lock(cs) : do_unlock(cs);
cs->waiting = 0;
wake_up(&cs->waitqueue);
break;
case ACT_IF_VER:
if (ev->parameter != 0)
cs->cmd_result = -EINVAL;
else if (cs->gotfwver != 1) {
cs->cmd_result = -ENOENT;
} else {
memcpy(ev->arg, cs->fwver, sizeof cs->fwver);
cs->cmd_result = 0;
}
cs->waiting = 0;
wake_up(&cs->waitqueue);
break;
/* events from the proc file system */
case ACT_PROC_CIDMODE:
spin_lock_irqsave(&cs->lock, flags);
if (ev->parameter != cs->cidmode) {
cs->cidmode = ev->parameter;
if (ev->parameter) {
cs->at_state.pending_commands |= PC_CIDMODE;
gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
} else {
cs->at_state.pending_commands |= PC_UMMODE;
gig_dbg(DEBUG_EVENT, "Scheduling PC_UMMODE");
}
cs->commands_pending = 1;
}
spin_unlock_irqrestore(&cs->lock, flags);
cs->waiting = 0;
wake_up(&cs->waitqueue);
break;
/* events from the hardware drivers */
case ACT_NOTIFY_BC_DOWN:
bchannel_down(bcs);
break;
case ACT_NOTIFY_BC_UP:
bchannel_up(bcs);
break;
case ACT_SHUTDOWN:
do_shutdown(cs);
break;
default:
if (action >= ACT_CMD && action < ACT_CMD + AT_NUM) {
*pp_command = at_state->bcs->commands[action - ACT_CMD];
if (!*pp_command) {
*p_genresp = 1;
*p_resp_code = RSP_NULL;
}
} else
dev_err(cs->dev, "%s: action==%d!\n", __func__, action);
}
}
int main(int argc, char *argv[])
{
struct configuration config;
int i;
const char *catalog_path;
struct result_queue *queue;
struct queryrunner *runner;
struct keygrab_data keygrab_data;
for(i=1; i<argc; i++) {
const char *arg = argv[i];
if(strcmp("--kill", arg)==0) {
return ocha_init_kill() ? 0:99;
}
}
ocha_init("ochad", argc, argv, TRUE/*has gui*/, &config);
if(ocha_init_ocha_is_running()) {
already_running();
return 89;
}
if(!ocha_init_create_socket()) {
return 71;
}
restart_register(argv[0]);
ocha_init_requires_catalog(config.catalog_path);
chdir(g_get_home_dir());
for(i=1; i<argc; i++) {
const char *arg = argv[i];
if(strncmp("--pid=", arg, strlen("--pid="))==0) {
const char *file=&arg[strlen("--pid=")];
pid_t pid = getpid();
FILE* pidh = fopen(file, "w");
if(pidh==NULL) {
fprintf(stderr, "error: cannot open pid file %s\n", file);
exit(14);
}
fprintf(pidh, "%d\n", pid);
fclose(pidh);
}
}
schedule_init(&config);
querywin_init();
catalog_path = config.catalog_path;
queue = querywin_get_result_queue();
runner=catalog_queryrunner_new(catalog_path, queue);
querywin_set_queryrunner(runner);
configure_keygrab(&keygrab_data);
gtk_main();
return 0;
}
void eventloop(tsocket main_fd, tsocket main_sctp_fd)
{
static uint32 child_count = 0;
static int conn_count = 0;
static RTSP_buffer *rtsp_list = NULL;
tsocket max_fd, fd = -1;
RTSP_buffer *p = NULL;
RTSP_proto rtsp_proto;
uint32 fd_found;
fd_set rset,wset;
//Init of scheduler
FD_ZERO(&rset);
FD_ZERO(&wset);
if (conn_count != -1) {
/* This is the process allowed for accepting new clients */
FD_SET(main_fd, &rset);
max_fd = main_fd;
}
/* Add all sockets of all sessions to fd_sets */
for (p = rtsp_list; p; p = p->next) {
rtsp_set_fdsets(p, &max_fd, &rset, &wset, NULL);
}
/* Stay here and wait for something happens */
if (select(max_fd+1, &rset, &wset, NULL, NULL) < 0) {
ERRORLOGG("select error in eventloop()");
/* Maybe we have to force exit here*/
return;
}
/* transfer data for any RTSP sessions */
schedule_connections(&rtsp_list, &conn_count, &rset, &wset, NULL);
/* handle new connections */
if (conn_count != -1) {
if (FD_ISSET(main_fd, &rset)) {
fd = tcp_accept(main_fd);
rtsp_proto = TCP;
}
// Handle a new connection
if (fd >= 0) {
for (fd_found = 0, p = rtsp_list; p != NULL; p = p->next) {
if (p->fd == fd) {
fd_found = 1;
break;
}
}
if (!fd_found) {
if (conn_count < ONE_FORK_MAX_CONNECTION) {
++conn_count;
// ADD A CLIENT
add_client(&rtsp_list, fd, rtsp_proto);
} else {
if (fork() == 0) {
// I'm the child
++child_count;
RTP_port_pool_init
(ONE_FORK_MAX_CONNECTION *
child_count * 2 +
RTP_DEFAULT_PORT);
if (schedule_init() == ERR_FATAL) {
FATALLOGG("Can't start schedule. Server is aborting");
return;
}
conn_count = 1;
rtsp_list = NULL;
add_client(&rtsp_list, fd, rtsp_proto);
} else {
// I'm the father
fd = -1;
conn_count = -1;
tcp_close(main_fd);
}
}
num_conn++;
INFOLOGG("Connection reached: %d", num_conn);
}
}
} // shawill: and... if not? END OF "HANDLE NEW CONNECTIONS"
}
int main(void)
{
char s[] = "1442936700,0,1,4,#2346W,3,#0800O#1900C#0900O#1800C"; // for str_processing test
RCC_ClocksTypeDef RCC_Clocks;
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_RNG, ENABLE);
RNG_Cmd(ENABLE);
/* Initialize the timer for dht11 */
tim_init(TIM2);
/* Initialize the SRAM ****************************************************/
PSRAM_Init();
/* Initialize the LCD *****************************************************/
LCD_Init();
LCD_LOG_Init();
LCD_LOG_SetHeader((uint8_t*)" Ethernet test");
LCD_LOG_SetFooter ((uint8_t*)" localtime: ");
/* Add your application code here */
/* Configure ethernet (GPIOs, clocks, MAC, DMA) */
ETH_BSP_Config();
/* Initilaize the LwIP stack */
LwIP_Init();
schedule_init(&schedule_got,schedule_string); // schedule string store in schedule_string
DNS_Init();
//while(!schedule_got); // wait until string got
LCD_DisplayStringLine(Line2, (uint8_t*)schedule_string);
LCD_DisplayStringLine(Line3, (uint8_t*)"0");
/* Main Loop */
//process ste str form internet
Str_Split(s, Init_time); // s is temp string
RTC_Config();
Time_Date_Setting(Init_time->year, Init_time->mon, Init_time->day, Init_time->hour +3, Init_time->min, Init_time->sec);
while (1)
{
uint8_t year, mon, day;
uint8_t hour, min, sec;
RTC_TimeTypeDef RTC_TimeStruct_main;
RTC_DateTypeDef RTC_DateStruct_main;
RTC_GetDate(RTC_Format_BIN, &RTC_DateStruct_main);
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStruct_main);
year = RTC_DateStruct_main.RTC_Year;
mon = RTC_DateStruct_main.RTC_Month;
day = RTC_DateStruct_main.RTC_Date;
hour = RTC_TimeStruct_main.RTC_Hours;
min = RTC_TimeStruct_main.RTC_Minutes;
sec = RTC_TimeStruct_main.RTC_Seconds;
//detect whether it is time to turn on Motor and LED, then execute it.
Soak(day, hour, min );
Water(day, hour, min, sec);
Light(mon, day, hour, min);
//detect over
/* check if any packet received */
if (ETH_CheckFrameReceived())
{
/* process received ethernet packet */
LwIP_Pkt_Handle();
}
/* handle periodic timers for LwIP */
LwIP_Periodic_Handle(LocalTime);
}
}
