/*..........................................................................*/
int main() {
Blinky_ctor(); /* instantiate the Blinky AO */
BSP_init(); /* initialize the board */
return QF_run(); /* transfer control to QF-nano */
}
/*..........................................................................*/
int main (void) {
Sensor_ctor();
BSP_init(); /* initialize the board */
return QF_run(); /* transfer control to QF-nano */
}
/*..........................................................................*/
int main(int argc, char *argv[]) {
UI_ctor(); /* instantiate the UI Active Object */
BSP_init(argc, argv); /* initialize the Board Support Package */
QF_init(); /* initialize the framework and the underlying RT kernel */
/* initialize the event pools... */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
// QF_poolInit(l_medPoolSto, sizeof(l_medPoolSto), sizeof(l_medPoolSto[0]));
QF_psInit(l_subscrSto, Q_DIM(l_subscrSto)); /* init publish-subscribe */
/* setup the QS filters... */
/* send object dictionaries for event queues... */
QS_OBJ_DICTIONARY(l_uiQueueSto);
/* send object dictionaries for event pools... */
QS_OBJ_DICTIONARY(l_smlPoolSto);
// QS_OBJ_DICTIONARY(l_medPoolSto);
/* send signal dictionaries for globally published events... */
QS_SIG_DICTIONARY(QUIT_SIG, 0);
/* start the active objects... */
QActive_start(AO_UI,
1, /* priority */
l_uiQueueSto, Q_DIM(l_uiQueueSto), /* evt queue */
(void *)0, 0, /* no per-thread stack */
(QEvt *)0); /* no initialization event */
return QF_run(); /* run the QF application */
}
/*..........................................................................*/
void main (void) {
TServer_ctor();
BSP_init(); /* initialize the board */
QF_run(); /* transfer control to QF-nano */
}
/*..........................................................................*/
int main(void) {
uint8_t n;
Philo_ctor(); /* instantiate all Philosopher active objects */
Table_ctor(); /* instantiate the Table active object */
BSP_init(); /* initialize the Board Support Package */
QF_init(); /* initialize the framework and the underlying RT kernel */
/* object dictionaries... */
QS_OBJ_DICTIONARY(l_smlPoolSto);
QS_OBJ_DICTIONARY(l_tableQueueSto);
QS_OBJ_DICTIONARY(l_philoQueueSto[0]);
QS_OBJ_DICTIONARY(l_philoQueueSto[1]);
QS_OBJ_DICTIONARY(l_philoQueueSto[2]);
QS_OBJ_DICTIONARY(l_philoQueueSto[3]);
QS_OBJ_DICTIONARY(l_philoQueueSto[4]);
//QF_psInit(l_subscrSto, Q_DIM(l_subscrSto)); /* init publish-subscribe */
/* initialize event pools... */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
for (n = 0; n < N_PHILO; ++n) { /* start the active objects... */
QActive_start(AO_Philo[n], (uint8_t)(n + 1),
l_philoQueueSto[n], Q_DIM(l_philoQueueSto[n]),
(void *)0, 0, (QEvt *)0);
}
QActive_start(AO_Table, (uint8_t)(N_PHILO + 1),
l_tableQueueSto, Q_DIM(l_tableQueueSto),
(void *)0, 0, (QEvt *)0);
return QF_run(); /* run the QF application */
}
/*..........................................................................*/
int main(
#ifdef WIN32
int argc, char *argv[]
#endif
) {
uint8_t i;
for(i = 0; i < N_CLOOP; ++i) {/* Instantiate the control loop active
objects; this is unnecessary in C++, as the
ctor is called even for a static object */
CLoop_ctor(&l_cloop[i]);
}
#ifdef WIN32
BSP_init(argc, argv); /* initialize the Board Support Package */
#elif defined(__MICROBLAZE__)
BSP_init();
#endif
QF_init(); /* initialize the framework and the underlying RT kernel */
declareQSDictionary();/* TODO: send object dictionaries on (re)connection
* with QSpy */
QF_psInit(l_subscrSto, Q_DIM(l_subscrSto)); /* init publish-subscribe */
/* initialize event pools; NOTE: plural */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
for(i = 0; i < N_CLOOP; ++i) { /* start the active objects... */
QActive_start((QActive*)&l_cloop[i], i+1 /* lowest AO priority: 1 */
, l_cloopQueueSto[i], Q_DIM(l_cloopQueueSto[i])
, NULL/* I don't supply stack */, BSP_STACK_SIZE
, NULL/* no data to supply to initial transition */);
}
return QF_run(); /* run the QF application */
}
int main(void)
{
/**
* Reserve this space for recording assertions. We don't touch this
* memory here, and assume that it will be in the same place on every
* run, and that it isn't cleared by hardware or by startup code. If
* those are true, then after a reset caused by an assertion, it will
* contain the values as filled in by QF_onAssert() at the end of the
* previous run (before the reset).
*
* FIXME: test the assumptions. Also test hardware reset.
*/
struct AssertionBuffer assertion_buffer;
BSP_set_assertion_buffer(&assertion_buffer);
startmain:
BSP_init();
serial_init();
SERIALSTR("\r\n\r\n*** Hots and Colds ***\r\n");
buttons_ctor();
rtc_ctor();
lcd_init();
recorder_ctor();
ui_ctor();
SERIALSTR("Let's go...\r\n");
QF_run();
goto startmain;
return 0;
}
/* the main function -------------------------------------------------------*/
int main(void) {
QF_init(Q_DIM(QF_active)); /* initialize the QF-nano framework */
BSP_init(); /* initialize the Board Support Package */
Blinky_ctor(); /* in C you must explicitly call the Blinky constructor */
return QF_run(); /* transfer control to QF-nano */
}
/*..........................................................................*/
int comp_main(int argc, char *argv[]) {
printf("Orthogonal Component pattern\nQEP version: %s\nQF version: %s\n"
"Press 'o' to turn the Alarm ON\n"
"Press 'f' to turn the Alarm OFF\n"
"Press '0'..'9' to set the Alarm time\n"
"Press 'a' to set the Clock in 12-hour mode\n"
"Press 'b' to set the Clock in 24-hour mode\n"
"Press ESC to quit...\n",
QEP_getVersion(), QF_getVersion());
QF_init(); /* initialize the framework and the underlying RT kernel */
/* initialize event pools... */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
/* instantiate and start the active objects... */
AlarmClock_ctor(&l_alarmClock);
QActive_start((QActive *)&l_alarmClock, 1,
l_alarmClockQSto, Q_DIM(l_alarmClockQSto),
(void *)0, 0, (QEvent *)0);
QF_run(); /* run the QF application */
return 0;
}
int main(void)
{
static QEvt const *l_filterQSto[10];
filter_ctor();
QACTIVE_START(AO_filter, 1U, l_filterQSto, Q_DIM(l_filterQSto), (void *)0, 0U, (QEvt *)0);
return QF_run();
}
/*..........................................................................*/
int main() {
/* initialize the framework and the underlying RT kernel */
QF_init();
/* initialize event pools... have to be initialized in increasing size order */
QF_poolInit(l_smlPoolSto_4, sizeof(l_smlPoolSto_4), sizeof(QEvt));
QF_poolInit(l_smlPoolSto_6, sizeof(l_smlPoolSto_6), sizeof(SetEvt));
QF_poolInit(l_smlPoolSto_14, sizeof(l_smlPoolSto_14), sizeof(RtcEvt));
/*create the coffe active object*/
CoffeeAO_ctor(&l_CoffeeAO);
/*start active object*/
QActive_start((QActive *)&l_CoffeeAO, 3,
(const QEvt**)l_smlPoolSto_14, Q_DIM(l_smlPoolSto_14),
(void *)0, 0, (QEvt *)0);
/*initialize bsp after pools*/
BSP_Init();
//printf("%i\n", sizeof(QEvt));
//printf("%i\n", sizeof(SetEvt));
//printf("%i\n", sizeof(AdEvt));
//printf("%i\n", sizeof(RtcEvt));
/* run the QF application */
QF_run();
return 0;
}
/*..........................................................................*/
int main (void) {
Pelican_ctor(); /* instantiate the Pelican AO */
BSP_init(); /* initialize the board */
return QF_run(); /* transfer control to QF-nano */
}
int main(int argc, char* argv[]) {
(void)argc;
(void)argv;
BSP_init();
QF_init();
return QF_run();
}
/*..........................................................................*/
int_t main (void) {
Pelican_ctor(); /* instantiate the Pelican AO */
Ped_ctor(); /* instantiate the Ped AO */
QF_init(Q_DIM(QF_active)); /* initialize the QF-nano framework */
BSP_init(); /* initialize the Board Support Package */
return QF_run(); /* transfer control to QF-nano */
}
/*..........................................................................*/
int main (void) {
Tunnel_ctor();
Ship_ctor();
Missile_ctor(GAME_MISSILE_SPEED_X);
BSP_init(); /* initialize the board */
return QF_run(); /* transfer control to QF-nano */
}
/*..........................................................................*/
int main() {
static QEvt const *tableQueueSto[N_PHILO];
static QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static QSubscrList subscrSto[MAX_PUB_SIG];
static QF_MPOOL_EL(TableEvt) smlPoolSto[2*N_PHILO]; /* small pool */
uint8_t n;
Philo_ctor(); /* instantiate all Philosopher active objects */
Table_ctor(); /* instantiate the Table active object */
QF_init(); /* initialize the framework and the underlying RT kernel */
BSP_init(); /* initialize the Board Support Package */
/* object dictionaries... */
QS_OBJ_DICTIONARY(smlPoolSto);
QS_OBJ_DICTIONARY(tableQueueSto);
QS_OBJ_DICTIONARY(philoQueueSto[0]);
QS_OBJ_DICTIONARY(philoQueueSto[1]);
QS_OBJ_DICTIONARY(philoQueueSto[2]);
QS_OBJ_DICTIONARY(philoQueueSto[3]);
QS_OBJ_DICTIONARY(philoQueueSto[4]);
/* initialize publish-subscribe... */
QF_psInit(subscrSto, Q_DIM(subscrSto));
/* initialize event pools... */
QF_poolInit(smlPoolSto, sizeof(smlPoolSto), sizeof(smlPoolSto[0]));
/* start the active objects... */
for (n = 0U; n < N_PHILO; ++n) {
QACTIVE_START(AO_Philo[n], /* AO to start */
(uint_fast8_t)(n + 1), /* QP priority of the AO */
philoQueueSto[n], /* event queue storage */
Q_DIM(philoQueueSto[n]), /* queue length [events] */
(void *)0, /* stack storage (not used) */
0U, /* size of the stack (default) */
(QEvt *)0); /* initialization event */
}
/* Table AO uses the custom stack size.
* NOTE: Remember to configure sufficient number of threads with
* user-provided stack size OS_PRIVCNT in RTX_Conf_CM.c
*/
QF_setRtxPrio(AO_Table, osPriorityHigh); /* set RTX priority */
QACTIVE_START(AO_Table, /* AO to start */
(uint_fast8_t)(N_PHILO + 1), /* QP priority of the AO */
tableQueueSto, /* event queue storage */
Q_DIM(tableQueueSto), /* queue length [events] */
(void *)0, /* stack storage (not used) */
128U*4U, /* stack size [bytes] (or 0) */
(QEvt *)0); /* initialization event */
return QF_run(); /* run the QF application */
}
int main(int argc, char **argv)
{
uint8_t mcusr;
char startupmsg[17];
startmain:
cli();
mcusr = MCUSR;
MCUSR = 0;
TOGGLE_BEGIN();
BSP_startmain(); /* Disables the watchdog timer. */
serial_init();
serial_send_rom(startup_message);
serial_drain();
SERIALSTR("*** Reset reason:");
if (mcusr & (1 << WDRF)) SERIALSTR(" WD");
if (mcusr & (1 << BORF)) SERIALSTR(" BO");
if (mcusr & (1 << EXTRF)) SERIALSTR(" EXT");
if (mcusr & (1 << PORF)) SERIALSTR(" PO");
SERIALSTR("\r\n");
twi_ctor();
timekeeper_ctor();
lcd_init();
// Show the startup reason on the LCD.
strcpy(startupmsg, "Startup: ----");
if (mcusr & (1<<3)) startupmsg[9] = 'W';
if (mcusr & (1<<2)) startupmsg[10] = 'B';
if (mcusr & (1<<1)) startupmsg[11] = 'X';
if (mcusr & (1<<0)) startupmsg[12] = 'P';
lcd_line1(startupmsg);
_delay_ms(500);
buttons_ctor();
alarm_ctor();
timedisplay_ctor();
timesetter_ctor();
/* Drain the serial output just before the watchdog timer is
reenabled. */
serial_drain();
/* Turn off interrrupts until we have initialised the rest of the
hardware, and after QF_run() has properly initialised the active
objects. Interrupts go back on in QF_onStartup() */
QF_INT_LOCK();
/* Initialize the BSP. Enables the watchdog timer. */
BSP_init();
QF_run();
goto startmain;
}
/*..........................................................................*/
void main(int argc, char *argv[]) {
/* explicitly invoke the active objects' ctors... */
Missile_ctor();
Ship_ctor();
Tunnel_ctor();
BSP_init(argc, argv); /* initialize the Board Support Package */
QF_init(); /* initialize the framework and the underlying RT kernel */
/* initialize the event pools... */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
QF_poolInit(l_medPoolSto, sizeof(l_medPoolSto), sizeof(l_medPoolSto[0]));
QF_psInit(l_subscrSto, Q_DIM(l_subscrSto)); /* init publish-subscribe */
/* send object dictionaries for event queues... */
QS_OBJ_DICTIONARY(l_missileQueueSto);
QS_OBJ_DICTIONARY(l_shipQueueSto);
QS_OBJ_DICTIONARY(l_tunnelQueueSto);
/* send object dictionaries for event pools... */
QS_OBJ_DICTIONARY(l_smlPoolSto);
QS_OBJ_DICTIONARY(l_medPoolSto);
/* send signal dictionaries for globally published events... */
QS_SIG_DICTIONARY(TIME_TICK_SIG, 0);
QS_SIG_DICTIONARY(PLAYER_TRIGGER_SIG, 0);
QS_SIG_DICTIONARY(PLAYER_QUIT_SIG, 0);
QS_SIG_DICTIONARY(GAME_OVER_SIG, 0);
/* start the active objects... */
QActive_start(AO_Missile,
1, /* priority */
l_missileQueueSto, Q_DIM(l_missileQueueSto), /* evt queue */
(void *)0, 0, /* no per-thread stack */
(QEvent *)0); /* no initialization event */
QActive_start(AO_Ship,
2, /* priority */
l_shipQueueSto, Q_DIM(l_shipQueueSto), /* evt queue */
(void *)0, 0, /* no per-thread stack */
(QEvent *)0); /* no initialization event */
QActive_start(AO_Tunnel,
3, /* priority */
l_tunnelQueueSto, Q_DIM(l_tunnelQueueSto), /* evt queue */
(void *)0, 0, /* no per-thread stack */
(QEvent *)0); /* no initialization event */
QF_run(); /* run the QF application */
}
/*..........................................................................*/
int main() {
static QEvt const *tableQueueSto[N_PHILO];
static QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static QSubscrList subscrSto[MAX_PUB_SIG];
static QF_MPOOL_EL(TableEvt) smlPoolSto[2*N_PHILO]; /* small pool */
uint8_t n;
Philo_ctor(); /* instantiate all Philosopher active objects */
Table_ctor(); /* instantiate the Table active object */
QF_init(); /* initialize the framework and the underlying RT kernel */
BSP_init(); /* initialize the Board Support Package */
/* object dictionaries... */
QS_OBJ_DICTIONARY(smlPoolSto);
QS_OBJ_DICTIONARY(tableQueueSto);
QS_OBJ_DICTIONARY(philoQueueSto[0]);
QS_OBJ_DICTIONARY(philoQueueSto[1]);
QS_OBJ_DICTIONARY(philoQueueSto[2]);
QS_OBJ_DICTIONARY(philoQueueSto[3]);
QS_OBJ_DICTIONARY(philoQueueSto[4]);
/* initialize publish-subscribe... */
QF_psInit(subscrSto, Q_DIM(subscrSto));
/* initialize event pools... */
QF_poolInit(smlPoolSto, sizeof(smlPoolSto), sizeof(smlPoolSto[0]));
/* start the active objects... */
for (n = 0U; n < N_PHILO; ++n) {
QACTIVE_START(AO_Philo[n], /* AO to start */
(uint_fast8_t)(n + 1), /* QP priority of the AO */
philoQueueSto[n], /* event queue storage */
Q_DIM(philoQueueSto[n]), /* queue length [events] */
(void *)0, /* stack storage (not used) */
0U, /* size of the stack [bytes] */
(QEvt *)0); /* initialization event */
}
QACTIVE_START(AO_Table, /* AO to start */
(uint_fast8_t)(N_PHILO + 1), /* QP priority of the AO */
tableQueueSto, /* event queue storage */
Q_DIM(tableQueueSto), /* queue length [events] */
(void *)0, /* stack storage (not used) */
0U, /* size of the stack [bytes] */
(QEvt *)0); /* initialization event */
return QF_run(); /* run the QF application */
}
/*..........................................................................*/
int main (void) {
AlarmClock_ctor();
printf("Orthogonal Component state pattern\nQP-nano version: %s\n"
"Press 'o' to turn the Alarm ON\n"
"Press 'f' to turn the Alarm OFF\n"
"Press '0'..'9' to set the Alarm time\n"
"Press 'A' to set the Clock in 12-hour mode\n"
"Press 'B' to set the Clock in 24-hour mode\n"
"Press ESC to quit...\n",
QP_getVersion());
BSP_init(); /* initialize the board */
return QF_run(); /* transfer control to QF-nano */
}
int main(void)
{
Ble_ctor();
Array_ctor();
QF_init(Q_DIM(QF_active)); /* initialize the QF-nano framework */
void BSP_init(); BSP_init(); /* initialize the Board Support Package */
/* dictionaries... */
QS_USR_DICTIONARY(TRACE_SDK_EVT);
QS_USR_DICTIONARY(TRACE_PEER_EVT);
QS_USR_DICTIONARY(TRACE_ADV_EVT);
QS_USR_DICTIONARY(TRACE_BLE_EVT);
QS_USR_DICTIONARY(TRACE_DM_EVT);
QS_USR_DICTIONARY(TRACE_ANCS_EVT);
return QF_run(); /* run the QF application */
}
/*..........................................................................*/
int main() {
static QEvt const *tableQueueSto[N_PHILO];
static QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static QSubscrList subscrSto[MAX_PUB_SIG];
static QF_MPOOL_EL(TableEvt) smlPoolSto[2*N_PHILO]; /* small pool */
uint8_t n;
Philo_ctor(); /* instantiate all Philosopher active objects */
Table_ctor(); /* instantiate the Table active object */
QF_init(); /* initialize the framework and the underlying RT kernel */
BSP_init(); /* initialize the Board Support Package */
/* object dictionaries... */
QS_OBJ_DICTIONARY(smlPoolSto);
QS_OBJ_DICTIONARY(tableQueueSto);
QS_OBJ_DICTIONARY(philoQueueSto[0]);
QS_OBJ_DICTIONARY(philoQueueSto[1]);
QS_OBJ_DICTIONARY(philoQueueSto[2]);
QS_OBJ_DICTIONARY(philoQueueSto[3]);
QS_OBJ_DICTIONARY(philoQueueSto[4]);
QF_psInit(subscrSto, Q_DIM(subscrSto)); /* init publish-subscribe */
/* initialize event pools... */
QF_poolInit(smlPoolSto, sizeof(smlPoolSto), sizeof(smlPoolSto[0]));
for (n = 0U; n < N_PHILO; ++n) { /* start the active objects... */
QACTIVE_START(AO_Philo[n], (uint8_t)(n + 1),
philoQueueSto[n], Q_DIM(philoQueueSto[n]),
(void *)0, 0U, (QEvt *)0);
}
QACTIVE_START(AO_Table, (uint8_t)(N_PHILO + 1),
tableQueueSto, Q_DIM(tableQueueSto),
(void *)0, 0U, (QEvt *)0);
return QF_run(); /* run the QF application */
}
/*..........................................................................*/
int main(int argc, char *argv[]) {
printf("Reminder state pattern\nQEP version: %s\nQF version: %s\n"
"Press 'e' to echo the current value...\n"
"Press ESC to quit...\n",
QEP_getVersion(), QF_getVersion());
Cruncher_ctor(&l_cruncher);
BSP_init(argc, argv); /* initialize the BSP */
QF_init(); /* initialize the framework and the underlying RT kernel */
/* publish-subscribe not used, no call to QF_psInit() */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
/* instantiate and start the active objects... */
QACTIVE_START((QActive *)&l_cruncher, 1,
l_cruncherQSto, Q_DIM(l_cruncherQSto),
(void *)0, 1024, (QEvt *)0);
return QF_run(); /* run the QF application */
}
int main(void) {
static QEvt const *l_tableQueueSto[N_PHILO];
static QEvt const *l_philoQueueSto[N_PHILO][N_PHILO];
static QSubscrList l_subscrSto[MAX_PUB_SIG];
/* storage for event pools... */
static QF_MPOOL_EL(TableEvt) l_smlPoolSto[2*N_PHILO]; /* small pool */
uint8_t n;
Philo_ctor(); /* instantiate all Philosopher active objects */
Table_ctor(); /* instantiate the Table active object */
QF_init(); /* initialize the framework and the underlying RT kernel */
BSP_init(); /* initialize the BSP */
/* send object dictionaries for event pools... */
QS_OBJ_DICTIONARY(l_smlPoolSto);
/* init publish-subscribe... */
QF_psInit(l_subscrSto, Q_DIM(l_subscrSto));
/* initialize event pools... */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
/* start the active objects... */
for (n = 0; n < N_PHILO; ++n) {
QACTIVE_START(AO_Philo[n], (uint8_t)(n + 1),
l_philoQueueSto[n], Q_DIM(l_philoQueueSto[n]),
(void *)0, 0U, (QEvt *)0);
}
QACTIVE_START(AO_Table, (uint8_t)(N_PHILO + 1),
l_tableQueueSto, Q_DIM(l_tableQueueSto),
(void *)0, 0U, (QEvt *)0);
return QF_run(); /* run the QF application, QF_run() does not return */
}
/*..........................................................................*/
int main(void) {
/**初始化BSP*/
BSP_init();
// /**载入系统参数，如失败系统停止运行*/
// if(!Load_Parameters())
// {
// //系统参数初始化失败，程序终止
// return -1;
// }
/**初始化QP框架*/
QF_init();
/** 初始化事件池，用了小尺寸事件池和中尺寸事件池，未用大尺寸事件池，因为并没有字节数特别多的事件 */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
QF_poolInit(l_medPoolSto, sizeof(l_medPoolSto), sizeof(l_medPoolSto[0]));
// QF_poolInit(l_largePoolSto, sizeof(l_largePoolSto), sizeof(l_largePoolSto[0]));
/**初始化publish-subscribe缓区*/
QF_psInit(l_subscrSto, Q_DIM(l_subscrSto));
/**创建内存池，预分配一个块。只能调用一次*/
if (MP_Create() < 0) {
/**内存池创建失败，程序终止*/
return -1;
}
#ifdef GPRS
/**GPRS状态机初始化*/
QGprs_ctor();
/**启动GPRS状态机*/
QActive_start(AO_Gprs, AO_PRIO_GPRS, l_GPRSQueueSto, Q_DIM(l_GPRSQueueSto),
(void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef GPS
/**GPS状态机初始化*/
QGps_ctor();
/**启动状态机*/
QActive_start(AO_Gps, AO_PRIO_GPS, l_GPSQueueSto, Q_DIM(l_GPSQueueSto),
(void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef ACCDET
/**ACC检测状态机初始化*/
QACCDetector_ctor();
/**启动ACC检测状态机*/
QActive_start(AO_ACCDetector, AO_PRIO_ACCDET, l_ACCQueueSto,
Q_DIM(l_ACCQueueSto), (void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef CAN
/**CAN状态机初始化*/
QCAN_ctor();
/**启动CAN状态机*/
QActive_start(AO_Can, AO_PRIO_CAN, l_CANQueueSto, Q_DIM(l_CANQueueSto),
(void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef LCD
/**LCD屏状态机初始化 */
QLCD_ctor();
/**启动状态机*/
QActive_start(AO_LCD, AO_PRIO_LCD, l_LCDQueueSto, Q_DIM(l_LCDQueueSto),
(void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef SENSOR
/**LCD屏状态机初始化 */
Q3DSensor_ctor();
/**启动状态机*/
QActive_start(AO_3DSensor, AO_PRIO_SENSOR, l_SENSORQueueSto,
Q_DIM(l_SENSORQueueSto), (void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef VIDEO
/**摄像头状态机初始化 */
QVideo_ctor();
/**启动状态机*/
QActive_start(AO_Video, AO_PRIO_VIDEO, l_VIDEOQueueSto,
Q_DIM(l_VIDEOQueueSto), (void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef TTS
/**TTS状态机初始化 */
QTTS_ctor();
/**启动状态机*/
QActive_start(AO_TTS, AO_PRIO_TTS, l_TTSQueueSto, Q_DIM(l_TTSQueueSto),
(void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef RECORDER
/**TTS状态机初始化 */
QRecorder_ctor();
/**启动状态机*/
QActive_start(AO_Recorder, AO_PRIO_RECORDER, l_RECORDQueueSto,
Q_DIM(l_RECORDQueueSto), (void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef ICCARD
/**IC卡状态机初始化 */
QICcard_ctor();
/**启动状态机*/
QActive_start(AO_ICCard, AO_PRIO_IC, l_ICCARDQueueSto,
Q_DIM(l_ICCARDQueueSto), (void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef PRINTER
/**IC卡状态机初始化 */
QPrinter_ctor();
/**启动状态机*/
QActive_start(AO_Printer, AO_PRIO_PRINTER, l_PRINTERQueueSto,
Q_DIM(l_PRINTERQueueSto), (void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef IR
/**IC卡状态机初始化 */
QIR_ctor();
/**启动状态机*/
QActive_start(AO_IR, AO_PRIO_IR, l_IRQueueSto, Q_DIM(l_IRQueueSto),
(void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef USB
/**IC卡状态机初始化 */
QUSB_ctor();
/**启动状态机*/
QActive_start(AO_USB, AO_PRIO_USB, l_USBQueueSto, Q_DIM(l_USBQueueSto),
(void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef AUDIO
/**IC卡状态机初始化 */
QAudio_ctor();
/**启动状态机*/
QActive_start(AO_Audio, AO_PRIO_AUDIO, l_AUDIOQueueSto,
Q_DIM(l_AUDIOQueueSto), (void *) 0, 0U, (QEvt *) 0);
#endif
#ifdef UPGRADE
/**SD卡升级状态机初始化*/
QUpgrade_ctor();
/**启动升级状态机*/
QActive_start(AO_Upgrade, AO_PRIO_UPGRADE, l_UPGRADEQueueSto,
Q_DIM(l_UPGRADEQueueSto), (void *) 0, 0U, (QEvt *) 0);
#endif
/**系统时间状态机初始化*/
QSystick_ctor();
/**启动系统时钟状态机*/
QActive_start(AO_Systick, AO_PRIO_SYSTICK, l_SYSTICKQueueSto,
Q_DIM(l_SYSTICKQueueSto), (void *) 0, 0U, (QEvt *) 0);
/**载入系统参数，如失败系统停止运行*/
// if (!Load_Parameters()) {
// /**系统参数初始化失败，程序终止*/
// return -1;
// }
/**嵌套中断向量初始化*/
NVIC_Configuration();
/**启动QP框架，程序开始运行*/
return QF_run();
}
/*..........................................................................*/
int main() {
static QEvt const *tableQueueSto[N_PHILO];
static uint64_t tableStackSto[64];
static QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static uint64_t philoStackSto[N_PHILO][64];
static QSubscrList subscrSto[MAX_PUB_SIG];
static QF_MPOOL_EL(TableEvt) smlPoolSto[2*N_PHILO]; /* small pool */
/* stack for the "naked" test thread */
static void const *testQueueSto[5];
static uint64_t testStackSto[64];
/* stack for the QXK's idle thread */
static uint64_t idleStackSto[32];
uint8_t n;
Philo_ctor(); /* instantiate all Philosopher active objects */
Table_ctor(); /* instantiate the Table active object */
Test_ctor(); /* instantiate the Test "naked" thread */
QF_init(); /* initialize the framework */
BSP_init(); /* initialize the Board Support Package */
/* object dictionaries... */
QS_OBJ_DICTIONARY(smlPoolSto);
QS_OBJ_DICTIONARY(tableQueueSto);
QS_OBJ_DICTIONARY(philoQueueSto[0]);
QS_OBJ_DICTIONARY(philoQueueSto[1]);
QS_OBJ_DICTIONARY(philoQueueSto[2]);
QS_OBJ_DICTIONARY(philoQueueSto[3]);
QS_OBJ_DICTIONARY(philoQueueSto[4]);
/* initialize QXK... */
QXK_init(idleStackSto, sizeof(idleStackSto));
/* initialize publish-subscribe... */
QF_psInit(subscrSto, Q_DIM(subscrSto));
/* initialize event pools... */
QF_poolInit(smlPoolSto, sizeof(smlPoolSto), sizeof(smlPoolSto[0]));
/* start the active objects... */
for (n = 0U; n < N_PHILO; ++n) {
QACTIVE_START(AO_Philo[n], /* AO to start */
(uint_fast8_t)(n + 1), /* QP priority of the AO */
philoQueueSto[n], /* event queue storage */
Q_DIM(philoQueueSto[n]), /* queue length [events] */
philoStackSto[n], /* stack storage */
sizeof(philoStackSto[n]), /* stack size [bytes] */
(QEvt *)0); /* initialization event */
}
QACTIVE_START(AO_Table, /* AO to start */
(uint_fast8_t)(N_PHILO + 1), /* QP priority of the AO */
tableQueueSto, /* event queue storage */
Q_DIM(tableQueueSto), /* queue length [events] */
tableStackSto, /* stack storage */
sizeof(tableStackSto), /* stack size [bytes] */
(QEvt *)0); /* initialization event */
/* start the "naked" thread */
QXTHREAD_START(&XT_Test->super, /* Thread to start */
(uint_fast8_t)10U, /* QP priority of the thread */
testQueueSto, /* message queue storage */
Q_DIM(testQueueSto), /* message length [events] */
testStackSto, /* stack storage */
sizeof(testStackSto), /* stack size [bytes] */
(QEvt *)0); /* initialization event */
return QF_run(); /* run the QF application */
}
/*..........................................................................*/
int main() {
static QEvt const *tableQueueSto[N_PHILO];
static QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static OS_STK philoStk[N_PHILO][128]; /* stacks for the Philosophers */
static OS_STK tableStk[256]; /* stack for the Table */
static QSubscrList subscrSto[MAX_PUB_SIG];
static TableEvt smlPoolSto[2*N_PHILO]; /* storage for small event pool */
uint8_t n;
/* in C you need to explicitly instantiate all AOs... */
Philo_ctor();
Table_ctor();
QF_init(); /* initialize the framework and the underlying RT kernel */
BSP_init(); /* initialize the Board Support Package */
/* object dictionaries... */
QS_OBJ_DICTIONARY(smlPoolSto);
QS_OBJ_DICTIONARY(tableQueueSto);
QS_OBJ_DICTIONARY(philoQueueSto[0]);
QS_OBJ_DICTIONARY(philoQueueSto[1]);
QS_OBJ_DICTIONARY(philoQueueSto[2]);
QS_OBJ_DICTIONARY(philoQueueSto[3]);
QS_OBJ_DICTIONARY(philoQueueSto[4]);
/* init publish-subscribe */
QF_psInit(subscrSto, Q_DIM(subscrSto));
/* initialize event pools... */
QF_poolInit(smlPoolSto, sizeof(smlPoolSto), sizeof(smlPoolSto[0]));
/* start the active objects... */
/* CAUTION:
* Make sure to configure **SUFFICIENT** number of uC/OS-II tasks and
* message queues in "os_cfg.h" for all your active objects!!!
*/
for (n = 0U; n < N_PHILO; ++n) {
/* NOTE: provide uC/OS-II task attributes for the AO's task */
QF_setUCosTaskAttr(AO_Philo[n], OS_TASK_OPT_STK_CHK);
QACTIVE_START(AO_Philo[n],
(uint_fast8_t)(n + 1), /* QP priority */
philoQueueSto[n], /* storage for the AO's queue */
Q_DIM(philoQueueSto[n]), /* queue's length [entries] */
philoStk[n], /* stack storage */
sizeof(philoStk[n]), /* sack size [bytes] */
(QEvt const *)0); /* initialization event */
}
/* NOTE: provide uC/OS-II task attributes for the AO's task */
QF_setUCosTaskAttr(AO_Table, OS_TASK_OPT_STK_CHK);
QACTIVE_START(AO_Table,
(uint_fast8_t)(N_PHILO + 1), /* QP priority */
tableQueueSto, /* storage for the AO's queue */
Q_DIM(tableQueueSto), /* queue's length [entries] */
tableStk, /* stack storage */
sizeof(tableStk), /* sack size [bytes] */
(QEvt const *)0); /* initialization event */
return QF_run(); /* run the QF application */
}
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();
}
}
/*............................................................................*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
files (startup_stm32f40_41xxx.s/startup_stm32f427_437xx.s/
startup_stm32f429_439xx.s/startup_stm32f401xx.s) before to branch to
application main. To reconfigure the default setting of SystemInit()
function, refer to system_stm32f4xx.c file
*/
/* Enable debugging for select modules - Note: this has no effect in rel
* builds since all DBG level logging is disabled and only LOG and up msgs
* will get printed. */
DBG_setDefaults();
/* initialize the Board Support Package */
BSP_init();
dbg_slow_printf("Initialized BSP\n");
log_slow_printf("Starting Bootloader version %s built on %s\n", FW_VER, BUILD_DATE);
/* Instantiate the Active objects by calling their "constructors" */
dbg_slow_printf("Initializing AO constructors\n");
/* Make sure the comm interfaces are up first */
SerialMgr_ctor();
LWIPMgr_ctor();
/* Iterate though the available I2C busses on the system and call the ctor()
* for each instance of the I2CBusMgr AO for each bus. */
for( uint8_t i = 0; i < MAX_I2C_BUS; ++i ) {
I2CBusMgr_ctor( i ); /* Start this instance of AO for this bus. */
}
I2C1DevMgr_ctor();
CommMgr_ctor();
FlashMgr_ctor();
SysMgr_ctor();
dbg_slow_printf("Initializing QF\n");
QF_init(); /* initialize the framework and the underlying RT kernel */
/* object dictionaries... */
dbg_slow_printf("Initializing object dictionaries for QSPY\n");
QS_OBJ_DICTIONARY(l_smlPoolSto);
QS_OBJ_DICTIONARY(l_medPoolSto);
QS_OBJ_DICTIONARY(l_lrgPoolSto);
QS_OBJ_DICTIONARY(l_SerialMgrQueueSto);
QS_OBJ_DICTIONARY(l_LWIPMgrQueueSto);
QS_OBJ_DICTIONARY(l_I2CBusMgrQueueSto);
QS_OBJ_DICTIONARY(l_I2C1DevMgrQueueSto);
QS_OBJ_DICTIONARY(l_CommMgrQueueSto);
QS_OBJ_DICTIONARY(l_FlashMgrQueueSto);
QS_OBJ_DICTIONARY(l_SysMgrQueueSto);
QF_psInit(l_subscrSto, Q_DIM(l_subscrSto)); /* init publish-subscribe */
/* initialize the general memory pool */
dbg_slow_printf("Initializing general purpose memory pool in CCMRAM\n");
QMPool_init(
p_glbMemPool,
l_memPoolSto,
sizeof(l_memPoolSto),
DC3_MAX_MEM_BLK_SIZE
);
/* initialize event pools... */
dbg_slow_printf("Initializing small event storage pool\n");
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
dbg_slow_printf("Initializing medium event storage pool\n");
QF_poolInit(l_medPoolSto, sizeof(l_medPoolSto), sizeof(l_medPoolSto[0]));
dbg_slow_printf("Initializing large event storage pool\n");
QF_poolInit(l_lrgPoolSto, sizeof(l_lrgPoolSto), sizeof(l_lrgPoolSto[0]));
/* Start Active objects */
dbg_slow_printf("Starting Active Objects\n");
QACTIVE_START(AO_SerialMgr,
SERIAL_MGR_PRIORITY, /* priority */
l_SerialMgrQueueSto, Q_DIM(l_SerialMgrQueueSto), /* evt queue */
(void *)0, 0, /* per-thread stack size */
(QEvt *)0, /* no initialization event */
"SerialMgr" /* Name of the task */
);
QACTIVE_START(AO_LWIPMgr,
ETH_PRIORITY, /* priority */
l_LWIPMgrQueueSto, Q_DIM(l_LWIPMgrQueueSto), /* evt queue */
(void *)0, 0, /* per-thread stack size */
(QEvt *)0, /* no initialization event */
"LWIPMgr" /* Name of the task */
);
/* Iterate though the available I2C busses on the system and start an
* instance of the I2CBusMgr AO for each bus.
* WARNING!!!: make sure that the priorities for them are all together since
* this loop will iterates through them and will take another AO's priority.
* You will end up with clashing priorities for your AOs.*/
for( uint8_t i = 0; i < MAX_I2C_BUS; ++i ) {
QACTIVE_START(AO_I2CBusMgr[i],
I2CBUS1MGR_PRIORITY + i, /* priority */
l_I2CBusMgrQueueSto[i], Q_DIM(l_I2CBusMgrQueueSto[i]), /* evt queue */
(void *)0, 0, /* per-thread stack size */
(QEvt *)0, /* no initialization event */
"I2CBusMgr" /* Name of the task */
);
}
QACTIVE_START(AO_I2C1DevMgr,
I2C1DEVMGR_PRIORITY, /* priority */
l_I2C1DevMgrQueueSto, Q_DIM(l_I2C1DevMgrQueueSto), /* evt queue */
(void *)0, 0, /* per-thread stack size */
(QEvt *)0, /* no initialization event */
"I2CDevMgr" /* Name of the task */
);
QACTIVE_START(AO_CommMgr,
COMM_MGR_PRIORITY, /* priority */
l_CommMgrQueueSto, Q_DIM(l_CommMgrQueueSto), /* evt queue */
(void *)0, 0, /* per-thread stack size */
(QEvt *)0, /* no initialization event */
"CommMgr" /* Name of the task */
);
QACTIVE_START(AO_FlashMgr,
FLASH_MGR_PRIORITY, /* priority */
l_FlashMgrQueueSto, Q_DIM(l_FlashMgrQueueSto), /* evt queue */
(void *)0, 0, /* per-thread stack size */
(QEvt *)0, /* no initialization event */
"FlashMgr" /* Name of the task */
);
QACTIVE_START(AO_SysMgr,
SYS_MGR_PRIORITY, /* priority */
l_SysMgrQueueSto, Q_DIM(l_SysMgrQueueSto), /* evt queue */
(void *)0, 0, /* per-thread stack size */
(QEvt *)0, /* no initialization event */
"SysMgr" /* Name of the task */
);
log_slow_printf("Starting QPC. All logging from here on out shouldn't show 'SLOW'!!!\n\n");
QF_run(); /* run the QF application */
return(0);
}
/*..........................................................................*/
int main(void) {
Table_ctor(); /* instantiate the Table active object */
LwIPMgr_ctor(); /* instantiate all LwIP-Manager active object */
MgtProtocolHandler_ctor(); /* instantiate the MgtProtocolHandler active object */
IceMgr_ctor(); /* instantiate the IceMgr active object */
ModIo2Mgr_ctor(); /* instantiate the ModIo2Mgr active object */
IceDetectionMgr_ctor(); /* instantiate the IceDetectionMgr active object */
BSP_init(); /* initialize the Board Support Package */
QF_init(); /* initialize the framework and the underlying RT kernel */
/*
ModLED8x8_init();
while (1) {
ModLED8x8_scrollString("*** RES Smart Cocktail Factory ***", SCROLL_RIGHT);
delayMs(500);
ModLED8x8_scrollString("*** RES Smart Cocktail Factory ***", SCROLL_LEFT);
delayMs(500);
}
*/
/* object dictionaries... */
QS_OBJ_DICTIONARY(l_smlPoolSto);
QS_OBJ_DICTIONARY(l_medPoolSto);
QS_OBJ_DICTIONARY(l_lwIPMgrQueueSto);
QS_OBJ_DICTIONARY(l_tableQueueSto);
QS_OBJ_DICTIONARY(l_mgtProtocolHandlerSto);
QS_OBJ_DICTIONARY(l_iceMgrSto);
QS_OBJ_DICTIONARY(l_modIo2MgrSto);
QS_OBJ_DICTIONARY(l_iceDetectionMgrSto);
/* init publish-subscribe */
QF_psInit(l_subscrSto, Q_DIM(l_subscrSto));
/* initialize event pools... */
QF_poolInit(l_smlPoolSto, sizeof(l_smlPoolSto), sizeof(l_smlPoolSto[0]));
QF_poolInit(l_medPoolSto, sizeof(l_medPoolSto), sizeof(l_medPoolSto[0]));
/* start active objects */
QActive_start(AO_LwIPMgr, 1,
l_lwIPMgrQueueSto, Q_DIM(l_lwIPMgrQueueSto),
(void *)0, 0, (QEvent *)0);
QActive_start(AO_Table, 3,
l_tableQueueSto, Q_DIM(l_tableQueueSto),
(void *)0, 0, (QEvent *)0);
QActive_start(AO_MgtProtocolHandler, 5,
l_mgtProtocolHandlerSto, Q_DIM(l_mgtProtocolHandlerSto),
(void *)0, 0, (QEvent *)0);
QActive_start(AO_IceMgr, 7,
l_iceMgrSto, Q_DIM(l_iceMgrSto),
(void *)0, 0, (QEvent *)0);
QActive_start(AO_ModIo2Mgr, 9,
l_modIo2MgrSto, Q_DIM(l_modIo2MgrSto),
(void *)0, 0, (QEvent *)0);
QActive_start(AO_IceDetectionMgr, 11,
l_iceDetectionMgrSto, Q_DIM(l_iceDetectionMgrSto),
(void *)0, 0, (QEvent *)0);
/* run the QF application */
QF_run();
return 1;
}