void BSP_init(void) { uint32_t err_code; err_code = nrf_drv_timer_init(&TIMER1, NULL, Timer1_handler); APP_ERROR_CHECK(err_code); nrf_drv_timer_extended_compare(&TIMER1, NRF_TIMER_CC_CHANNEL0 , nrf_drv_timer_ms_to_ticks(&TIMER1, 1000/BSP_TICKS_PER_SEC) , NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, true); // Configure button 1 for low accuracy (why not high accuracy?) Q_ALLEGE(nrf_drv_gpiote_init() == NRF_SUCCESS); nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true); config.pull = NRF_GPIO_PIN_PULLUP; Q_ALLEGE(nrf_drv_gpiote_in_init(BTN_PIN, &config, btn1_event_handler) == NRF_SUCCESS); nrf_drv_gpiote_in_event_enable(BTN_PIN, /* int enable = */ true); NRF_GPIO->DIRSET = 1 << GPIO_TP; /* initialize the QS software tracing... */ if (QS_INIT((void *)0) == 0) { Q_ERROR(); } }
void QActive_postFIFO(QActive *me, QEvent const *e) { #else void QActive_postFIFO(QActive *me, QEvent const *e, void const *sender) { #endif QF_INT_LOCK_KEY_ QF_INT_LOCK_(); QS_BEGIN_NOLOCK_(QS_QF_ACTIVE_POST_FIFO, QS_aoObj_, me) QS_TIME_(); /* timestamp */ QS_OBJ_(sender); /* the sender object */ QS_SIG_(e->sig); /* the signal of the event */ QS_OBJ_(me); /* this active object (recipient) */ QS_U8_(EVT_POOL_ID(e)); /* the pool Id of the event */ QS_U8_(EVT_REF_CTR(e)); /* the ref count of the event */ QS_EQC_(0); /* number of free entries (unknown) */ QS_EQC_(0); /* min number of free entries (unknown) */ QS_END_NOLOCK_() if (EVT_POOL_ID(e) != (uint8_t)0) { /* is it a pool event? */ EVT_INC_REF_CTR(e); /* increment the reference counter */ } QF_INT_UNLOCK_(); Q_ALLEGE(OSQPost((OS_EVENT *)me->eQueue, (void *)e) == OS_NO_ERR); }
/*..........................................................................*/ void QFsm_init_(QFsm * const me, QEvt const * const e) { QS_CRIT_STAT_ Q_REQUIRE((me->vptr != (QMsmVtbl const *)0) /* ctor must be executed */ && (me->temp.fun != Q_STATE_CAST(0)) /* ctor must be executed */ && (me->state.fun == Q_STATE_CAST(0)));/*init tran. NOT taken */ QS_BEGIN_(QS_QEP_STATE_INIT, QS_priv_.smObjFilter, me) QS_OBJ_(me); /* this state machine object */ QS_FUN_(Q_STATE_CAST(0)); /* source state (not defined for a FSM) */ QS_FUN_(me->temp.fun); /* the target of the transition */ QS_END_() /* execute the top-most initial transition */ Q_ALLEGE((*me->temp.fun)(me, e) == (QState)Q_RET_TRAN);/* must be taken */ (void)QEP_TRIG_(me->temp.fun, Q_ENTRY_SIG); /* enter the target */ me->state.fun = me->temp.fun; /* record the new active state */ QS_BEGIN_(QS_QEP_INIT_TRAN, QS_priv_.smObjFilter, me) QS_TIME_(); /* time stamp */ QS_OBJ_(me); /* this state machine object */ QS_FUN_(me->state.fun); /* the new active state */ QS_END_() }
//............................................................................ void BSP_init(void) { // set the system clock as specified in lm3s_config.h (20MHz from PLL) SystemInit(); // enable clock to the peripherals used by the application SYSCTL->RCGC2 |= 1U | (1U << 2); // enable clock to GPIOA & C __NOP(); // wait after enabling clocks __NOP(); __NOP(); // configure the LED and push button GPIOC->DIR |= USER_LED; // set direction: output GPIOC->DEN |= USER_LED; // digital enable GPIOC->DATA_Bits[USER_LED] = 0U; // turn the User LED off GPIOC->DIR &= ~PUSH_BUTTON; // set direction: input GPIOC->DEN |= PUSH_BUTTON; // digital enable Display96x16x1Init(1U); // initialize the OLED display Display96x16x1StringDraw(&"Dining Philos"[0], 0U, 0U); Display96x16x1StringDraw(&"0 ,1 ,2 ,3 ,4"[0], 0U, 1U); Q_ALLEGE(QS_INIT(static_cast<void *>(0))); QS_OBJ_DICTIONARY(&l_SysTick_Handler); QS_OBJ_DICTIONARY(&l_GPIOPortA_IRQHandler); QS_USR_DICTIONARY(PHILO_STAT); }
//............................................................................ void BSP_init(void) { Q_ALLEGE(QS_INIT((void *)0)); QS_RESET(); QS_OBJ_DICTIONARY(&l_clock_tick); // must be called *after* QF_init() QS_USR_DICTIONARY(PHILO_STAT); }
static QState Ble_ancs_enabled(Ble* const me) { uint32_t err_code; switch(Q_SIG(me)) { case Q_ENTRY_SIG: err_code = ble_ancs_c_notif_source_notif_enable(&m_ancs_c); Q_ALLEGE(err_code == NRF_SUCCESS); #if 0 err_code = ble_ancs_c_data_source_notif_enable(&m_ancs_c); Q_ALLEGE(err_code == NRF_SUCCESS); #endif return Q_HANDLED(); default: return Q_SUPER(&QHsm_top); } }
/*..........................................................................*/ void QHsm_init(QHsm *me) { QStateHandler t; Q_ALLEGE((*me->state)(me) == Q_RET_TRAN);/* initial tran. must be taken */ t = (QStateHandler)&QHsm_top; /* an HSM starts in the top state */ do { /* drill into the target hierarchy... */ QStateHandler path[QEP_MAX_NEST_DEPTH_]; int8_t ip = (int8_t)0; path[0] = me->state; Q_SIG(me) = (QSignal)QEP_EMPTY_SIG_; (void)(*me->state)(me); while (me->state != t) { ++ip; path[ip] = me->state; (void)(*me->state)(me); } me->state = path[0]; /* entry path must not overflow */ Q_ASSERT(ip < (int8_t)QEP_MAX_NEST_DEPTH_); Q_SIG(me) = (QSignal)Q_ENTRY_SIG; do { /* retrace the entry path in reverse (correct) order... */ (void)(*path[ip])(me); /* enter path[ip] */ --ip; } while (ip >= (int8_t)0); t = path[0]; Q_SIG(me) = (QSignal)Q_INIT_SIG; } while ((*t)(me) == Q_RET_TRAN); /* initial transition handled? */ me->state = t; }
bool QActive_post_(QActive * const me, QEvt const * const e, uint_fast16_t const margin, void const * const sender) #endif /* Q_SPY */ { uint_fast16_t nFree; bool status; QF_CRIT_STAT_ QF_CRIT_ENTRY_(); nFree = (uint_fast16_t)(me->eQueue.maxMsg - me->eQueue.nofMsg); if (nFree > margin) { QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_POST_FIFO, QS_priv_.aoObjFilter, me) QS_TIME_(); /* timestamp */ QS_OBJ_(sender); /* the sender object */ QS_SIG_(e->sig); /* the signal of the event */ QS_OBJ_(me); /* this active object (recipient) */ QS_2U8_(e->poolId_, e->refCtr_); /* pool Id & ref Count */ QS_EQC_((QEQueueCtr)nFree); /* # free entries available */ QS_EQC_((QEQueueCtr)0); /* min # free entries (unknown) */ QS_END_NOCRIT_() if (e->poolId_ != (uint8_t)0) { /* is it a pool event? */ QF_EVT_REF_CTR_INC_(e); /* increment the reference counter */ } /* posting to the embOS mailbox must succeed, see NOTE3 */ Q_ALLEGE(OS_PutMailCond(&me->eQueue, (OS_CONST_PTR void *)&e) == (char)0); status = true; /* return success */ }
//............................................................................ void BSP_init(void) { Q_ALLEGE(QS_INIT((char *)0)); QS_RESET(); QS_OBJ_DICTIONARY(&l_time_tick); QS_USR_DICTIONARY(PHILO_STAT); BSP_randomSeed(1234U); }
/*..........................................................................*/ QEvent const *QActive_get_(QActive *me) { QEvent const *e; Q_ALLEGE(xQueueReceive(me->eQueue, &e, portMAX_DELAY) == pdPASS); return e; }
//............................................................................ void QActive::postLIFO(QEvent const *e) { QF_INT_LOCK_KEY_ QF_INT_LOCK_(); if (e->dynamic_ != (uint8_t)0) { ++((QEvent *)e)->dynamic_; } QF_INT_UNLOCK_(); Q_ALLEGE(OSQPostFront((OS_EVENT *)m_eQueue, (void *)e) == OS_NO_ERR); }
/*..........................................................................*/ void QActive_start_(QActive * const me, uint_fast8_t prio, QEvt const *qSto[], uint_fast16_t qLen, void *stkSto, uint_fast16_t stkSize, QEvt const *ie) { pthread_t thread; pthread_attr_t attr; struct sched_param param; /* p-threads allocate stack internally */ Q_REQUIRE_ID(600, stkSto == (void *)0); QEQueue_init(&me->eQueue, qSto, qLen); pthread_cond_init(&me->osObject, 0); me->prio = (uint8_t)prio; QF_add_(me); /* make QF aware of this active object */ QMSM_INIT(&me->super, ie); /* take the top-most initial tran. */ QS_FLUSH(); /* flush the QS trace buffer to the host */ pthread_attr_init(&attr); /* SCHED_FIFO corresponds to real-time preemptive priority-based scheduler * NOTE: This scheduling policy requires the superuser privileges */ pthread_attr_setschedpolicy(&attr, SCHED_FIFO); /* see NOTE04 */ param.sched_priority = prio + (sched_get_priority_max(SCHED_FIFO) - QF_MAX_ACTIVE - 3); pthread_attr_setschedparam(&attr, ¶m); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); if (stkSize == 0U) { /* set the allowed minimum */ stkSize = (uint_fast16_t)PTHREAD_STACK_MIN; } pthread_attr_setstacksize(&attr, (size_t)stkSize); if (pthread_create(&thread, &attr, &thread_routine, me) != 0) { /* Creating the p-thread with the SCHED_FIFO policy failed. Most * probably this application has no superuser privileges, so we just * fall back to the default SCHED_OTHER policy and priority 0. */ pthread_attr_setschedpolicy(&attr, SCHED_OTHER); param.sched_priority = 0; pthread_attr_setschedparam(&attr, ¶m); Q_ALLEGE(pthread_create(&thread, &attr, &thread_routine, me)== 0); } pthread_attr_destroy(&attr); me->thread = (uint8_t)1; }
//............................................................................ void BSP_init(void) { Q_ALLEGE(QS_INIT((char *)0)); QS_RESET(); QS_OBJ_DICTIONARY(&l_time_tick); QS_USR_DICTIONARY(PHILO_STAT); l_stdOutStream << "DPP-Qt console example" << endl << "QP " << QP::QF::getVersion() << endl; BSP_randomSeed(1234U); }
/**@brief Function for putting the chip into sleep mode. * * @note This function will not return. */ void BSP_stop() { uint32_t new_cnf = NRF_GPIO->PIN_CNF[BTN_PIN]; uint32_t new_sense = GPIO_PIN_CNF_SENSE_Low; new_cnf &= ~GPIO_PIN_CNF_SENSE_Msk; new_cnf |= (new_sense << GPIO_PIN_CNF_SENSE_Pos); NRF_GPIO->PIN_CNF[BTN_PIN] = new_cnf; // Go to system-off mode (this function will not return; // wakeup will cause a reset). Q_ALLEGE(sd_power_system_off() == NRF_SUCCESS); }
/*..........................................................................*/ void BSP_init(void) { printf("Dining Philosopher Problem example" "\nQEP %s\nQF %s\n" "Press 'p' to pause/un-pause\n" "Press ESC to quit...\n", QEP_getVersion(), QF_getVersion()); BSP_randomSeed(1234U); Q_ALLEGE(QS_INIT((void *)0)); QS_OBJ_DICTIONARY(&l_clock_tick); /* must be called *after* QF_init() */ QS_USR_DICTIONARY(PHILO_STAT); }
/*..........................................................................*/ void QHsm_init(QHsm * const me, QEvt const * const e) { QStateHandler t = me->state.fun; QS_CRIT_STAT_ Q_REQUIRE((me->vptr != (QMsmVtbl const *)0) /* ctor must be executed */ && (me->temp.fun != Q_STATE_CAST(0)) /* ctor must be executed */ && (t == Q_STATE_CAST(&QHsm_top))); /*initial tran. NOT taken */ /* the top-most initial transition must be taken */ Q_ALLEGE((*me->temp.fun)(me, e) == (QState)Q_RET_TRAN); do { /* drill into the target... */ QStateHandler path[QEP_MAX_NEST_DEPTH_]; int_t ip = (int_t)0; /* transition entry path index */ QS_BEGIN_(QS_QEP_STATE_INIT, QS_priv_.smObjFilter, me) QS_OBJ_(me); /* this state machine object */ QS_FUN_(t); /* the source state */ QS_FUN_(me->temp.fun); /* the target of the initial transition */ QS_END_() path[0] = me->temp.fun; (void)QEP_TRIG_(me->temp.fun, QEP_EMPTY_SIG_); while (me->temp.fun != t) { ++ip; path[ip] = me->temp.fun; (void)QEP_TRIG_(me->temp.fun, QEP_EMPTY_SIG_); } me->temp.fun = path[0]; /* entry path must not overflow */ Q_ASSERT(ip < (int_t)QEP_MAX_NEST_DEPTH_); do { /* retrace the entry path in reverse (desired) order... */ QEP_ENTER_(path[ip]); /* enter path[ip] */ --ip; } while (ip >= (int_t)0); t = path[0]; /* current state becomes the new source */ } while (QEP_TRIG_(t, Q_INIT_SIG) == (QState)Q_RET_TRAN); QS_BEGIN_(QS_QEP_INIT_TRAN, QS_priv_.smObjFilter, me) QS_TIME_(); /* time stamp */ QS_OBJ_(me); /* this state machine object */ QS_FUN_(t); /* the new active state */ QS_END_() me->state.fun = t; /* change the current active state */ me->temp.fun = t; /* mark the configuration as stable */ }
/*..........................................................................*/ void BSP_init(int argc, char *argv[]) { printf("Dining Philosophers Problem example" "\nQP %s\n" "Press 'p' to pause\n" "Press 's' to serve\n" "Press ESC to quit...\n", QP_versionStr); BSP_randomSeed(1234U); Q_ALLEGE(QS_INIT((void *)0)); QS_OBJ_DICTIONARY(&l_clock_tick); /* must be called *after* QF_init() */ QS_USR_DICTIONARY(PHILO_STAT); }
/*..........................................................................*/ void QActive_start(QActive *me, uint8_t prio, QEvent const *qSto[], uint32_t qLen, void *stkSto, uint32_t stkSize, QEvent const *ie) { pthread_attr_t attr; struct sched_param param; Q_REQUIRE(stkSto == (void *)0); /* p-threads allocate stack internally */ QEQueue_init(&me->eQueue, qSto, (QEQueueCtr)qLen); pthread_cond_init(&me->osObject, 0); me->prio = prio; QF_add_(me); /* make QF aware of this active object */ QF_ACTIVE_INIT_(&me->super, ie); /* execute the initial transition */ QS_FLUSH(); /* flush the trace buffer to the host */ pthread_attr_init(&attr); /* SCHED_FIFO corresponds to real-time preemptive priority-based scheduler * NOTE: This scheduling policy requires the superuser privileges */ pthread_attr_setschedpolicy(&attr, SCHED_FIFO); /* see NOTE04 */ param.sched_priority = prio + (sched_get_priority_max(SCHED_FIFO) - QF_MAX_ACTIVE - 3); pthread_attr_setschedparam(&attr, ¶m); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); if (pthread_create(&me->thread, &attr, &thread_routine, me) != 0) { /* Creating the p-thread with the SCHED_FIFO policy failed. * Most probably this application has no superuser privileges, * so we just fall back to the default SCHED_OTHER policy * and priority 0. */ pthread_attr_setschedpolicy(&attr, SCHED_OTHER); param.sched_priority = 0; pthread_attr_setschedparam(&attr, ¶m); Q_ALLEGE(pthread_create(&me->thread, &attr, &thread_routine, me)== 0); } pthread_attr_destroy(&attr); }
//............................................................................ void QHsm::init(QEvent const *e) { QStateHandler t; QS_INT_LOCK_KEY_ // the top-most initial transition must be taken Q_ALLEGE((*m_state)(this, e) == Q_RET_TRAN); t = (QStateHandler)&QHsm::top; // HSM starts in the top state do { // drill into the target... QStateHandler path[QEP_MAX_NEST_DEPTH_]; int8_t ip = (int8_t)0; // transition entry path index QS_BEGIN_(QS_QEP_STATE_INIT, QS::smObj_, this) QS_OBJ_(this); // this state machine object QS_FUN_(t); // the source state QS_FUN_(m_state); // the target of the initial transition QS_END_() path[0] = m_state; (void)QEP_TRIG_(m_state, QEP_EMPTY_SIG_); while (m_state != t) { ++ip; path[ip] = m_state; (void)QEP_TRIG_(m_state, QEP_EMPTY_SIG_); } m_state = path[0]; // entry path must not overflow Q_ASSERT(ip < (int8_t)QEP_MAX_NEST_DEPTH_); do { // retrace the entry path in reverse (desired) order... QEP_ENTER_(path[ip]); // enter path[ip] --ip; } while (ip >= (int8_t)0); t = path[0]; // current state becomes the new source } while (QEP_TRIG_(t, Q_INIT_SIG) == Q_RET_TRAN); m_state = t; QS_BEGIN_(QS_QEP_INIT_TRAN, QS::smObj_, this) QS_TIME_(); // time stamp QS_OBJ_(this); // this state machine object QS_FUN_(m_state); // the new active state QS_END_() }
//............................................................................ void BSP_init(void) { // Enable the floating-point unit SCB->CPACR |= (0xFU << 20); // Enable lazy stacking for interrupt handlers. This allows FPU // instructions to be used within interrupt handlers, but at the // expense of extra stack and CPU usage. // FPU->FPCCR |= (1U << FPU_FPCCR_ASPEN_Pos) | (1U << FPU_FPCCR_LSPEN_Pos); // Set the clocking to run directly from the crystal ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // enable clock to the peripherals used by the application SYSCTL->RCGC2 |= (1U << 5); // enable clock to GPIOF __NOP(); // wait after enabling clocks __NOP(); __NOP(); // configure the LEDs and push buttons GPIOF->DIR |= (LED_RED | LED_GREEN | LED_BLUE); // set direction: output GPIOF->DEN |= (LED_RED | LED_GREEN | LED_BLUE); // digital enable GPIOF->DATA_Bits[LED_RED] = 0; // turn the LED off GPIOF->DATA_Bits[LED_GREEN] = 0; // turn the LED off GPIOF->DATA_Bits[LED_BLUE] = 0; // turn the LED off // configure the User Switches GPIOF->DIR &= ~(USR_SW1 | USR_SW2); // set direction: input ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, (USR_SW1 | USR_SW2), GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); BSP_randomSeed(1234U); Q_ALLEGE(QS_INIT(static_cast<void *>(0))); QS_RESET(); QS_OBJ_DICTIONARY(&l_SysTick_Handler); QS_OBJ_DICTIONARY(&l_GPIOPortA_IRQHandler); QS_USR_DICTIONARY(PHILO_STAT); }
//............................................................................ static LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { switch (iMsg) { // Perform initialization upon cration of the main dialog window // NOTE: Any child-windows are NOT created yet at this time, so // the GetDlgItem() function can't be used (it will return NULL). // case WM_CREATE: { l_hWnd = hWnd; // save the window handle // initialize the owner-drawn buttons... // NOTE: must be done *before* the first drawing of the buttons, // so WM_INITDIALOG is too late. // l_userBtn.init(LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_BTN_UP)), LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_BTN_DWN)), LoadCursor(NULL, IDC_HAND)); return 0; } // Perform initialization after all child windows have been created case WM_INITDIALOG: { l_oled.init(BSP_SCREEN_WIDTH, 2U, // scale horizontally by 2 BSP_SCREEN_HEIGHT, 2U, // scale vertically by 2 GetDlgItem(hWnd, IDC_LCD), c_offColor); l_userLED.init(1U, // 1 "segment" (the LED itself) 2U); // 2 bitmaps (for LED OFF/ON states) l_userLED.initSegment(0U, GetDlgItem(hWnd, IDC_LED)); l_userLED.initBitmap(0U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_LED_OFF))); l_userLED.initBitmap(1U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_LED_ON))); l_scoreBoard.init(4U, // 4 "segments" (digits 0-3) 10U); // 10 bitmaps (for 0-9 states) l_scoreBoard.initSegment(0U, GetDlgItem(hWnd, IDC_SEG0)); l_scoreBoard.initSegment(1U, GetDlgItem(hWnd, IDC_SEG1)); l_scoreBoard.initSegment(2U, GetDlgItem(hWnd, IDC_SEG2)); l_scoreBoard.initSegment(3U, GetDlgItem(hWnd, IDC_SEG3)); l_scoreBoard.initBitmap(0U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG0))); l_scoreBoard.initBitmap(1U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG1))); l_scoreBoard.initBitmap(2U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG2))); l_scoreBoard.initBitmap(3U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG3))); l_scoreBoard.initBitmap(4U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG4))); l_scoreBoard.initBitmap(5U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG5))); l_scoreBoard.initBitmap(6U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG6))); l_scoreBoard.initBitmap(7U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG7))); l_scoreBoard.initBitmap(8U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG8))); l_scoreBoard.initBitmap(9U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG9))); BSP_updateScore(0U); // --> QP: spawn the application thread to run main() Q_ALLEGE(CreateThread(NULL, 0, &appThread, NULL, 0, NULL) != (HANDLE)0); return 0; } case WM_DESTROY: { BSP_terminate(0); return 0; } // commands from regular buttons and menus... case WM_COMMAND: { SetFocus(hWnd); switch (wParam) { case IDOK: case IDCANCEL: { BSP_terminate(0); break; } } return 0; } // owner-drawn buttons... case WM_DRAWITEM: { LPDRAWITEMSTRUCT pdis = (LPDRAWITEMSTRUCT)lParam; switch (pdis->CtlID) { case IDC_USER: { // USER owner-drawn button switch (l_userBtn.draw(pdis)) { case OwnerDrawnButton::BTN_DEPRESSED: { BSP_playerTrigger(); l_userLED.setSegment(0U, 1U); break; } case OwnerDrawnButton::BTN_RELEASED: { l_userLED.setSegment(0U, 0U); break; } } break; } } return 0; } // mouse input... case WM_MOUSEWHEEL: { if ((HIWORD(wParam) & 0x8000U) == 0U) { // wheel turned forward? BSP_moveShipUp(); } else { // the wheel was turned backwards BSP_moveShipDown(); } return 0; } // keyboard input... case WM_KEYDOWN: { switch (wParam) { case VK_UP: BSP_moveShipUp(); break; case VK_DOWN: BSP_moveShipDown(); break; case VK_SPACE: BSP_playerTrigger(); break; } return 0; } } return DefWindowProc(hWnd, iMsg, wParam, lParam) ; }
/*..........................................................................*/ static LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { switch (iMsg) { /* Perform initialization upon cration of the main dialog window * NOTE: Any child-windows are NOT created yet at this time, so * the GetDlgItem() function can't be used (it will return NULL). */ case WM_CREATE: { l_hWnd = hWnd; /* save the window handle */ /* initialize the owner-drawn buttons * NOTE: must be done *before* the first drawing of the buttons, * so WM_INITDIALOG is too late. */ OwnerDrawnButton_init(&l_pauseBtn, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_BTN_UP)), LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_BTN_DWN)), LoadCursor(NULL, IDC_HAND)); return 0; } /* Perform initialization after all child windows have been created */ case WM_INITDIALOG: { SegmentDisplay_init(&l_philos, N_PHILO, /* N_PHILO "segments" for the Philos */ 3U); /* 3 bitmaps (for thinking/hungry/eating) */ SegmentDisplay_initSegment(&l_philos, 0U, GetDlgItem(hWnd, IDC_PHILO_0)); SegmentDisplay_initSegment(&l_philos, 1U, GetDlgItem(hWnd, IDC_PHILO_1)); SegmentDisplay_initSegment(&l_philos, 2U, GetDlgItem(hWnd, IDC_PHILO_2)); SegmentDisplay_initSegment(&l_philos, 3U, GetDlgItem(hWnd, IDC_PHILO_3)); SegmentDisplay_initSegment(&l_philos, 4U, GetDlgItem(hWnd, IDC_PHILO_4)); SegmentDisplay_initBitmap(&l_philos, 0U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_THINKING))); SegmentDisplay_initBitmap(&l_philos, 1U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_HUNGRY))); SegmentDisplay_initBitmap(&l_philos, 2U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_EATING))); /* --> QP: spawn the application thread to run main() */ Q_ALLEGE(CreateThread(NULL, 0, &appThread, NULL, 0, NULL) != (HANDLE)0); return 0; } case WM_DESTROY: { BSP_terminate(0); return 0; } /* commands from regular buttons and menus... */ case WM_COMMAND: { SetFocus(hWnd); switch (wParam) { case IDOK: case IDCANCEL: { //QF_PUBLISH(Q_NEW(QEvt, TERMINATE_SIG), (void *)0); BSP_terminate(0); break; } } return 0; } /* owner-drawn buttons... */ case WM_DRAWITEM: { LPDRAWITEMSTRUCT pdis = (LPDRAWITEMSTRUCT)lParam; switch (pdis->CtlID) { case IDC_PAUSE: { /* PAUSE owner-drawn button */ switch (OwnerDrawnButton_draw(&l_pauseBtn,pdis)) { case BTN_DEPRESSED: { static QEvt const pe = { PAUSE_SIG, 0U, 0U }; QACTIVE_POST(AO_Table, &pe, (void *)0); break; } case BTN_RELEASED: { static QEvt const se = { SERVE_SIG, 0U, 0U }; QACTIVE_POST(AO_Table, &se, (void *)0); break; } default: { break; } } break; } } return 0; } /* mouse input... */ case WM_MOUSEWHEEL: { return 0; } /* keyboard input... */ case WM_KEYDOWN: { return 0; } } return DefWindowProc(hWnd, iMsg, wParam, lParam) ; }
/*..........................................................................*/ static LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { switch (iMsg) { /* Perform initialization upon cration of the main dialog window * NOTE: Any child-windows are NOT created yet at this time, so * the GetDlgItem() function can't be used (it will return NULL). */ case WM_CREATE: { l_hWnd = hWnd; /* save the window handle */ /* initialize the owner-drawn buttons... * NOTE: must be done *before* the first drawing of the buttons, * so WM_INITDIALOG is too late. */ OwnerDrawnButton_init(&l_userBtn, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_BTN_UP)), LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_BTN_DWN)), LoadCursor(NULL, IDC_HAND)); return 0; } /* Perform initialization after all child windows have been created */ case WM_INITDIALOG: { GraphicDisplay_init(&l_oled, BSP_SCREEN_WIDTH, 2U, /* scale horizontally by 2 */ BSP_SCREEN_HEIGHT, 2U, /* scale vertically by 2 */ GetDlgItem(hWnd, IDC_LCD), c_offColor); SegmentDisplay_init(&l_userLED, 1U, /* 1 "segment" (the LED itself) */ 2U); /* 2 bitmaps (for LED OFF/ON states) */ SegmentDisplay_initSegment(&l_userLED, 0U, GetDlgItem(hWnd, IDC_LED)); SegmentDisplay_initBitmap(&l_userLED, 0U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_LED_OFF))); SegmentDisplay_initBitmap(&l_userLED, 1U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_LED_ON))); SegmentDisplay_init(&l_scoreBoard, 4U, /* 4 "segments" (digits 0-3) */ 10U); /* 10 bitmaps (for 0-9 states) */ SegmentDisplay_initSegment(&l_scoreBoard, 0U, GetDlgItem(hWnd, IDC_SEG0)); SegmentDisplay_initSegment(&l_scoreBoard, 1U, GetDlgItem(hWnd, IDC_SEG1)); SegmentDisplay_initSegment(&l_scoreBoard, 2U, GetDlgItem(hWnd, IDC_SEG2)); SegmentDisplay_initSegment(&l_scoreBoard, 3U, GetDlgItem(hWnd, IDC_SEG3)); SegmentDisplay_initBitmap(&l_scoreBoard, 0U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG0))); SegmentDisplay_initBitmap(&l_scoreBoard, 1U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG1))); SegmentDisplay_initBitmap(&l_scoreBoard, 2U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG2))); SegmentDisplay_initBitmap(&l_scoreBoard, 3U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG3))); SegmentDisplay_initBitmap(&l_scoreBoard, 4U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG4))); SegmentDisplay_initBitmap(&l_scoreBoard, 5U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG5))); SegmentDisplay_initBitmap(&l_scoreBoard, 6U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG6))); SegmentDisplay_initBitmap(&l_scoreBoard, 7U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG7))); SegmentDisplay_initBitmap(&l_scoreBoard, 8U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG8))); SegmentDisplay_initBitmap(&l_scoreBoard, 9U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_SEG9))); BSP_updateScore(0U); /* --> QP: spawn the application thread to run main_gui() */ Q_ALLEGE(CreateThread(NULL, 0, &appThread, NULL, 0, NULL) != (HANDLE)0); return 0; } case WM_DESTROY: { BSP_terminate(0); return 0; } /* commands from regular buttons and menus... */ case WM_COMMAND: { SetFocus(hWnd); switch (wParam) { case IDOK: case IDCANCEL: { BSP_terminate(0); break; } } return 0; } /* owner-drawn buttons... */ case WM_DRAWITEM: { LPDRAWITEMSTRUCT pdis = (LPDRAWITEMSTRUCT)lParam; switch (pdis->CtlID) { case IDC_USER: { /* USER owner-drawn button */ switch (OwnerDrawnButton_draw(&l_userBtn, pdis)) { case BTN_DEPRESSED: { playerTrigger(); SegmentDisplay_setSegment(&l_userLED, 0U, 1U); break; } case BTN_RELEASED: { SegmentDisplay_setSegment(&l_userLED, 0U, 0U); break; } default: { break; } } break; } } return 0; } /* mouse input... */ case WM_MOUSEWHEEL: { if ((HIWORD(wParam) & 0x8000U) == 0U) {/* wheel turned forward? */ moveShipUp(); } else { /* the wheel was turned backwards */ moveShipDown(); } return 0; } /* keyboard input... */ case WM_KEYDOWN: { switch (wParam) { case VK_UP: moveShipUp(); break; case VK_DOWN: moveShipDown(); break; case VK_SPACE: playerTrigger(); break; } return 0; } } return DefWindowProc(hWnd, iMsg, wParam, lParam) ; }
//............................................................................ void BSP_init(void) { Q_ALLEGE(QS_INIT(l_cmdLine)); QS_RESET(); QS_OBJ_DICTIONARY(&l_clock_tick); QS_USR_DICTIONARY(PLAYER_TRIGGER); }
//............................................................................ static LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { switch (iMsg) { // Perform initialization upon cration of the main dialog window // NOTE: Any child-windows are NOT created yet at this time, so // the GetDlgItem() function can't be used (it will return NULL). // case WM_CREATE: { l_hWnd = hWnd; // save the window handle // initialize the owner-drawn buttons // NOTE: must be done *before* the first drawing of the buttons, // so WM_INITDIALOG is too late. // l_pauseBtn.init(LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_BTN_UP)), LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_BTN_DWN)), LoadCursor(NULL, IDC_HAND)); return 0; } // Perform initialization after all child windows have been created case WM_INITDIALOG: { l_philos.init(N_PHILO, // N_PHILO "segments" for the Philos 3U); // 3 bitmaps (for thinking/hungry/eating) l_philos.initSegment(0U, GetDlgItem(hWnd, IDC_PHILO_0)); l_philos.initSegment(1U, GetDlgItem(hWnd, IDC_PHILO_1)); l_philos.initSegment(2U, GetDlgItem(hWnd, IDC_PHILO_2)); l_philos.initSegment(3U, GetDlgItem(hWnd, IDC_PHILO_3)); l_philos.initSegment(4U, GetDlgItem(hWnd, IDC_PHILO_4)); l_philos.initBitmap(0U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_THINKING))); l_philos.initBitmap(1U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_HUNGRY))); l_philos.initBitmap(2U, LoadBitmap(l_hInst, MAKEINTRESOURCE(IDB_EATING))); // --> QP: spawn the application thread to run main() Q_ALLEGE(CreateThread(NULL, 0, &appThread, NULL, 0, NULL) != (HANDLE)0); return 0; } case WM_DESTROY: { BSP_terminate(0); return 0; } // commands from regular buttons and menus... case WM_COMMAND: { SetFocus(hWnd); switch (wParam) { case IDOK: case IDCANCEL: { //QP::QF::PUBLISH(Q_NEW(QP::QEvt, TERMINATE_SIG), (void *)0); BSP_terminate(0); break; } } return 0; } // owner-drawn buttons... case WM_DRAWITEM: { LPDRAWITEMSTRUCT pdis = (LPDRAWITEMSTRUCT)lParam; switch (pdis->CtlID) { case IDC_PAUSE: { // PAUSE owner-drawn button static QP::QEvt pe = QEVT_INITIALIZER(PAUSE_SIG); switch (l_pauseBtn.draw(pdis)) { case OwnerDrawnButton::BTN_DEPRESSED: { AO_Table->POST(&pe, (void *)0); break; } case OwnerDrawnButton::BTN_RELEASED: { AO_Table->POST(&pe, (void *)0); break; } } break; } } return 0; } // mouse input... case WM_MOUSEWHEEL: { return 0; } // keyboard input... case WM_KEYDOWN: { return 0; } } return DefWindowProc(hWnd, iMsg, wParam, lParam) ; }