void ButtonSprite::onClicked()
{
if (callbackFunc) {
callbackFunc();
// touchListener->setEnabled(false);
}
}
/** This function runs as a polling task at the system clock rate if there is no interrupt driver (such as Ip-Unidig) being used */
void drvAPS_EM::pollerThread()
{
while(1) { /* Do forever */
if (acquiring_) callbackFunc(0);
epicsThreadSleep(epicsThreadSleepQuantum());
}
}
/*FUNCTION**********************************************************************
*
* Function Name : HWTIMER_SYS_UnblockCallback
* Description : The function is used to unblock previously blocked callbacks.
* If there is a callback pending, it gets immediately executed. This function
* must not be called from a callback routine (it does not make sense to do so
* anyway as callback function never gets executed while callbacks are blocked).
*
*END**************************************************************************/
_hwtimer_error_code_t HWTIMER_SYS_UnblockCallback(hwtimer_t *hwtimer)
{
hwtimer_callback_t callbackFunc;
hwtimer_t volatile *hwtimerVol = hwtimer;
/* Check input parameters */
if (NULL == hwtimer)
{
return kHwtimerInvalidInput;
}
/* Unblock callbacks in ISR. No more pending request could arrive after this. */
hwtimerVol->callbackBlocked = 0U;
/* Check for any previously set pending requests during blocked state */
if (hwtimerVol->callbackPending)
{
callbackFunc = hwtimerVol->callbackFunc;
if (NULL != callbackFunc)
{
/* Prevent invocation of callback from ISR (callback may not be re-entrant) */
hwtimerVol->callbackFunc = NULL;
callbackFunc(hwtimerVol->callbackData);
/* Allow invocation of callback from ISR */
hwtimerVol->callbackFunc = callbackFunc;
}
/* Clear pending flag, callback just serviced */
hwtimerVol->callbackPending = 0U;
}
return kHwtimerSuccess;
}
IGraphAlg* CreateAlgorithm()
{
//initialize random seed (necessary before calling doubleSweep() ).
srand( static_cast<unsigned int>(time(nullptr)) );
sa_prob_func_ptr probFunc(new ExpProbability);
sa_temp_func_ptr tempFunc(new IntervalTemperature);
sa_callback_func_ptr callbackFunc(new DrawingCallback("."));
IGraphAlg* alg = new SimulatedAnnealing(probFunc, tempFunc, callbackFunc);
return alg;
}
int
rf_State_LastState(RF_RaidAccessDesc_t *desc)
{
void (*callbackFunc) (RF_CBParam_t) = desc->callbackFunc;
RF_CBParam_t callbackArg;
callbackArg.p = desc->callbackArg;
/*
* We don't support non-async IO.
*/
KASSERT(desc->async_flag);
/*
* That's all the IO for this one... unbusy the 'disk'.
*/
rf_disk_unbusy(desc);
/*
* Wakeup any requests waiting to go.
*/
rf_lock_mutex2(desc->raidPtr->mutex);
desc->raidPtr->openings++;
rf_unlock_mutex2(desc->raidPtr->mutex);
rf_lock_mutex2(desc->raidPtr->iodone_lock);
rf_signal_cond2(desc->raidPtr->iodone_cv);
rf_unlock_mutex2(desc->raidPtr->iodone_lock);
/*
* The parity_map hook has to go here, because the iodone
* callback goes straight into the kintf layer.
*/
if (desc->raidPtr->parity_map != NULL &&
desc->type == RF_IO_TYPE_WRITE)
rf_paritymap_end(desc->raidPtr->parity_map,
desc->raidAddress, desc->numBlocks);
/* printf("Calling biodone on 0x%x\n",desc->bp); */
biodone(desc->bp); /* access came through ioctl */
if (callbackFunc)
callbackFunc(callbackArg);
rf_FreeRaidAccDesc(desc);
return RF_FALSE;
}
int
rf_State_LastState(RF_RaidAccessDesc_t *desc)
{
void (*callbackFunc) (RF_CBParam_t) = desc->callbackFunc;
RF_CBParam_t callbackArg;
callbackArg.p = desc->callbackArg;
/*
* If this is not an async request, wake up the caller.
*/
if (desc->async_flag == 0)
wakeup(desc->bp);
/*
* That's all the IO for this one... Unbusy the 'disk'.
*/
rf_disk_unbusy(desc);
/*
* Wakeup any requests waiting to go.
*/
RF_LOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
((RF_Raid_t *) desc->raidPtr)->openings++;
RF_UNLOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
/* Wake up any pending I/O. */
raidstart(((RF_Raid_t *) desc->raidPtr));
/* printf("%s: Calling biodone on 0x%x.\n", __func__, desc->bp); */
splassert(IPL_BIO);
biodone(desc->bp); /* Access came through ioctl. */
if (callbackFunc)
callbackFunc(callbackArg);
rf_FreeRaidAccDesc(desc);
return RF_FALSE;
}
static DWORD WINAPI ThreadProc(LPVOID param)
{
auto threadRef = static_cast<ThreadRef*>(param);
threadRef->callbackFunc(threadRef->callbackObj);
return 0;
}
/*******************************************************************************
Routine Name: i2c_continue
Form: int i2c_continue( void )
Parameters: none
Return value: int
I2C_R_TRANS_FIN(=1) : send and receive is finished
I2C_R_TRANS_CONT_OK(=0) : send and receive is continued (success)
I2C_R_TRANS_CONT_NG(=-1) : send and receive is continued (failure)
I2C_R_TRANS_FIN_NG(=-2) : send and receive is finished (failure)
Description: process to continue send and receive
******************************************************************************/
int i2c_continue( void )
{
unsigned char i2c0stat;
unsigned char setbit;
cbfI2c callbackFunc;
i2c0stat = I2C0STAT;
switch(_gsCtrlParam.status){
case I2C_SEND_SLAVE_ADDRESS:
/* transmission error check */
if((i2c0stat&I2C0STAT_I20ER) == I2C0STAT_I20ER){
_gsCtrlParam.status = I2C_TRANS_END;
_gsCtrlParam.errStat = I2C_ERR_SEND_ERR;
I2C0CON = (unsigned char)0x00; /* stop i2c */
if( _gsCtrlParam.callBack != (void *)0 ){
callbackFunc = _gsCtrlParam.callBack;
_gsCtrlParam.callBack = (void *)0;
callbackFunc( _gsCtrlParam.cnt, _gsCtrlParam.errStat );
}
return ( I2C_R_TRANS_FIN );
}
/* NACK reception check */
else if((i2c0stat&I2C0STAT_I20ACR) == I2C0STAT_I20ACR){
_gsCtrlParam.status = I2C_TRANS_END;
_gsCtrlParam.errStat = I2C_ERR_ACR;
I2C0CON = (unsigned char)I2C0CON_I20SP; /* Stop condition */
}
/* Slave address transmission success */
else{
if(_gsCtrlParam.addr_size != 0){
_gsCtrlParam.status = I2C_SEND_ADDRESS;
I2C0TD = (unsigned char)*_gsCtrlParam.addr;
_gsCtrlParam.addr++;
_gsCtrlParam.addr_size--;
I2C0CON = (unsigned char)I2C0CON_I20ST; /* i2c start */
}
else{
if(_gsCtrlParam.mode != 0 ){
_gsCtrlParam.status = I2C_RECEIVE_DATA;
setbit = I2C0CON_I20ST;
if( ( _gsCtrlParam.data_size - 1) == _gsCtrlParam.cnt ){
setbit |= (unsigned char)I2C0CON_I20ACT;
}
I2C0CON = setbit;
}
else{
_gsCtrlParam.status = I2C_SEND_DATA;
I2C0TD = (unsigned char)*_gsCtrlParam.data;
_gsCtrlParam.data++;
_gsCtrlParam.cnt++;
I2C0CON = (unsigned char)I2C0CON_I20ST;
}
}
}
return(I2C_R_TRANS_CONT_OK);
case I2C_SEND_ADDRESS:
if((i2c0stat&I2C0STAT_I20ACR) == I2C0STAT_I20ACR){
_gsCtrlParam.status = I2C_TRANS_END;
_gsCtrlParam.errStat = I2C_ERR_ACR;
I2C0CON = (unsigned char)I2C0CON_I20SP; /* Stop condition */
}
else{
if( _gsCtrlParam.addr_size != 0 ){
I2C0TD = (unsigned char)*_gsCtrlParam.addr;
_gsCtrlParam.addr++;
_gsCtrlParam.addr_size--;
I2C0CON = (unsigned char)I2C0CON_I20ST; /* i2c start */
}
/* Address transmission success */
else{
if(_gsCtrlParam.data_size == 0){
_gsCtrlParam.status = I2C_TRANS_END;
I2C0CON = (unsigned char)I2C0CON_I20SP; /* Stop condition */
}
else{
if(_gsCtrlParam.mode != 0 ){/* receive mode */
_gsCtrlParam.status = I2C_SEND_SLAVE_ADDRESS;
I20RW = 1; /* Receive mode */
I20RS = 1; /* Restart condition */
}
else{/* send mode */
_gsCtrlParam.status = I2C_SEND_DATA;
I2C0TD = (unsigned char)*_gsCtrlParam.data;
_gsCtrlParam.data++;
_gsCtrlParam.cnt++;
I2C0CON = (unsigned char)I2C0CON_I20ST;
}
}
}
}
return ( I2C_R_TRANS_CONT_OK );
case I2C_SEND_DATA:
if((i2c0stat&I2C0STAT_I20ACR) == I2C0STAT_I20ACR){
_gsCtrlParam.status = I2C_TRANS_END;
_gsCtrlParam.errStat = I2C_ERR_ACR;
I2C0CON = (unsigned char)I2C0CON_I20SP; /* Stop condition */
}
else if( _gsCtrlParam.data_size != _gsCtrlParam.cnt ){
I2C0TD = (unsigned char)*_gsCtrlParam.data;
_gsCtrlParam.data++;
_gsCtrlParam.cnt++;
I2C0CON = (unsigned char)I2C0CON_I20ST;
}
else{
_gsCtrlParam.status = (unsigned char)I2C_TRANS_END;
/*--- Stop condition send ? ---*/
I2C0CON = (unsigned char)I2C0CON_I20SP; /* Stop condition */
}
return ( I2C_R_TRANS_CONT_OK );
case I2C_RECEIVE_DATA:
*_gsCtrlParam.data = I2C0RD;
_gsCtrlParam.data++;
_gsCtrlParam.cnt++;
if( _gsCtrlParam.data_size != _gsCtrlParam.cnt ){
setbit = (unsigned char)I2C0CON_I20ST;
if( ( _gsCtrlParam.data_size - 1) == _gsCtrlParam.cnt ){
setbit |= (unsigned char)I2C0CON_I20ACT;
}
I2C0CON = setbit;
}
else{
_gsCtrlParam.status = (unsigned char)I2C_TRANS_END;
I2C0CON = (unsigned char)I2C0CON_I20SP; /* Stop condition */
}
return(I2C_R_TRANS_CONT_OK);
case I2C_TRANS_END:
default:
if( _gsCtrlParam.callBack != (void *)0 ){
callbackFunc = _gsCtrlParam.callBack;
_gsCtrlParam.callBack = (void *)0;
callbackFunc( _gsCtrlParam.cnt, _gsCtrlParam.errStat );
}
break;
}
return ( I2C_R_TRANS_FIN );
}
