/**
* \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);
}
//${AOs::Philo::SM::eating} ..................................................
Q_STATE_DEF(Philo, eating) {
QP::QState status_;
switch (e->sig) {
//${AOs::Philo::SM::eating}
case Q_ENTRY_SIG: {
m_timeEvt.armX(eat_time(), 0U);
status_ = Q_RET_HANDLED;
break;
}
//${AOs::Philo::SM::eating}
case Q_EXIT_SIG: {
TableEvt *pe = Q_NEW(TableEvt, DONE_SIG);
pe->philoNum = PHILO_ID(this);
QP::QF::PUBLISH(pe, this);
(void)m_timeEvt.disarm();
status_ = Q_RET_HANDLED;
break;
}
//${AOs::Philo::SM::eating::TIMEOUT}
case TIMEOUT_SIG: {
status_ = tran(&thinking);
break;
}
//${AOs::Philo::SM::eating::EAT, DONE}
case EAT_SIG: // intentionally fall through
case DONE_SIG: {
// EAT or DONE must be for other Philos than this one
Q_ASSERT(Q_EVT_CAST(TableEvt)->philoNum != PHILO_ID(this));
status_ = Q_RET_HANDLED;
break;
}
default: {
status_ = super(&top);
break;
}
}
return status_;
}
//${Comp::Philo::SM::hungry} .................................................
Q_STATE_DEF(Philo, hungry) {
QP::QState status_;
switch (e->sig) {
//${Comp::Philo::SM::hungry}
case Q_ENTRY_SIG: {
TableEvt *pe = Q_NEW(TableEvt, HUNGRY_SIG);
pe->philo = this;
AO_Table->postLIFO(pe);
status_ = Q_RET_HANDLED;
break;
}
//${Comp::Philo::SM::hungry::EAT}
case EAT_SIG: {
status_ = tran(&eating);
break;
}
default: {
status_ = super(&top);
break;
}
}
return status_;
}
/*..........................................................................*/
QState Philo_hungry(Philo *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
TableEvt *pe = Q_NEW(TableEvt, HUNGRY_SIG);
pe->philoNum = PHILO_ID(me);
QACTIVE_POST(AO_Table, (QEvt *)pe, me);
return Q_HANDLED();
}
case EAT_SIG: {
if (((TableEvt const *)e)->philoNum == PHILO_ID(me)) {
BSP_busyDelay();
return Q_TRAN(&Philo_eating);
}
break;
}
case DONE_SIG: {
/* 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);
}
/* @(/2/0/9/1/2/12) ........................................................*/
QState CoffeeAO_coffeePotToggle(CoffeeAO * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/2/0/9/1/2/12) */
case Q_ENTRY_SIG: {
l_CoffeeAO.is_coffee_pot_in_machine = l_CoffeeAO.is_coffee_pot_in_machine == 0 ? 1 : 0;
QActive_postFIFO((QActive *)&l_CoffeeAO, Q_NEW(QEvent, GO_BACK_SIG));
status_ = Q_HANDLED();
break;
}
/* @(/2/0/9/1/2/12) */
case Q_EXIT_SIG: {
printf("toggled coffee pot in machine to: %u\n", l_CoffeeAO.is_coffee_pot_in_machine);
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&CoffeeAO_submenu);
break;
}
}
return status_;
}
//${AOs::Philo::SM::hungry} ..................................................
Q_STATE_DEF(Philo, hungry) {
QP::QState status_;
switch (e->sig) {
//${AOs::Philo::SM::hungry}
case Q_ENTRY_SIG: {
TableEvt *pe = Q_NEW(TableEvt, HUNGRY_SIG);
pe->philoNum = PHILO_ID(this);
AO_Table->POST(pe, this);
status_ = Q_RET_HANDLED;
break;
}
//${AOs::Philo::SM::hungry::EAT}
case EAT_SIG: {
//${AOs::Philo::SM::hungry::EAT::[Q_EVT_CAST(TableEvt)->philoNum=~}
if (Q_EVT_CAST(TableEvt)->philoNum == PHILO_ID(this)) {
status_ = tran(&eating);
}
else {
status_ = Q_RET_UNHANDLED;
}
break;
}
//${AOs::Philo::SM::hungry::DONE}
case DONE_SIG: {
/* DONE must be for other Philos than this one */
Q_ASSERT(Q_EVT_CAST(TableEvt)->philoNum != PHILO_ID(this));
status_ = Q_RET_HANDLED;
break;
}
default: {
status_ = super(&top);
break;
}
}
return status_;
}
//............................................................................
QState Philo::eating(Philo *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
me->m_timeEvt.postIn(me, EAT_TIME);
return Q_HANDLED();
}
case Q_EXIT_SIG: {
TableEvt *pe = Q_NEW(TableEvt, DONE_SIG);
pe->philoNum = PHILO_ID(me);
QF::PUBLISH(pe, me);
return Q_HANDLED();
}
case TIMEOUT_SIG: {
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);
}
/*..........................................................................*/
static void Cache_read(Cache *me, QEvent const *e)
{
CacheRWEvt *pe = (CacheRWEvt *)e;
CacheRWRly *re;
int reply = CACHE_READ_REPLY_SIG;
re = Q_NEW(CacheRWRly, reply);
QS_BEGIN(QS_CACHE_RW, QS_apObj_);
QS_U32_HEX(8, pe->sector);
QS_U32_HEX(8, pe->track);
QS_U32_HEX(4, pe->offset);
QS_U32_HEX(4, pe->len);
QS_U32_HEX(2, pe->flags);
QS_END();
Track_dispatch(pe->conf, e);
/* doing a fake bio finish */
re->conf = pe->conf;
re->errno = 0;
re->buf.bio.bi = pe->buf.bio.bi;
QACTIVE_POST(pe->ao, (QEvent *)re, AO_cache);
}
/*..........................................................................*/
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, me);
return Q_HANDLED();
}
case TIMEOUT_SIG: {
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);
}
// @(/3/0/2/3) ...............................................................
QP::QState Philo::eating(Philo * const me, QP::QEvt const * const e) {
QP::QState status_;
switch (e->sig) {
// @(/3/0/2/3)
case Q_ENTRY_SIG: {
me->m_timeEvt.armX(think_time());
status_ = Q_HANDLED();
break;
}
// @(/3/0/2/3)
case Q_EXIT_SIG: {
QP::QF::PUBLISH(Q_NEW(TableEvt, DONE_SIG, PHILO_ID(me)), me);
(void)me->m_timeEvt.disarm();
status_ = Q_HANDLED();
break;
}
// @(/3/0/2/3/0)
case TIMEOUT_SIG: {
status_ = Q_TRAN(&Philo::thinking);
break;
}
// @(/3/0/2/3/1)
case EAT_SIG: // intentionally fall through
case DONE_SIG: {
/* EAT or DONE must be for other Philos than this one */
Q_ASSERT(Q_EVT_CAST(TableEvt)->philoNum != PHILO_ID(me));
status_ = Q_HANDLED();
break;
}
default: {
status_ = Q_SUPER(&QHsm::top);
break;
}
}
return status_;
}
QP::QState Missile::exploding(Missile * const me, QP::QEvt const * const e) {
QP::QState status_;
switch (e->sig) {
// @(/3/2/4/3/0)
case TIME_TICK_SIG: {
// @(/3/2/4/3/0/0)
if ((me->m_x >= GAME_SPEED_X) && (me->m_exp_ctr < 15U)) {
++me->m_exp_ctr; // advance the explosion counter
me->m_x -= GAME_SPEED_X; // move the explosion by one step
// tell the Tunnel to render the current stage of Explosion
ObjectImageEvt *oie = Q_NEW(ObjectImageEvt, EXPLOSION_SIG);
oie->x = me->m_x + 3U; // x-pos of explosion
oie->y = (int8_t)((int)me->m_y - 4U); // y-pos
oie->bmp = EXPLOSION0_BMP + (me->m_exp_ctr >> 2);
AO_Tunnel->POST(oie, me);
status_ = QM_HANDLED();
}
// @(/3/2/4/3/0/1)
else {
status_ = QM_TRAN(&armed_s, QP::QMsm::s_emptyAction_);
}
break;
}
/*..........................................................................*/
QState Mine2_planted(Mine2 *me, QEvt const *e) {
uint8_t x;
uint8_t y;
uint8_t bmp;
switch (e->sig) {
case TIME_TICK_SIG: {
if (me->x >= GAME_SPEED_X) {
ObjectImageEvt *oie;
me->x -= GAME_SPEED_X; /* move the mine 1 step */
/* tell the Tunnel to draw the Mine */
oie = Q_NEW(ObjectImageEvt, MINE_IMG_SIG);
oie->x = me->x;
oie->y = me->y;
oie->bmp = MINE2_BMP;
QACTIVE_POST(AO_Tunnel, (QEvt *)oie, me);
}
else {
return Q_TRAN(&Mine2_unused);
}
return Q_HANDLED();
}
case SHIP_IMG_SIG: {
x = (uint8_t)((ObjectImageEvt const *)e)->x;
y = (uint8_t)((ObjectImageEvt const *)e)->y;
bmp = (uint8_t)((ObjectImageEvt const *)e)->bmp;
/* test for incoming Ship hitting this mine */
if (do_bitmaps_overlap(MINE2_BMP, me->x, me->y, bmp, x, y)) {
static MineEvt const mine2_hit = {
{ HIT_MINE_SIG, 0, 0 }, /* the QEvt base instance */
2 /* type of the mine (2 for type-2 mine) */
};
QACTIVE_POST(AO_Ship, (QEvt *)&mine2_hit, me);
/* go straight to 'disabled' and let the Ship do
* the exploding
*/
return Q_TRAN(&Mine2_unused);
}
return Q_HANDLED();
}
case MISSILE_IMG_SIG: {
x = (uint8_t)((ObjectImageEvt const *)e)->x;
y = (uint8_t)((ObjectImageEvt const *)e)->y;
bmp = (uint8_t)((ObjectImageEvt const *)e)->bmp;
/* test for incoming Missile hitting this mine */
/* NOTE: Mine type-2 is nastier than Mine type-1.
* The type-2 mine can hit the Ship with any of its
* "tentacles". However, it can be destroyed by the
* Missile only by hitting its center, defined as
* a smaller bitmap MINE2_MISSILE_BMP.
*/
if (do_bitmaps_overlap(MINE2_MISSILE_BMP,
me->x, me->y, bmp, x, y))
{
static ScoreEvt const mine2_destroyed = {
{ DESTROYED_MINE_SIG, 0, 0 },/*the QEvt base instance */
45 /* score for destroying Mine type-2 */
};
QACTIVE_POST(AO_Missile, (QEvt *)&mine2_destroyed, me);
return Q_TRAN(&Mine2_exploding);
}
return Q_HANDLED();
}
}
return Q_SUPER(&Mine2_used);
}
void PIOINT0_IRQHandler(void) {
/* for testing */
QACTIVE_POST(AO_Table, Q_NEW(QEvt, MAX_PUB_SIG), &l_PIOINT0_IRQHandler);
}
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_sendOperator (My_UI_KeyboardImpl* mepl, char arg1) {
KeyEvent* ke = Q_NEW(KeyEvent, MY_CALC_OPER_SIG);
ke->keyId = arg1;
QF_publish((QEvent*)ke);
}
/* ${AOs::Philo::SM::hungry} */
static QState Philo_hungry_e(Philo * const me) {
TableEvt *pe = Q_NEW(TableEvt, HUNGRY_SIG);
pe->philoNum = PHILO_ID(me);
QACTIVE_POST(AO_Table, &pe->super, me);
return QM_ENTRY(&Philo_hungry_s);
}
static QState Ship_flying(Ship * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/2/1/4/1/3/0) */
case TIME_TICK_SIG: {
/* tell the Tunnel to draw the Ship and test for hits */
ObjectImageEvt *oie = Q_NEW(ObjectImageEvt, SHIP_IMG_SIG);
oie->x = me->x;
oie->y = me->y;
oie->bmp = SHIP_BMP;
QACTIVE_POST(AO_Tunnel, (QEvt *)oie, me);
++me->score; /* increment the score for surviving another tick */
if ((me->score % 10U) == 0U) { /* is the score "round"? */
ScoreEvt *sev = Q_NEW(ScoreEvt, SCORE_SIG);
sev->score = me->score;
QACTIVE_POST(AO_Tunnel, (QEvt *)sev, me);
}
status_ = QM_HANDLED();
break;
}
/* @(/2/1/4/1/3/1) */
case PLAYER_TRIGGER_SIG: {
ObjectPosEvt *ope = Q_NEW(ObjectPosEvt, MISSILE_FIRE_SIG);
ope->x = me->x;
ope->y = me->y + SHIP_HEIGHT - 1U;
QACTIVE_POST(AO_Missile, (QEvt *)ope, me);
status_ = QM_HANDLED();
break;
}
/* @(/2/1/4/1/3/2) */
case DESTROYED_MINE_SIG: {
me->score += Q_EVT_CAST(ScoreEvt)->score;
/* the score will be sent to the Tunnel by the next TIME_TICK */
status_ = QM_HANDLED();
break;
}
/* @(/2/1/4/1/3/3) */
case HIT_WALL_SIG: {
static QActionHandler const act_[] = {
Q_ACTION_CAST(&Ship_exploding_e),
Q_ACTION_CAST(0)
};
status_ = QM_TRAN(&Ship_exploding_s, &act_[0]);
break;
}
/* @(/2/1/4/1/3/4) */
case HIT_MINE_SIG: {
static QActionHandler const act_[] = {
Q_ACTION_CAST(&Ship_exploding_e),
Q_ACTION_CAST(0)
};
status_ = QM_TRAN(&Ship_exploding_s, &act_[0]);
break;
}
default: {
status_ = QM_SUPER();
break;
}
}
return status_;
}
const DC3Error_t DB_write(
const DC3DBElem_t elem,
const DC3AccessType_t accessType,
const size_t bufSize,
const uint8_t* const pBuffer
)
{
DC3Error_t status = ERR_NONE; /* keep track of success/failure of operations. */
/* 1. Find where the element lives */
DB_ElemLoc_t loc = settingsDB[elem].loc;
/* 2. Call the location dependent functions to write the data to DB */
switch( loc ) {
case DB_EEPROM:
if ( _DC3_ACCESS_BARE == accessType ) {
uint16_t bytesWritten = 0;
status = I2C_writeDevMem(
accessType, // const DC3AccessType_t accessType,
DB_I2C_devices[loc], // const DC3I2CDevice_t iDev,
settingsDB[elem].offset, // const uint16_t offset,
settingsDB[elem].size, // const uint16_t bytesToWrite,
bufSize, // const uint16_t bufSize
pBuffer, // const uint8_t* const pBuffer
&bytesWritten // uint16_t* pBytesWritten
);
if ( ERR_NONE == status ) { /* Only check length if no error */
if ( bytesWritten != settingsDB[elem].size ) {
status = ERR_DB_ELEM_LENGTH_WRITE_MISMATCH;
goto DB_write_ERR_HANDLE; /* Stop and jump to error handling */
}
}
} else {
/* Create the event and directly post it to the right AO. */
I2CWriteReqEvt *i2cWriteReqEvt = Q_NEW(I2CWriteReqEvt, I2C1_DEV_RAW_MEM_WRITE_SIG);
i2cWriteReqEvt->i2cDev = DB_getI2CDev(loc);
i2cWriteReqEvt->start = settingsDB[elem].offset;
i2cWriteReqEvt->bytes = settingsDB[elem].size;
i2cWriteReqEvt->accessType = accessType;
MEMCPY(i2cWriteReqEvt->dataBuf, pBuffer, i2cWriteReqEvt->bytes);
QACTIVE_POST(AO_I2C1DevMgr, (QEvt *)(i2cWriteReqEvt), SysMgr_AO);
}
break;
case DB_SN_ROM: /* Fall through intentionally */
case DB_UI_ROM: /* Fall through intentionally */
case DB_GPIO: /* Fall through intentionally */
case DB_FLASH: /* Fall through intentionally */
status = ERR_DB_ELEM_IS_READ_ONLY;
goto DB_write_ERR_HANDLE;
break;
/* Add more locations here. Anything that fails will go to the default
* case and get logged as an error. */
default:
status = ERR_DB_ELEM_NOT_FOUND;
goto DB_write_ERR_HANDLE;
break;
}
DB_write_ERR_HANDLE: /* Handle any error that may have occurred. */
ERR_COND_OUTPUT( status, accessType,
"DB write of element %s (%d) to DB: Error 0x%08x\n",
CON_dbElemToStr( elem ), elem, status );
return( status );
}
const DC3Error_t DB_initToDefault( const DC3AccessType_t accessType )
{
DC3Error_t status = ERR_NONE; /* keep track of success/failure */
switch( accessType ) {
case _DC3_ACCESS_BARE:
status = DB_write(
_DC3_DB_MAGIC_WORD,
accessType,
sizeof(DB_defaultEepromSettings.dbMagicWord),
(uint8_t *)&DB_defaultEepromSettings.dbMagicWord
);
if ( ERR_NONE != status ) {
goto DB_initToDefault_ERR_HANDLE;
}
status = DB_write(
_DC3_DB_VERSION,
accessType,
sizeof(DB_defaultEepromSettings.dbVersion),
(uint8_t *)&DB_defaultEepromSettings.dbVersion
);
if ( ERR_NONE != status ) {
goto DB_initToDefault_ERR_HANDLE;
}
status = DB_write(
_DC3_DB_IP_ADDR,
accessType,
sizeof(DB_defaultEepromSettings.ipAddr),
(uint8_t *)&DB_defaultEepromSettings.ipAddr
);
if ( ERR_NONE != status ) {
goto DB_initToDefault_ERR_HANDLE;
}
break; /* end of case _DC3_ACCESS_BARE */
case _DC3_ACCESS_QPC:{;
/* Create the event and directly post it to the right AO. */
I2CWriteReqEvt *i2cWriteReqEvt = Q_NEW(I2CWriteReqEvt, I2C1_DEV_RAW_MEM_WRITE_SIG);
i2cWriteReqEvt->i2cDev = DB_getI2CDev(_DC3_DB_MAGIC_WORD);
i2cWriteReqEvt->start = DB_getElemOffset(_DC3_DB_MAGIC_WORD);
i2cWriteReqEvt->bytes = sizeof(DB_defaultEepromSettings);
i2cWriteReqEvt->accessType = accessType;
MEMCPY(i2cWriteReqEvt->dataBuf, &DB_defaultEepromSettings, sizeof(DB_defaultEepromSettings));
QACTIVE_POST(AO_I2C1DevMgr, (QEvt *)(i2cWriteReqEvt), SysMgr_AO);
goto DB_initToDefault_ERR_HANDLE; /* Stop and jump to error handling */
}
break; /* end of case ACCESS_QPC */
case _DC3_ACCESS_FRT:
status = ERR_UNIMPLEMENTED;
goto DB_initToDefault_ERR_HANDLE; /* Stop and jump to error handling */
break; /* end of case ACCESS_FREERTOS */
default:
status = ERR_UNIMPLEMENTED;
goto DB_initToDefault_ERR_HANDLE; /* Stop and jump to error handling */
break; /* end of default case */
} /* End of switch statement */
DB_initToDefault_ERR_HANDLE: /* Handle any error that may have occurred. */
ERR_COND_OUTPUT( status, accessType,
"Initializing DB to default: Error 0x%08x\n",
status );
return( status );
}
//............................................................................
QState Table::serving(Table *me, QEvt const *e) {
uint8_t n, m;
TableEvt *pe;
switch (e->sig) {
case Q_ENTRY_SIG: {
displyTableStat("serving");
for (n = 0; n < N_PHILO; ++n) { // give permissions to eat...
if (me->m_isHungry[n]
&& (me->m_fork[LEFT(n)] == FREE)
&& (me->m_fork[n] == FREE))
{
me->m_fork[LEFT(n)] = me->m_fork[n] = USED;
pe = Q_NEW(TableEvt, EAT_SIG);
pe->philoNum = n;
QF::PUBLISH(pe, me);
me->m_isHungry[n] = 0;
displyPhilStat(n, "eating ");
}
}
return Q_HANDLED();
}
case HUNGRY_SIG: {
n = ((TableEvt *)e)->philoNum;
Q_ASSERT(n < N_PHILO && !me->m_isHungry[n]);
displyPhilStat(n, "hungry ");
m = LEFT(n);
if (me->m_fork[m] == FREE && me->m_fork[n] == FREE) {
me->m_fork[m] = me->m_fork[n] = USED;
pe = Q_NEW(TableEvt, EAT_SIG);
pe->philoNum = n;
QF::PUBLISH(pe, me);
displyPhilStat(n, "eating ");
}
else {
me->m_isHungry[n] = 1;
}
return Q_HANDLED();
}
case DONE_SIG: {
n = ((TableEvt *)e)->philoNum;
Q_ASSERT(n < N_PHILO);
displyPhilStat(n, "thinking");
me->m_fork[LEFT(n)] = me->m_fork[n] = FREE;
m = RIGHT(n); // check the right neighbor
if (me->m_isHungry[m] && me->m_fork[m] == FREE) {
me->m_fork[n] = me->m_fork[m] = USED;
me->m_isHungry[m] = 0;
pe = Q_NEW(TableEvt, EAT_SIG);
pe->philoNum = m;
QF::PUBLISH(pe, me);
displyPhilStat(m, "eating ");
}
m = LEFT(n); // check the left neighbor
n = LEFT(m);
if (me->m_isHungry[m] && me->m_fork[n] == FREE) {
me->m_fork[m] = me->m_fork[n] = USED;
me->m_isHungry[m] = 0;
pe = Q_NEW(TableEvt, EAT_SIG);
pe->philoNum = m;
QF::PUBLISH(pe, me);
displyPhilStat(m, "eating ");
}
return Q_HANDLED();
}
case PAUSE_SIG: // "Toggle" button pressed
case KEY_CENTER_PRESS_SIG: { // hardkey CENTER pressed
return Q_TRAN(&Table::paused);
}
}
return Q_SUPER(&Table::ready);
}
/* ${AOs::Philo::SM::eating} */
static QState Philo_eating_x(Philo * const me) {
TableEvt *pe = Q_NEW(TableEvt, DONE_SIG);
pe->philoNum = PHILO_ID(me);
QF_PUBLISH(&pe->super, me);
return QM_EXIT(&Philo_eating_s);
}
/* @(/2/0/9/1/1) ...........................................................*/
QState CoffeeAO_menu(CoffeeAO * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/2/0/9/1/1/0) */
case ADWHEEL_SIG: {
// calculate current menu entry
char menu_text[20];
struct Entry* menu_entry = &menu_entries[me->current_menu_index];
me->current_menu_index = ((AdEvt*)e)->val * me->max_menu_index / 1024;
lcd_clear();
set_cursor(0, 0);
switch (menu_entry->interpolate_with) {
case NOTHING:
strcpy(menu_text, menu_entry->menu_label);
break;
case BREW_STRENGTH:
sprintf(menu_text, menu_entry->menu_label, l_CoffeeAO.current_brew_strength + 1);
break;
case IS_COFFEE_POT_IN_MACHINE:
sprintf(menu_text, menu_entry->menu_label, l_CoffeeAO.is_coffee_pot_in_machine);
break;
case IS_AUTOMATIC_BREW_ACTIVE:
sprintf(menu_text, menu_entry->menu_label, l_CoffeeAO.is_automatic_brew_active);
break;
}
lcd_print(menu_text);
set_cursor(4, 1);
sprintf(menu_text, "%02u:%02u:%02u", l_CoffeeAO.alarm.real_current_time.hours, l_CoffeeAO.alarm.real_current_time.minutes, l_CoffeeAO.alarm.real_current_time.seconds);
lcd_print(menu_text);
status_ = Q_HANDLED();
break;
}
/* @(/2/0/9/1/1/1) */
case INT_SIG: {
QEvent *menuEvt = Q_NEW(QEvent, menu_entries[me->current_menu_index].signal);
//QEvent *menuEvt = Q_NEW(QEvent, GO_COFFEE_POT_TOGGLE_SIG);
QF_INT_ENABLE();
QActive_postFIFO((QActive *)&l_CoffeeAO, menuEvt);
QF_INT_DISABLE();
status_ = Q_HANDLED();
break;
}
/* @(/2/0/9/1/1/2) */
case GO_COFFEE_POT_TOGGLE_SIG: {
status_ = Q_TRAN(&CoffeeAO_coffeePotToggle);
break;
}
/* @(/2/0/9/1/1/3) */
case GO_TIME_BREW_TOGGLE_SIG: {
status_ = Q_TRAN(&CoffeeAO_timeBrewActivatedToggle);
break;
}
/* @(/2/0/9/1/1/4) */
case GO_SET_BREW_TIME_CLOCK_SIG: {
status_ = Q_TRAN(&CoffeeAO_set_brew_h1);
break;
}
/* @(/2/0/9/1/1/5) */
case GO_SET_TIME_OF_DAY_SIG: {
status_ = Q_TRAN(&CoffeeAO_set_clock_h1);
break;
}
/* @(/2/0/9/1/1/6) */
case GO_START_BREWING_SIG: {
status_ = Q_TRAN(&CoffeeAO_startBrewingNow);
break;
}
/* @(/2/0/9/1/1/7) */
case GO_SET_BREW_STRENGTH_SIG: {
status_ = Q_TRAN(&CoffeeAO_setBrewStrength);
break;
}
default: {
status_ = Q_SUPER(&CoffeeAO_coffeemachine);
break;
}
}
return status_;
}
/* @(/2/4/3/2/1) ...........................................................*/
static QState Mine2_planted(Mine2 * const me, QEvt const * const e) {
QState status_;
switch (e->sig) {
/* @(/2/4/3/2/1/0) */
case TIME_TICK_SIG: {
/* @(/2/4/3/2/1/0/0) */
if (me->x >= GAME_SPEED_X) {
ObjectImageEvt *oie;
me->x -= GAME_SPEED_X; /* move the mine 1 step */
/* tell the Tunnel to draw the Mine */
oie = Q_NEW(ObjectImageEvt, MINE_IMG_SIG);
oie->x = me->x;
oie->y = me->y;
oie->bmp = MINE2_BMP;
QACTIVE_POST(AO_Tunnel, (QEvt *)oie, me);
status_ = QM_HANDLED();
}
/* @(/2/4/3/2/1/0/1) */
else {
static QActionHandler const act_[] = {
Q_ACTION_CAST(&Mine2_used_x),
Q_ACTION_CAST(0)
};
status_ = QM_TRAN(&Mine2_unused_s, &act_[0]);
}
break;
}
/* @(/2/4/3/2/1/1) */
case SHIP_IMG_SIG: {
uint8_t x = Q_EVT_CAST(ObjectImageEvt)->x;
uint8_t y = Q_EVT_CAST(ObjectImageEvt)->y;
uint8_t bmp = Q_EVT_CAST(ObjectImageEvt)->bmp;
/* @(/2/4/3/2/1/1/0) */
if (do_bitmaps_overlap(MINE2_BMP, me->x, me->y, bmp, x, y)) {
static QActionHandler const act_[] = {
Q_ACTION_CAST(&Mine2_used_x),
Q_ACTION_CAST(0)
};
static MineEvt const mine1_hit = {
{ HIT_MINE_SIG, 0U, 0U }, /* the QEvt base instance */
2U /* type of the mine (2 for Mine type-2) */
};
QACTIVE_POST(AO_Ship, (QEvt *)&mine1_hit, me);
/* go straight to 'disabled' and let the Ship do
* the exploding */
status_ = QM_TRAN(&Mine2_unused_s, &act_[0]);
}
else {
status_ = QM_UNHANDLED();
}
break;
}
/* @(/2/4/3/2/1/2) */
case MISSILE_IMG_SIG: {
uint8_t x = Q_EVT_CAST(ObjectImageEvt)->x;
uint8_t y = Q_EVT_CAST(ObjectImageEvt)->y;
uint8_t bmp = Q_EVT_CAST(ObjectImageEvt)->bmp;
/* @(/2/4/3/2/1/2/0) */
if (do_bitmaps_overlap(MINE2_MISSILE_BMP, me->x, me->y, bmp, x, y)) {
static QActionHandler const act_[] = {
Q_ACTION_CAST(&Mine2_exploding_e),
Q_ACTION_CAST(0)
};
/* NOTE: Mine type-2 is nastier than Mine type-1.
* The type-2 mine can hit the Ship with any of its
* "tentacles". However, it can be destroyed by the
* Missile only by hitting its center, defined as
* a smaller bitmap MINE2_MISSILE_BMP.
*/
static ScoreEvt const mine2_destroyed = {
{ DESTROYED_MINE_SIG, 0U, 0U }, /* the QEvt base instance */
45U /* score for destroying Mine type-2 */
};
QACTIVE_POST(AO_Missile, (QEvt *)&mine2_destroyed, me);
status_ = QM_TRAN(&Mine2_exploding_s, &act_[0]);
}
else {
status_ = QM_UNHANDLED();
}
break;
}
default: {
status_ = QM_SUPER();
break;
}
}
return status_;
}
//${AOs::Table::SM::active::serving} .........................................
QP::QState Table::serving(Table * const me, QP::QEvt const * const e) {
QP::QState status_;
switch (e->sig) {
// ${AOs::Table::SM::active::serving}
case Q_ENTRY_SIG: {
for (uint8_t n = 0U; n < N_PHILO; ++n) { // give permissions to eat...
if (me->m_isHungry[n]
&& (me->m_fork[LEFT(n)] == FREE)
&& (me->m_fork[n] == FREE))
{
me->m_fork[LEFT(n)] = USED;
me->m_fork[n] = USED;
TableEvt *te = Q_NEW(TableEvt, EAT_SIG);
te->philoNum = n;
AO_Philo[n]->POST(te, me);
me->m_isHungry[n] = false;
BSP::displayPhilStat(n, EATING);
}
}
status_ = Q_HANDLED();
break;
}
// ${AOs::Table::SM::active::serving::HUNGRY}
case HUNGRY_SIG: {
uint8_t n = Q_EVT_CAST(TableEvt)->philoNum;
// phil ID must be in range and he must be not hungry
Q_ASSERT((n < N_PHILO) && (!me->m_isHungry[n]));
BSP::displayPhilStat(n, HUNGRY);
uint8_t m = LEFT(n);
// ${AOs::Table::SM::active::serving::HUNGRY::[bothfree]}
if ((me->m_fork[m] == FREE) && (me->m_fork[n] == FREE)) {
me->m_fork[m] = USED;
me->m_fork[n] = USED;
TableEvt *pe = Q_NEW(TableEvt, EAT_SIG);
pe->philoNum = n;
QP::QF::PUBLISH(pe, me);
BSP::displayPhilStat(n, EATING);
status_ = Q_HANDLED();
}
// ${AOs::Table::SM::active::serving::HUNGRY::[else]}
else {
me->m_isHungry[n] = true;
status_ = Q_HANDLED();
}
break;
}
// ${AOs::Table::SM::active::serving::DONE}
case DONE_SIG: {
uint8_t n = Q_EVT_CAST(TableEvt)->philoNum;
// phil ID must be in range and he must be not hungry
Q_ASSERT((n < N_PHILO) && (!me->m_isHungry[n]));
BSP::displayPhilStat(n, THINKING);
uint8_t m = LEFT(n);
// both forks of Phil[n] must be used
Q_ASSERT((me->m_fork[n] == USED) && (me->m_fork[m] == USED));
me->m_fork[m] = FREE;
me->m_fork[n] = FREE;
m = RIGHT(n); // check the right neighbor
if (me->m_isHungry[m] && (me->m_fork[m] == FREE)) {
me->m_fork[n] = USED;
me->m_fork[m] = USED;
me->m_isHungry[m] = false;
TableEvt *pe = Q_NEW(TableEvt, EAT_SIG);
pe->philoNum = m;
QP::QF::PUBLISH(pe, me);
BSP::displayPhilStat(m, EATING);
}
m = LEFT(n); // check the left neighbor
n = LEFT(m); // left fork of the left neighbor
if (me->m_isHungry[m] && (me->m_fork[n] == FREE)) {
me->m_fork[m] = USED;
me->m_fork[n] = USED;
me->m_isHungry[m] = false;
TableEvt *pe = Q_NEW(TableEvt, EAT_SIG);
pe->philoNum = m;
QP::QF::PUBLISH(pe, me);
BSP::displayPhilStat(m, EATING);
}
status_ = Q_HANDLED();
break;
}
// ${AOs::Table::SM::active::serving::EAT}
case EAT_SIG: {
Q_ERROR();
status_ = Q_HANDLED();
break;
}
// ${AOs::Table::SM::active::serving::PAUSE}
case PAUSE_SIG: {
status_ = Q_TRAN(&paused);
break;
}
default: {
status_ = Q_SUPER(&active);
break;
}
}
return status_;
}
const DC3Error_t DB_read(
const DC3DBElem_t elem,
const DC3AccessType_t accessType,
const size_t bufSize,
uint8_t* pBuffer
)
{
DC3Error_t status = ERR_NONE; /* keep track of success/failure */
/* 1. Find where the element lives */
DB_ElemLoc_t loc = settingsDB[elem].loc;
/* 2. Call the location dependent functions to retrieve the data from DB */
switch( loc ) {
case DB_EEPROM: /* Intentionally fall through */
case DB_SN_ROM: /* Intentionally fall through */
case DB_UI_ROM:
if ( _DC3_ACCESS_BARE == accessType ) {
uint16_t bytesRead = 0;
status = I2C_readDevMem(
accessType, // const DC3AccessType_t accType,
DB_I2C_devices[loc], // const DC3I2CDevice_t iDev,
settingsDB[elem].offset, // const uint16_t offset,
settingsDB[elem].size, // const uint16_t bytesToRead,
bufSize, // const uint8_t bufSize
pBuffer, // uint8_t* const pBuffer,
&bytesRead // uint16_t* pBytesRead
);
if ( ERR_NONE == status ) { /* Only check length if no error */
if ( bytesRead != settingsDB[elem].size ) {
status = ERR_DB_ELEM_LENGTH_READ_MISMATCH;
goto DB_read_ERR_HANDLE; /* Stop and jump to error handling */
}
}
} else {
/* Create the event and directly post it to the right AO. */
I2CReadReqEvt *i2cReadReqEvt = Q_NEW(I2CReadReqEvt, I2C1_DEV_RAW_MEM_READ_SIG);
i2cReadReqEvt->i2cDev = DB_getI2CDev(loc);
i2cReadReqEvt->start = settingsDB[elem].offset;
i2cReadReqEvt->bytes = settingsDB[elem].size;
i2cReadReqEvt->accessType = accessType;
QACTIVE_POST(AO_I2C1DevMgr, (QEvt *)(i2cReadReqEvt), SysMgr_AO);
}
break;
case DB_GPIO:
status = ERR_UNIMPLEMENTED;
goto DB_read_ERR_HANDLE; /* Stop and jump to error handling */
break;
case DB_FLASH:
; // need this or we get "a label can only be part of a statement and
// a declaration is not a statement" compile error
uint16_t resultLen = 0;
status = DB_readFlash(
elem,
accessType,
bufSize,
pBuffer,
&resultLen
);
break;
/* Add more locations here. Anything that fails will go to the default
* case and get logged as an error. */
default:
status = ERR_DB_ELEM_NOT_FOUND;
goto DB_read_ERR_HANDLE; /* Stop and jump to error handling */
break;
}
DB_read_ERR_HANDLE: /* Handle any error that may have occurred. */
ERR_COND_OUTPUT( status, accessType,
"DB read of element %s (%d) from DB: Error 0x%08x\n",
CON_dbElemToStr( elem ), elem, status );
return( status );
}
void My_UI_KeyboardImpl_clearEntry (My_UI_KeyboardImpl* mepl) {
QF_publish((QEvent*)Q_NEW(KeyEvent, MY_CALC_CLEARENTRY_SIG));
}
const DC3Error_t DB_readFlash(
const DC3DBElem_t elem,
const DC3AccessType_t accessType,
const size_t bufSize,
uint8_t* pBuffer,
uint16_t* pResultLen
)
{
DC3Error_t status = ERR_NONE;
/* Make sure the element is in flash */
if( !DB_IS_ELEM_IN_FLASH(elem) ) {
status = ERR_DB_ELEM_IS_NOT_IN_FLASH;
goto DB_readFlash_ERR_HANDLE; /* Stop and jump to error handling */
}
switch ( accessType ) {
case _DC3_ACCESS_QPC: /* Intentionally fall through */
case _DC3_ACCESS_FRT: {
DBReadDoneEvt *evt = Q_NEW(DBReadDoneEvt, DB_FLASH_READ_DONE_SIG);
evt->dbElem = elem;
evt->status = ERR_NONE;
/* Both evt->status and status should be assigned here */
evt->status = status = FLASH_readBufferUint8(
settingsDB[elem].offset,
settingsDB[elem].size,
MAX_DB_ELEM_SIZE,
evt->dataBuf,
(uint16_t *)&(evt->dataLen)
);
QACTIVE_POST(AO_SysMgr, (QEvt *)evt, AO_SysMgr);
break;
}
case _DC3_ACCESS_BARE:
if ( bufSize < settingsDB[elem].size ) {
status = ERR_MEM_BUFFER_LEN;
goto DB_readFlash_ERR_HANDLE; /* Stop and jump to error handling */
}
if ( NULL == pBuffer ) {
status = ERR_MEM_NULL_VALUE;
goto DB_readFlash_ERR_HANDLE; /* Stop and jump to error handling */
}
status = FLASH_readBufferUint8(
settingsDB[elem].offset,
settingsDB[elem].size,
bufSize,
pBuffer,
pResultLen
);
break;
default:
status = ERR_INVALID_ACCESS_TYPE;
goto DB_readFlash_ERR_HANDLE; /* Stop and jump to error handling */
break;
}
DB_readFlash_ERR_HANDLE: /* Handle any error that may have occurred */
ERR_COND_OUTPUT( status, accessType,
"Reading from Flash DB element %s (%d): Error 0x%08x \n",
CON_dbElemToStr( elem ), elem, status );
return( status );
}
void My_UI_KeyboardImpl_powerOff (My_UI_KeyboardImpl* mepl) {
QF_publish((QEvent*)Q_NEW(KeyEvent, MY_CALC_POWEROFF_SIG));
}
// @(/2/1/5/1/3) .............................................................
QP::QState Ship::flying(Ship * const me, QP::QEvt const * const e) {
QP::QState status;
switch (e->sig) {
// @(/2/1/5/1/3)
case Q_ENTRY_SIG: {
me->m_score = 0U; /* reset the score */
ScoreEvt *sev = Q_NEW(ScoreEvt, SCORE_SIG);
sev->score = me->m_score;
AO_Tunnel->POST(sev, me);
status = Q_HANDLED();
break;
}
// @(/2/1/5/1/3/0)
case TIME_TICK_SIG: {
// tell the Tunnel to draw the Ship and test for hits
ObjectImageEvt *oie = Q_NEW(ObjectImageEvt, SHIP_IMG_SIG);
oie->x = me->m_x;
oie->y = me->m_y;
oie->bmp = SHIP_BMP;
AO_Tunnel->POST(oie, me);
++me->m_score; // increment the score for surviving another tick
if ((me->m_score % 10U) == 0U) { // is the score "round"?
ScoreEvt *sev = Q_NEW(ScoreEvt, SCORE_SIG);
sev->score = me->m_score;
AO_Tunnel->POST(sev, me);
}
status = Q_HANDLED();
break;
}
// @(/2/1/5/1/3/1)
case PLAYER_TRIGGER_SIG: {
ObjectPosEvt *ope = Q_NEW(ObjectPosEvt, MISSILE_FIRE_SIG);
ope->x = me->m_x;
ope->y = me->m_y + SHIP_HEIGHT - 1U;
AO_Missile->POST(ope, me);
status = Q_HANDLED();
break;
}
// @(/2/1/5/1/3/2)
case DESTROYED_MINE_SIG: {
me->m_score += Q_EVT_CAST(ScoreEvt)->score;
// the score will be sent to the Tunnel by the next TIME_TICK
status = Q_HANDLED();
break;
}
// @(/2/1/5/1/3/3)
case HIT_WALL_SIG: {
status = Q_TRAN(&Ship::exploding);
break;
}
// @(/2/1/5/1/3/4)
case HIT_MINE_SIG: {
status = Q_TRAN(&Ship::exploding);
break;
}
default: {
status = Q_SUPER(&Ship::active);
break;
}
}
return status;
}
void My_UI_KeyboardImpl_sendEquals (My_UI_KeyboardImpl* mepl) {
KeyEvent* ke = Q_NEW(KeyEvent, MY_CALC_EQUALS_SIG);
ke->keyId = '=';
QF_publish((QEvent*)ke);
}
