/* @(/1/9/3/0) */
static QState QACCDetector_initial(QACCDetector * const me, QEvt const * const e) {
u8 curState;
static const QEvt acc_on_evt = {ACC_ON_SIG, 0};
static const QEvt acc_off_evt = {ACC_OFF_SIG, 0};
QS_SIG_DICTIONARY(ACC_ON_SIG, (void*)0);
QS_SIG_DICTIONARY(ACC_OFF_SIG, (void*)0);
QS_SIG_DICTIONARY(Q_TIMEOUT_SIG, me);
QS_SIG_DICTIONARY(ACC_ONCHANGE_SIG, me);
//初始化时，先广播一次ACC状态
curState = (u8)GET_ACC_STATE();
if(0 == curState)
{
TRACE_(QS_USER, NULL, "[ACC] state = ACC_ON");
QF_publish(&acc_on_evt, me);
}
else
{
TRACE_(QS_USER, NULL, "[ACC] state = ACC_OFF");
QF_publish(&acc_off_evt, me);
}
return Q_TRAN(&QACCDetector_idle);
}
/*..........................................................................*/
QState Philo_eating(Philo *me, QEvent const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
QTimeEvt_postIn(&me->timeEvt, (QActive *)me, EAT_TIME);
return Q_HANDLED();
}
case Q_EXIT_SIG: {
TableEvt *pe = Q_NEW(TableEvt, DONE_SIG);
pe->philoNum = PHILO_ID(me);
QF_publish((QEvent *)pe);
return Q_HANDLED();
}
case TIMEOUT_SIG: {
BSP_busyDelay();
return Q_TRAN(&Philo_thinking);
}
case EAT_SIG: /* intentionally fall-through */
case DONE_SIG: {
/* EAT or DONE must be for other Philos than this one */
Q_ASSERT(((TableEvt const *)e)->philoNum != PHILO_ID(me));
return Q_HANDLED();
}
}
return Q_SUPER(&QHsm_top);
}
/**
* \brief handle incoming echo request
*
* \param the incoming NewDataEvent
*/
void uip_icmp6_echo_request_input(NewDataEvent * e)
{
struct uip_icmp_hdr * icmp_hdr;
struct uip_tcpip_hdr * tcpip_hdr;
Neighbor_AO * neighbor;
static QEvent const pr_sig = { PACKET_RECEIVED_SIG};
static QEvent const ps_sig = { PACKET_SENT_SIG};
tcpip_hdr = ( struct uip_tcpip_hdr *) &e->buf[UIP_LLH_LEN];
icmp_hdr = (struct uip_icmp_hdr *)&e->buf[uip_l2_l3_hdr_len];
neighbor = uip_nd6_nbrcache_lookup(&tcpip_hdr->srcipaddr);
if (NULL != neighbor)
QActive_postFIFO((QActive *)neighbor, &pr_sig);
switch_eth_addr(e);
memcpy(&tcpip_hdr->destipaddr, &tcpip_hdr->srcipaddr, sizeof(uip_ipaddr_t));
memcpy(&tcpip_hdr->srcipaddr, &uip_hostaddr, sizeof(uip_ipaddr_t));
icmp_hdr->type = ICMP6_ECHO_REPLY;
icmp_hdr->icode = 0;
icmp_hdr->icmpchksum = 0;
icmp_hdr->icmpchksum = ~upper_layer_chksum6((unsigned char *) &e->buf);
e->super.sig = SEND_DATA_SIG;
QF_publish((QEvent *) e);
QActive_postFIFO((QActive *)neighbor, &ps_sig);
}
//void process_data_from_event(NewDataEvent *e)
int resolve_protocol_type(NewDataEvent *e)
{
struct uip_tcpip_hdr * tcpip_hdr;
struct uip_icmp_hdr * icmp_hdr;
int rtc;
tcpip_hdr = ( struct uip_tcpip_hdr *) &e->buf[UIP_LLH_LEN];
//only process IPV6 Packets
if (IP_VERSION_V6 != tcpip_hdr->vtc)
return ( IP_VERSION_NOT_SUPPORTED);
if ( !uip_is_multicast(tcpip_hdr->destipaddr) &&
!uip_is_hostaddr(&tcpip_hdr->destipaddr) ) {
e->super.sig = SEND_DATA_SIG;
QF_publish((QEvent *) e);
return ( IP_MULI_CAST_CHECK );
}
//if not multicast and not for my interfaces
//find target interface through prefix
//send to
if (tcpip_hdr->proto == UIP_PROTO_ICMP6) {
icmp_hdr = (struct uip_icmp_hdr *)&e->buf[uip_l2_l3_hdr_len];
switch(icmp_hdr->type) {
case ICMP6_NS:
uip_nd6_io_ns_input((NewDataEvent *)e);
break;
case ICMP6_NA:
uip_nd6_io_na_input((NewDataEvent *) e);
break;
case ICMP6_RA:
//uip_nd6_io_ra_input();
break;
case ICMP6_RS:
//uip_nd6_io_rs_input();
break;
case ICMP6_ECHO_REQUEST:
uip_icmp6_echo_request_input((NewDataEvent *)e);
break;
case ICMP6_ECHO_REPLY:
/** \note We don't implement any application callback for now */
uip_icmp6_echo_reply_input((NewDataEvent *)e);
printf("Received an icmp6 echo reply\n");
break;
default:
printf("Unknown icmp6 message type %d\n", icmp_hdr->type);
break;
}
rtc=UIP_PROTO_ICMP6;
}
if (tcpip_hdr->proto == UIP_PROTO_UDP)
rtc=UIP_PROTO_UDP;
return (rtc);
}
/* @(/1/7/6/1/3/2) .........................................................*/
static QState QCAN_ACC_Off(QCAN * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/7/6/1/3/2/0) */
case ACC_ON_SIG: {
status_ = Q_TRAN(&QCAN_ACC_On);
break;
}
/* @(/1/7/6/1/3/2/1) */
case PER_SECOND_SIG: {
if(1 == me->m_bRecvFrame)
{
if(me->m_ledFlashCnt++ % 3 == 0) //控制等闪烁，3s
{
CAN_FLASH_LED();
}
me->m_bRecvFrame = 0;
me->m_canfreeTicks = 0;
}
else
{
me->m_canfreeTicks ++;
// if(me->m_canfreeTicks > TIMEOUT_CAN_FREE_SECONDS)
// {
//请求CAN模块休眠
// static const QEvent sleep_Evt = {CAN_RXIDLE_TIMEOUT_SIG, 0};
// QACTIVE_POST(AO_Can, (QEvt*)&sleep_Evt, (void*)0);
CAN_LED_OFF();
// }
}
/* @(/1/7/6/1/3/2/1/0) */
if (me->m_canfreeTicks > TIMEOUT_CAN_FREE_SECONDS) {
//系统休眠条件：ACC OFF，CAN总线无数据时长超过指定时长
static const QEvent sleep_Evt = {SLEEP_REQ_SIG, 0};
QF_publish(&sleep_Evt, me); //广播睡眠请求消息，通知各个模块进入休眠态
TRACE_(QS_USER, NULL, "[CAN] ----- PowerMgr: SLEEP -----");
status_ = Q_TRAN(&QCAN_Sleep_Mode);
}
/* @(/1/7/6/1/3/2/1/1) */
else {
status_ = Q_HANDLED();
}
break;
}
default: {
status_ = Q_SUPER(&QCAN_non_conflicting);
break;
}
}
return status_;
}
void My_UI_KeyboardImpl_sendKey (My_UI_KeyboardImpl* mepl, char arg1) {
KeyEvent* ke;
if (arg1 == '0') {
ke = Q_NEW(KeyEvent, MY_CALC_DIGIT_0_SIG);
} else {
ke = Q_NEW(KeyEvent, MY_CALC_DIGIT_1_9_SIG);
}
ke->keyId = arg1;
QF_publish((QEvent*)ke);
}
bool CalculatorImpl_onError (CalculatorImpl* mepl) {
if (AttributeMapper_get(mepl, "TESTING")) { // for unit-testing
bool rv = AttributeMapper_get(mepl, "onError");
printf("%s.onError() == %s\n", mepl->machineName, AttributeMapper_booltostr(rv));
return rv;
} else {
bool rv = (strlen(mepl->errStat) > 0);
if (rv) {
printf("%s.onError() == %s\n", mepl->machineName, mepl->errStat);
ResultEvent* re = Q_NEW(ResultEvent, REPORTRESULT_SIG);
strcpy(re->result, mepl->errStat);
QF_publish((QEvent*)re);
}
return rv;
}
}
void UserEventTestImpl_userEventOnTrans (UserEventTestImpl* mepl, QEvent const* e, const char* arg2, double arg3) {
printf("%s.userEventOnTrans() received event signal '%hd', var value '%s', and literal '%lf'\n",
mepl->machineName, e->sig, arg2, arg3);
if (AttributeMapper_get(mepl, "FUNCTIONALITY")) {
// transfer e data to var, and save literal as new e data
DataEvent const* de = (DataEvent const*)e;
strncpy(mepl->var, de->data, MAX_DATA_SIZE);
// publish new data in e as test Ack event
DataEvent* newDE = Q_NEW(DataEvent, TEST_ACK_EV1_SIG);
sprintf(newDE->data, "%lf", arg3);
QF_publish((QEvent*)newDE);
} else {
// set var to literal
sprintf(mepl->var, "%lf", arg3);
}
}
//-----------------------------------------------------------------------------
/// Read for EMAC device
//-----------------------------------------------------------------------------
void
phy_dev_read(void)
{
unsigned int len;
unsigned char buf[UIP_CONF_BUFFER_SIZE+2];
NewDataEvent *e;
if( EMAC_RX_OK != EMAC_Poll( (unsigned char*)&buf,
UIP_CONF_BUFFER_SIZE,
&len) ) {
return;
}
e= Q_NEW(NewDataEvent, NEW_DATA_SIG);
e->len = len;
memcpy(e->buf, buf, sizeof(buf));
QF_publish((QEvent *) e);
}
/**
* \brief Send an ICMPv6 Echo Request to Neighbor
*
* \param Destination Neighbor_AO
*/
void uip_icmp6_echo_request_output_to_neighbor(Neighbor_AO * neighbor)
{
NewDataEvent *e;
struct uip_icmpip_hdr * icmpip_hdr;
static QEvent const ps_sig = { PACKET_SENT_SIG};
e= Q_NEW(NewDataEvent, SEND_DATA_SIG);
icmpip_hdr = ( struct uip_icmpip_hdr *) &e->buf[UIP_LLH_LEN];
set_eth_src_addr_local(e);
set_eth_dst_addr(e, &neighbor->lladdr);
/* IP header fields */
icmpip_hdr->vtc = 0x60;
icmpip_hdr->tcf = 0;
icmpip_hdr->flow = 0;
icmpip_hdr->proto = UIP_PROTO_ICMP6;
icmpip_hdr->ttl = UIP_ND6_HOP_LIMIT;
memcpy(&icmpip_hdr->destipaddr, &neighbor->ipaddr, sizeof(uip_ipaddr_t));
memcpy(&icmpip_hdr->srcipaddr, &uip_hostaddr, sizeof(uip_ipaddr_t));
icmpip_hdr->len[0] = 0; /* length will not be more than 255 */
icmpip_hdr->len[1] = UIP_ICMPH_LEN + UIP_ICMP_QUENCH_LEN+ 32;
e->len = UIP_LLH_LEN + UIP_IPH_LEN + UIP_ICMPH_LEN + UIP_ICMP_QUENCH_LEN + 32;
icmpip_hdr->type = ICMP6_ECHO_REQUEST;
icmpip_hdr->icode = 0;
//ICMP QUENCH
icmpip_hdr->id = htons(0x0002);
icmpip_hdr->seq = htons(neighbor->icmp_seq);
neighbor->icmp_seq++;
icmpip_hdr->icmpchksum = 0;
icmpip_hdr->icmpchksum = ~upper_layer_chksum6((unsigned char *) &e->buf);
QF_publish((QEvent *) e);
QActive_postFIFO((QActive *)neighbor, &ps_sig);
}
void CalculatorImpl_reportResult (CalculatorImpl* mepl) {
ResultEvent* re = Q_NEW(ResultEvent, REPORTRESULT_SIG);
sprintf(re->result, "%lf", mepl->result);
QF_publish((QEvent*)re);
}
void My_UI_KeyboardImpl_sendOperator (My_UI_KeyboardImpl* mepl, char arg1) {
KeyEvent* ke = Q_NEW(KeyEvent, MY_CALC_OPER_SIG);
ke->keyId = arg1;
QF_publish((QEvent*)ke);
}
int main(int argc, char* argv[])
{
char cmdBuf[SOCK_BUFF_SIZE];
printf("Quantum Test\nQEP %s\nQF %s, QF/Linux port %s\n",
QEP_getVersion(),
QF_getVersion(), QF_getPortVersion());
QF_init();
QF_psInit(subscrSto, Q_DIM(subscrSto));
QF_poolInit(poolArray, sizeof(poolArray), sizeof(GenEvt));
applicationStart(QSIZE);
for (;;)
{
// Get the incoming string command from the dmsTerminal or the GUI
receiveCmd(cmdBuf);
// Attempt to parse the command string for IMPL or ACTIVE calls
char tmpBuf[USER_ENTRY_SIZE];
char smName[USER_ENTRY_SIZE];
char attrName[USER_ENTRY_SIZE];
char valStr[USER_ENTRY_SIZE];
// scan for IMPL['SM'].set("attr", True/False), allowing blanks
// IMPL['trans'].set('guard', False)
int cnt = sscanf(strcpy(tmpBuf, cmdBuf),
"IMPL[%*['\"]%[^'\"]%*['\"]].set(%*['\"]%[^'\"]%*['\"],%[^)])",
smName, attrName, valStr);
if (cnt > 0) { // found an IMPL attribute setter!
setGuardAttribute(smName, attrName, valStr);
continue;
}
char *word;
word = strtok(cmdBuf, " ");
// We assume the first word contains the signal that is to be published,
// and the remaining words are data to be used to populate the event.
GenEvt *event;
int signal = strtoul(word, NULL, 10);
if (signal == DURING)
{
QF_tick();
QF_publish( Q_NEW(QEvent, DURING) );
}
else
{
event = Q_NEW(GenEvt, signal);
// Loop through the remaining words and populate the event
int i = 0;
do
{
word = strtok('\0', " ");
if (word)
{
Q_ASSERT(i<EVENT_SIZE);
event->data[i] = strtoul(word, NULL, 16);
}
i = i + 1;
} while (word);
QF_publish((QEvent *)event);
}
QF_run();
}
}
void My_UI_KeyboardImpl_sendPoint (My_UI_KeyboardImpl* mepl) {
KeyEvent* ke = Q_NEW(KeyEvent, MY_CALC_POINT_SIG);
ke->keyId = '.';
QF_publish((QEvent*)ke);
}
void My_UI_KeyboardImpl_powerOff (My_UI_KeyboardImpl* mepl) {
QF_publish((QEvent*)Q_NEW(KeyEvent, MY_CALC_POWEROFF_SIG));
}
void My_UI_KeyboardImpl_sendEquals (My_UI_KeyboardImpl* mepl) {
KeyEvent* ke = Q_NEW(KeyEvent, MY_CALC_EQUALS_SIG);
ke->keyId = '=';
QF_publish((QEvent*)ke);
}
void My_UI_KeyboardImpl_clearEntry (My_UI_KeyboardImpl* mepl) {
QF_publish((QEvent*)Q_NEW(KeyEvent, MY_CALC_CLEARENTRY_SIG));
}
void OperandXImpl_fraction (OperandXImpl* mepl) {
KeyEvent* ke = Q_NEW(KeyEvent, OPERANDCHANGED_SIG);
ke->keyId = '.';
QF_publish((QEvent*)ke);
}
void My_Calc_OperandXImpl_fraction (My_Calc_OperandXImpl* mepl) {
KeyEvent* ke = Q_NEW(KeyEvent, MY_CALC_OPERANDCHANGED_SIG);
ke->keyId = '.';
QF_publish((QEvent*)ke);
}
/* @(/1/9/3/2) .............................................................*/
static QState QACCDetector_busy(QACCDetector * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/1/9/3/2) */
case Q_ENTRY_SIG: {
me->m_detectTimes = 0;
//保持1S
QTimeEvt_postEvery(&me->m_Timer, &me->super, TIMEOUT_DETECTING);
status_ = Q_HANDLED();
break;
}
/* @(/1/9/3/2) */
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->m_Timer);
status_ = Q_HANDLED();
break;
}
/* @(/1/9/3/2/0) */
case Q_TIMEOUT_SIG: {
u8 curState = (u8)GET_ACC_STATE();
me->m_detectTimes++;
/* @(/1/9/3/2/0/0) */
if (curState != me->m_state) {
//状态发生变化，重新开始检测
status_ = Q_TRAN(&QACCDetector_busy);
}
/* @(/1/9/3/2/0/1) */
else {
me->m_state = curState;
/* @(/1/9/3/2/0/1/0) */
if (me->m_detectTimes >= DETECTING_KEPT_AMOUNT) {
static const QEvent acc_on_Evt = {ACC_ON_SIG, 0};
static const QEvent acc_off_Evt = {ACC_OFF_SIG, 0};
TaskEvt *pe;
if(me->m_state == 0)
{
TRACE_(QS_USER, NULL, "[ACC] state = ACC ON");
SetACCState(ACC_ON);
//广播ACC开电消息
QF_publish(&acc_on_Evt, me);
}
else
{
TRACE_(QS_USER, NULL, "[ACC] state = ACC OFF");
SetACCState(ACC_OFF);
//广播ACC关电消息
QF_publish(&acc_off_Evt, me);
}
/*
//上报服务器车辆状态
//1. 00为停车，FE为充电启动；FF为钥匙启动；
pe = Q_NEW(TaskEvt, NEW_TASKSENDREQ_SIG);
pe->cmd = EVS15_CMD_START_STOP_RPT; //命令字
pe->sequence = GeneratePacketSequenceNumber();
pe->ret = (me->m_state == 0) ? STATE_ACCON : STATE_STOP;
QACTIVE_POST(AO_Gprs, (QEvt*)pe, (void*)0);
*/
status_ = Q_TRAN(&QACCDetector_idle);
}
/* @(/1/9/3/2/0/1/1) */
else {
status_ = Q_HANDLED();
}
}
break;
}
/* @(/1/9/3/2/1) */
case ACC_ONCHANGE_SIG: {
//检测过程中收到ACC变化，重新检测
me->m_state = (u8)GET_ACC_STATE();
status_ = Q_TRAN(&QACCDetector_busy);
break;
}
default: {
status_ = Q_SUPER(&QHsm_top);
break;
}
}
return status_;
}
void My_Calc_OperandXImpl_insert (My_Calc_OperandXImpl* mepl, QEvent const* e) {
KeyEvent* ke = Q_NEW(KeyEvent, MY_CALC_OPERANDCHANGED_SIG);
ke->keyId = ((KeyEvent const*)e)->keyId;
QF_publish((QEvent*)ke);
}
