/* ** =================================================================== ** Method : CI2C1_SendBlock (component InternalI2C) ** Description : ** When working as a MASTER, this method writes one (7-bit ** addressing) or two (10-bit addressing) slave address bytes ** inclusive of R/W bit = 0 to the I2C bus and then writes the ** block of characters to the bus. The slave address must be ** specified before, by the "SelectSlave" or "SlaveSelect10" ** method or in component initialization section, "Target slave ** address init" property. If interrupt service is enabled and ** the method returns ERR_OK, it doesn't mean that transmission ** was successful. The state of transmission is detectable by ** means of events (OnTransmitData, OnError or OnArbitLost). ** Data to be send is not copied to an internal buffer and ** remains in the original location. Therefore the content of ** the buffer should not be changed until the transmission is ** complete. Event OnTransmitData can be used to detect the end ** of the transmission. ** When working as a SLAVE, this method writes a block of ** characters to the internal output slave buffer and then, ** after the master starts the communication, to the I2C bus. ** If no character is ready for a transmission (internal output ** slave buffer is empty), the "Empty character" will be sent ** (see "Empty character" property). In SLAVE mode the data are ** copied to an internal buffer, if specified by "Output buffer ** size" property. ** Parameters : ** NAME - DESCRIPTION ** * Ptr - Pointer to the block of data to send. ** Siz - Size of the block. ** * Snt - Amount of data sent (moved to a buffer). ** In master mode, if interrupt support is ** enabled, the parameter always returns the ** same value as the parameter 'Siz' of this ** method. ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** ERR_DISABLED - Device is disabled ** ERR_BUSY - The slave device is busy, it ** does not respond by the acknowledge (only ** in master mode and when interrupt service ** is disabled) ** ERR_BUSOFF - Clock timeout elapsed or ** device cannot transmit data ** ERR_TXFULL - Transmitter is full. Some data ** has not been sent. (slave mode only) ** ERR_ARBITR - Arbitration lost (only when ** interrupt service is disabled and in master ** mode) ** =================================================================== */ byte CI2C1_SendBlock(void *Ptr,word Siz,word *Snt) { LDD_TError Error; if (Siz == 0U) { /* Test variable Size on zero */ *Snt = 0U; return ERR_OK; /* If zero then OK */ } EnterCritical(); /* Enter the critical section */ Error = IntI2cLdd1_MasterSendBlock(IntI2cLdd1_DeviceDataPtr, (LDD_TData *)Ptr, (LDD_I2C_TSize)Siz, LDD_I2C_SEND_STOP); /* Send one data byte */ if (Error == ERR_BUSY) { ExitCritical(); /* Exit the critical section */ return ERR_BUSOFF; } OutLenM = Siz; /* Set length of output bufer's content */ ExitCritical(); /* Exit the critical section */ *Snt = Siz; /* Dummy number of really sent chars */ return ERR_OK; /* OK */ }
/* ** =================================================================== ** Method : Serial_2_ClearRxBuf (component AsynchroSerial) ** Description : ** Clears the receive buffer. ** This method is available only if non-zero length of the ** input buffer is defined and the receiver property is enabled. ** Parameters : None ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** =================================================================== */ byte Serial_2_ClearRxBuf(void) { EnterCritical(); /* Save the PS register */ Serial_2_InpLen = 0x00U; /* Set number of chars in the receive buffer to 0 */ InpIndxR = 0x00U; /* Reset read index to the receive buffer */ InpIndxW = 0x00U; /* Reset write index to the receive buffer */ SerFlag &= (byte)(~(byte)(CHAR_IN_RX | FULL_RX)); /* Clear the flags indicating a char in buffer */ ExitCritical(); /* Restore the PS register */ return ERR_OK; /* OK */ }
void route_show(void) { int i; print_route(NULL); EnterCritical(); for (i = 0 ; i < GETNUMROUTEENTRIES ; i++) { print_route(GETROUTEP(i)); } ExitCritical(); }
/* ** =================================================================== ** Method : SM1_GetError (component SynchroMaster) ** Description : ** Returns a set of errors on the channel (errors that cannot ** be returned in given methods). The component accumulates ** errors in a set; after calling [GetError] this set is ** returned and cleared. This method is available only if the ** "Interrupt service/event" property is enabled. ** Parameters : ** NAME - DESCRIPTION ** * Err - A pointer to the returned set of errors ** Returns : ** --- - Error code (if GetError did not succeed), ** possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** =================================================================== */ byte SM1_GetError(SM1_TError *Err) { EnterCritical(); /* Disable global interrupts */ Err->err = 0U; Err->errName.OverRun = (((ErrFlag & OVERRUN_ERR) != 0U)? 1U : 0U); /* Overrun error */ Err->errName.RxBufOvf = (((ErrFlag & FULL_RX) != 0U)? 1U : 0U); /* Buffer overflow */ ErrFlag = 0x00U; /* Reset error flags */ ExitCritical(); /* Enable global interrupts */ return ERR_OK; /* OK */ }
/* ** =================================================================== ** Method : SM1_ClearRxBuf (component SynchroMaster) ** Description : ** Clears the receive buffer. This method is available only if ** a non-zero length of input buffer is defined. ** Parameters : None ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** =================================================================== */ byte SM1_ClearRxBuf(void) { EnterCritical(); /* Disable global interrupts */ SM1_InpLen = 0U; /* Set number of chars in the transmit buffer to 0 */ InpIndexW = 0x00U; /* Set index on the first item in the transmit buffer */ InpIndexR = 0x00U; SerFlag &= (byte)~(OVERRUN_ERR | FULL_RX); /* Clear flags */ ExitCritical(); /* Enable global interrupts */ return ERR_OK; /* OK */ }
/* ** =================================================================== ** Method : TMOUT1_LeaveCounter (component Timeout) ** ** Description : ** To be called to return the counter. Note that a counter ** always should be returned so it can be reused. ** Parameters : ** NAME - DESCRIPTION ** handle - Counter handle ** Returns : Nothing ** =================================================================== */ void TMOUT1_LeaveCounter(TMOUT1_CounterHandle handle) { if (handle==TMOUT1_OUT_OF_HANDLE) { return; } EnterCritical(); TMOUT1_Counters[handle] = 0; TMOUT1_FreeCounters[handle]=TRUE; ExitCritical(); }
/* ** =================================================================== ** Method : hwExpIn_GetRxIdle (bean AsynchroSerial) ** ** Description : ** Returns the state of the receiver idle flag. This method ** is available only if event <OnIdle> is disabled. ** Parameters : None ** Returns : ** --- - The state of the receiver idle flag. ** =================================================================== */ bool hwExpIn_GetRxIdle(void) { bool Result; EnterCritical(); /* Save the PS register */ Result = (bool)((SerFlag & IDLE_ERR)?1:0); /* If idle signal has been received? */ SerFlag &= ~IDLE_ERR; /* Reset idle signal flag */ ExitCritical(); /* Restore the PS register */ return Result; /* OK */ }
/*---------------------------------------------------------------------------*/ void watchdog_periodic(void) { #if PLATFORM_CONF_ENABLE_WATCHDOG EnterCritical(); SIM_SRVCOP = SIM_SRVCOP_SRVCOP(COP_KEY_1); SIM_SRVCOP = SIM_SRVCOP_SRVCOP(COP_KEY_2); /* {Default RTOS Adapter} Critical section end, general PE function is used */ ExitCritical(); #endif /* PLATFORM_CONF_ENABLE_WATCHDOG */ }
void TACHO_CalcSpeed(void) { #if 1 /* we calculate the speed as follow: 1000 steps/sec = delta * ----------------- samplePeriod (ms) As this function may be called very frequently, it is important to make it as efficient as possible! */ int16_t deltaLeft, deltaRight, newLeft, newRight, oldLeft, oldRight; int32_t speedLeft, speedRight; bool negLeft, negRight; EnterCritical(); oldLeft = (int16_t)TACHO_LeftPosHistory[TACHO_PosHistory_Index]; /* oldest left entry */ oldRight = (int16_t)TACHO_RightPosHistory[TACHO_PosHistory_Index]; /* oldest right entry */ if (TACHO_PosHistory_Index==0) { /* get newest entry */ newLeft = (int16_t)TACHO_LeftPosHistory[NOF_HISTORY-1]; newRight = (int16_t)TACHO_RightPosHistory[NOF_HISTORY-1]; } else { newLeft = (int16_t)TACHO_LeftPosHistory[TACHO_PosHistory_Index-1]; newRight = (int16_t)TACHO_RightPosHistory[TACHO_PosHistory_Index-1]; } ExitCritical(); deltaLeft = oldLeft-newLeft; /* delta of oldest position and most recent one */ /* use unsigned arithmetic */ if (deltaLeft < 0) { deltaLeft = -deltaLeft; negLeft = TRUE; } else { negLeft = FALSE; } deltaRight = oldRight-newRight; /* delta of oldest position and most recent one */ /* use unsigned arithmetic */ if (deltaRight < 0) { deltaRight = -deltaRight; negRight = TRUE; } else { negRight = FALSE; } /* calculate speed. this is based on the delta and the time (number of samples or entries in the history table) */ speedLeft = (int32_t)(deltaLeft * 1000/(TACHO_SAMPLE_PERIOD_MS*(NOF_HISTORY-1))); if (negLeft) { speedLeft = -speedLeft; } speedRight = (int32_t)(deltaRight * 1000/(TACHO_SAMPLE_PERIOD_MS*(NOF_HISTORY-1))); if (negRight) { speedRight = -speedRight; } TACHO_currLeftSpeed = -speedLeft; /* store current speed in global variable */ TACHO_currRightSpeed = -speedRight; /* store current speed in global variable */ #else /*! \todo Implement function */ #endif }
int get_ifnum_cardno(int ifnum) { if_entry_p ife; int cardno; ASSERTIFNUM(ifnum); EnterCritical(); ife = GETIFP(ifnum); cardno = ife->cardno; ExitCritical(); return cardno; }
/* ** =================================================================== ** Method : RC_SendChar (component AsynchroSerial) ** Description : ** Sends one character to the channel. If the component is ** temporarily disabled (Disable method) SendChar method only ** stores data into an output buffer. In case of a zero output ** buffer size, only one character can be stored. Enabling the ** component (Enable method) starts the transmission of the ** stored data. This method is available only if the ** transmitter property is enabled. ** Parameters : ** NAME - DESCRIPTION ** Chr - Character to send ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** ERR_TXFULL - Transmitter is full ** =================================================================== */ byte RC_SendChar(RC_TComData Chr) { if ((SerFlag & FULL_TX) != 0U) { /* Is any char is in TX buffer */ return ERR_TXFULL; /* If yes then error */ } EnterCritical(); /* Disable global interrupts */ OutBuffer = Chr; /* Store char to temporary variable */ (void)ASerialLdd1_SendBlock(ASerialLdd1_DeviceDataPtr, (LDD_TData *)&OutBuffer, 1U); /* Send one data byte */ SerFlag |= (FULL_TX); /* Set the flag "full TX buffer" */ ExitCritical(); /* Enable global interrupts */ return ERR_OK; /* OK */ }
/* ** =================================================================== ** Method : TMOUT1_AddTick (component Timeout) ** ** Description : ** Method to be called from a priodic timer or interrupt. It ** will decrement all current counters by one down to zero. ** Parameters : None ** Returns : Nothing ** =================================================================== */ void TMOUT1_AddTick(void) { byte i; EnterCritical(); for(i=0;i<TMOUT1_NOF_COUNTERS;i++) { if (TMOUT1_Counters[i]>0) { TMOUT1_Counters[i]--; } } ExitCritical(); }
/* ** =================================================================== ** Method : TMOUT1_CounterExpired (component Timeout) ** ** Description : ** Returns true if the timeout counter has been expired ** Parameters : ** NAME - DESCRIPTION ** handle - The timeout handle retrieved using ** GetCounter() ** Returns : ** --- - Returns TRUE if the counter has been ** expired, FALSE otherwise ** =================================================================== */ bool TMOUT1_CounterExpired(TMOUT1_CounterHandle handle) { bool res; if (handle==TMOUT1_OUT_OF_HANDLE) { return TRUE; } EnterCritical(); res = (bool)(TMOUT1_Counters[handle]==0); ExitCritical(); return res; }
/* ===================================================================*/ bool SPI_SD_GetBlockReceivedStatus(LDD_TDeviceData *DeviceDataPtr) { uint8_t Status; /* Temporary variable for flag saving */ /* {Default RTOS Adapter} Critical section begin, general PE function is used */ EnterCritical(); Status = ((SPI_SD_TDeviceDataPtr)DeviceDataPtr)->SerFlag; /* Save flag for return */ ((SPI_SD_TDeviceDataPtr)DeviceDataPtr)->SerFlag &= (uint8_t)(~(uint8_t)BLOCK_RECEIVED); /* Clear data block sent flag */ /* {Default RTOS Adapter} Critical section end, general PE function is used */ ExitCritical(); return (bool)(((Status & BLOCK_RECEIVED) != 0U)? TRUE : FALSE); /* Return saved status */ }
void wakeup (void *chan) { int i; d0printf("%d wakeup chan: %p\n", getpid(),chan); global_ftable->counter1++; EnterCritical(); for (i = 0; i < NENV; i++) if (synch_table->wchan[i] == chan) synch_table->wchan[i] = (void *)0; ExitCritical(); }
/* ===================================================================*/ LDD_TError ASerialLdd3_GetError(LDD_TDeviceData *DeviceDataPtr, LDD_SERIAL_TError *ErrorPtr) { ASerialLdd3_TDeviceDataPtr DeviceDataPrv = (ASerialLdd3_TDeviceDataPtr)DeviceDataPtr; /* {Bareboard RTOS Adapter} Critical section begin (RTOS function call is defined by Bareboard RTOS Adapter property) */ EnterCritical(); *ErrorPtr = DeviceDataPrv->ErrFlag; DeviceDataPrv->ErrFlag = 0x00U; /* Reset error flags */ /* {Bareboard RTOS Adapter} Critical section ends (RTOS function call is defined by Bareboard RTOS Adapter property) */ ExitCritical(); return ERR_OK; /* OK */ }
/* ===================================================================*/ LDD_TError ASerialLdd1_GetError(LDD_TDeviceData *DeviceDataPtr, LDD_SERIAL_TError *ErrorPtr) { ASerialLdd1_TDeviceDataPtr DeviceDataPrv = (ASerialLdd1_TDeviceDataPtr)DeviceDataPtr; /* {Default RTOS Adapter} Critical section begin, general PE function is used */ EnterCritical(); *ErrorPtr = DeviceDataPrv->ErrFlag; DeviceDataPrv->ErrFlag = 0x00U; /* Reset error flags */ /* {Default RTOS Adapter} Critical section end, general PE function is used */ ExitCritical(); return ERR_OK; /* OK */ }
/* ** =================================================================== ** Method : Serial_2_SendChar (component AsynchroSerial) ** Description : ** Sends one character to the channel. If the component is ** temporarily disabled (Disable method) SendChar method only ** stores data into an output buffer. In case of a zero output ** buffer size, only one character can be stored. Enabling the ** component (Enable method) starts the transmission of the ** stored data. This method is available only if the ** transmitter property is enabled. ** Parameters : ** NAME - DESCRIPTION ** Chr - Character to send ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** ERR_TXFULL - Transmitter is full ** =================================================================== */ byte Serial_2_SendChar(Serial_2_TComData Chr) { if (SerFlag & FULL_TX) { /* Is any char in TX buffer? */ return ERR_TXFULL; /* If yes then error */ } EnterCritical(); /* Save the PS register */ (void)SCI2S1; /* Reset interrupt request flag */ SCI2D = (byte)Chr; /* Store char to the transmitter register */ SCI2C2_TIE = 0x01U; /* Enable transmit interrupt */ SerFlag |= FULL_TX; /* Set the flag "full TX buffer" */ ExitCritical(); /* Restore the PS register */ return ERR_OK; /* OK */ }
int iter_ifnum(unsigned int flags) { if_entry_p ife; EnterCritical(); for(;;) { if (ifnum_iter >= GETNUMIFENTRIES || ifnum_iter < 0) { ExitCritical(); return -1; } if (flags) { ife = GETIFP(ifnum_iter); if ((ife->flags & flags) == flags) { ExitCritical(); return ifnum_iter++; } } else { ExitCritical(); return ifnum_iter++; } ifnum_iter++; } }
/* ** =================================================================== ** Method : WriteWord (bean IntFLASH) ** ** Description : ** This method is internal. It is used by Processor Expert ** only. ** =================================================================== */ static byte WriteWord(dword Addr,word Data16) { EnterCritical(); /* Enter critical section */ ClearFlags(); /* Clear all flags */ if (FSTAT_CBEIF == 0) { /* Is command buffer full ? */ ExitCritical(); /* Exit critical section */ return ERR_BUSY; /* If yes then error */ } *(word *far) Addr = Data16; /* Array address and program data */ FCMD = 32; /* Word program command */ FSTAT = 128; /* Clear flag command buffer empty */ if ((FSTAT_PVIOL == 1)||(FSTAT_ACCERR == 1)) { /* Is protection violation or acces error detected ? */ ExitCritical(); /* Exit critical section */ return ERR_NOTAVAIL; /* If yes then error */ } while (FSTAT_CBEIF == 0); /* Wait to buffer empty */ while (FSTAT_CCIF == 0); /* Wait to command complete */ ExitCritical(); /* Exit critical section */ if (*(word *far) Addr != Data16) /* Was attempt to write data to the given address errorneous? */ return ERR_VALUE; /* If yes then error */ return ERR_OK; /* OK */ }
/* ===================================================================*/ LDD_TError RealTimeLdd1_Reset(LDD_TDeviceData *DeviceDataPtr) { RealTimeLdd1_TDeviceData *DeviceDataPrv = (RealTimeLdd1_TDeviceData *)DeviceDataPtr; /* {Default RTOS Adapter} Critical section begin, general PE function is used */ EnterCritical(); (void)TU2_ResetCounter(DeviceDataPrv->LinkedDeviceDataPtr); /* Reset counter of TimerUnit */ DeviceDataPrv->TimerTicks = 0U; /* Reset counter of timer ticks */ DeviceDataPrv->Overflow = FALSE; /* Reset counter overflow flag */ /* {Default RTOS Adapter} Critical section end, general PE function is used */ ExitCritical(); return ERR_OK; }
/* ** =================================================================== ** Method : AS1_SendChar (bean AsynchroSerial) ** ** Description : ** Sends one character to the channel. If the bean is ** temporarily disabled (Disable method) SendChar method ** only stores data into an output buffer. In case of a zero ** output buffer size, only one character can be stored. ** Enabling the bean (Enable method) starts the transmission ** of the stored data. This method is available only if the ** transmitter property is enabled. ** Parameters : ** NAME - DESCRIPTION ** Chr - Character to send ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** ERR_TXFULL - Transmitter is full ** =================================================================== */ byte AS1_SendChar(AS1_TComData Chr) { if(SerFlag & FULL_TX) { /* Is any char in the TX buffer */ return ERR_TXFULL; /* If yes then error */ } EnterCritical(); /* Save the PS register */ (void) SCISR1; /* Reset interrupt request flag */ SCIDRL = (byte)Chr; /* Store char to transmitter register */ SCICR2_SCTIE = 1; /* Enable transmit interrupt */ SerFlag |= FULL_TX; /* Set the flag "full TX buffer" */ ExitCritical(); /* Restore the PS register */ return ERR_OK; /* OK */ }
/* ===================================================================*/ LDD_TError IntI2cLdd1_MasterReceiveBlock(LDD_TDeviceData *DeviceDataPtr, LDD_TData *BufferPtr, LDD_I2C_TSize Size, LDD_I2C_TSendStop SendStop) { IntI2cLdd1_TDeviceData *DeviceDataPrv = (IntI2cLdd1_TDeviceData *)DeviceDataPtr; if (Size == 0x00U) { /* Test variable Size on zero */ return ERR_OK; /* If zero then OK */ } if (SendStop == LDD_I2C_NO_SEND_STOP) { /* Test variable SendStop on supported value */ return ERR_PARAM_MODE; /* If not supported value then error */ } if ((DeviceDataPrv->SerFlag & GENERAL_CALL) != 0x00U) { /* Is the general call flag set (SelectSlaveDevice - address type is general call) ? */ return ERR_NOTAVAIL; /* It is not possible to receive data - Call SelectSlaveDevice method */ } if (DeviceDataPrv->SendStop == LDD_I2C_SEND_STOP) { if ((I2C_PDD_GetBusStatus(I2C0_BASE_PTR) == I2C_PDD_BUS_BUSY) || /* Is the bus busy? */ \ ((DeviceDataPrv->SerFlag & MASTER_IN_PROGRES) != 0x00U) || \ (DeviceDataPrv->InpLenM != 0x00U)) { return ERR_BUSY; /* If yes then error */ } } else { if(((DeviceDataPrv->SerFlag & MASTER_IN_PROGRES) != 0x00U) || /* Is the bus busy? */ \ (DeviceDataPrv->InpLenM != 0x00U)) { return ERR_BUSY; /* If yes then error */ } } /* {Default RTOS Adapter} Critical section begin, general PE function is used */ EnterCritical(); DeviceDataPrv->SerFlag |= MASTER_IN_PROGRES; /* Set flag "busy" */ DeviceDataPrv->InpPtrM = (uint8_t *)BufferPtr; /* Save pointer to data for reception */ DeviceDataPrv->InpByteMNum = 0x00U; /* Clear data number */ DeviceDataPrv->InpLenM = Size; /* Set the counter of input bufer's content */ DeviceDataPrv->SendStop = SendStop; /* Set generating stop condition */ I2C_PDD_SetTransmitMode(I2C0_BASE_PTR, I2C_PDD_TX_DIRECTION); /* Set TX mode */ if (I2C_PDD_GetMasterMode(I2C0_BASE_PTR) == I2C_PDD_MASTER_MODE) { /* Is device in master mode? */ I2C_PDD_RepeatStart(I2C0_BASE_PTR); /* If yes then repeat start cycle generated */ } else { I2C_PDD_SetMasterMode(I2C0_BASE_PTR, I2C_PDD_MASTER_MODE); /* If no then start signal generated */ } if ((DeviceDataPrv->SerFlag & ADDR_7) != 0x00U) { /* Is 7-bit addressing set ? */ DeviceDataPrv->SerFlag |= (ADDR_COMPLETE|REP_ADDR_COMPLETE); /* Only one byte of address will be sent 7-bit address mode*/ I2C_PDD_WriteDataReg(I2C0_BASE_PTR, (uint8_t)(DeviceDataPrv->SlaveAddr | 0x01U)); /* Send slave address */ } else { if ((DeviceDataPrv->SerFlag & ADDR_10) != 0x00U) { /* Is 10-bit addressing set ? */ DeviceDataPrv->SerFlag &= (uint8_t)~(ADDR_COMPLETE | REP_ADDR_COMPLETE); /* Second byte of address will be sent later */ I2C_PDD_WriteDataReg(I2C0_BASE_PTR, DeviceDataPrv->SlaveAddrHigh); /* Send slave address - high byte */ } } /* {Default RTOS Adapter} Critical section end, general PE function is used */ ExitCritical(); return ERR_OK; /* OK */ }
/* ** =================================================================== ** Method : AS1_RecvChar (bean AsynchroSerial) ** ** Description : ** If any data is received, this method returns one ** character, otherwise it returns an error code (it does ** not wait for data). This method is enabled only if the ** receiver property is enabled. ** [Note:] Because the preferred method to handle error and ** break exception in the interrupt mode is to use events ** <OnError> and <OnBreak> the return value ERR_RXEMPTY has ** higher priority than other error codes. As a consequence ** the information about an exception in interrupt mode is ** returned only if there is a valid character ready to be ** read. ** Parameters : ** NAME - DESCRIPTION ** * Chr - Pointer to a received character ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** ERR_RXEMPTY - No data in receiver ** ERR_BREAK - Break character is detected ** (only when the <Interrupt service> ** property is disabled and the <Break ** signal> property is enabled) ** ERR_COMMON - common error occurred (the ** <GetError> method can be used for error ** specification) ** =================================================================== */ byte AS1_RecvChar(AS1_TComData *Chr) { byte Result = ERR_OK; /* Return error code */ if(!(SerFlag & CHAR_IN_RX)) { /* Is any char in the RX buffer? */ return ERR_RXEMPTY; /* If no then error */ } EnterCritical(); /* Save the PS register */ *Chr = BufferRead; /* Received char */ Result = (byte)((SerFlag & (OVERRUN_ERR|COMMON_ERR))?ERR_COMMON:ERR_OK); SerFlag &= ~(OVERRUN_ERR|COMMON_ERR|CHAR_IN_RX); /* Clear all errors in the status variable */ ExitCritical(); /* Restore the PS register */ return Result; /* Return error code */ }
/* ===================================================================*/ LDD_TError SMasterLdd1_ReceiveBlock(LDD_TDeviceData *DeviceDataPtr, LDD_TData *BufferPtr, uint16_t Size) { if (((SMasterLdd1_TDeviceDataPtr)DeviceDataPtr)->InpDataNumReq != 0x00U) { /* Is the previous receive operation pending? */ return ERR_BUSY; /* If yes then error */ } /* {Default RTOS Adapter} Critical section begin, general PE function is used */ EnterCritical(); ((SMasterLdd1_TDeviceDataPtr)DeviceDataPtr)->InpDataPtr = (uint8_t*)BufferPtr; /* Store a pointer to the input data. */ ((SMasterLdd1_TDeviceDataPtr)DeviceDataPtr)->InpDataNumReq = Size; /* Store a number of characters to be received. */ ((SMasterLdd1_TDeviceDataPtr)DeviceDataPtr)->InpRecvDataNum = 0x00U; /* Set number of received characters to zero. */ /* {Default RTOS Adapter} Critical section end, general PE function is used */ ExitCritical(); return ERR_OK; /* OK */ }
/* ** =================================================================== ** Method : ASerial_RecvChar (component AsynchroSerial) ** Description : ** If any data is received, this method returns one character, ** otherwise it returns an error code (it does not wait for ** data). This method is enabled only if the receiver property ** is enabled. ** [Note:] Because the preferred method to handle error and ** break exception in the interrupt mode is to use events ** <OnError> and <OnBreak> the return value ERR_RXEMPTY has ** higher priority than other error codes. As a consequence the ** information about an exception in interrupt mode is returned ** only if there is a valid character ready to be read. ** Parameters : ** NAME - DESCRIPTION ** * Chr - Pointer to a received character ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** ERR_RXEMPTY - No data in receiver ** ERR_BREAK - Break character is detected ** (only when the <Interrupt service> property ** is disabled and the <Break signal> property ** is enabled) ** ERR_COMMON - common error occurred (the ** <GetError> method can be used for error ** specification) ** =================================================================== */ byte ASerial_RecvChar(ASerial_TComData *Chr) { byte Result = ERR_OK; /* Return error code */ if ((SerFlag & CHAR_IN_RX) == 0U) { /* Is any char in RX buffer? */ return ERR_RXEMPTY; /* If no then error */ } EnterCritical(); /* Disable global interrupts */ *Chr = BufferRead; /* Received char */ Result = (byte)((SerFlag & (OVERRUN_ERR|COMMON_ERR))? ERR_COMMON : ERR_OK); SerFlag &= (word)~(word)(OVERRUN_ERR|COMMON_ERR|CHAR_IN_RX); /* Clear all errors in the status variable */ ExitCritical(); /* Enable global interrupts */ return Result; /* Return error code */ }
/* ** =================================================================== ** Method : SM1_SetIdleClockPolarity (component SynchroMaster) ** Description : ** Sets the idle clock polarity at runtime. If the ** communication does not run, the clock signal will have ** required level. The method will disable communication (if ** enabled), change the idle clock polarity end re-enable the ** communication (if it was enabled before). ** Parameters : ** NAME - DESCRIPTION ** Level - Idle clock polarity: ** 0-low ** 1-high ** Returns : ** --- - Error code, possible codes: ** ERR_OK - OK ** ERR_SPEED - This device does not work in ** the active speed mode ** ERR_RANGE - Parameter out of range ** ** [ Version specific information neither for ** Freescale HC08 derivatives ] ** [ERR_DISABLED] - Obsolete, this error code ** is not used. ** ** =================================================================== */ byte SM1_SetIdleClockPolarity(byte Level) { if (Level > 1U) { return ERR_RANGE; } SpiClockfeatures = ((SpiClockfeatures & 0xFEU) | Level); EnterCritical(); /* Disable global interrupts */ (void)SMasterLdd1_Disable(SMasterLdd1_DeviceDataPtr); /* Disable device */ (void)SMasterLdd1_Enable(SMasterLdd1_DeviceDataPtr); /* Enable device and cancel receive data request */ (void)SMasterLdd1_SelectConfiguration(SMasterLdd1_DeviceDataPtr, 0x00U, SpiClockfeatures); HWEnDi(); /* Enable/Disable device */ ExitCritical(); /* Enable global interrupts */ return ERR_OK; }
/* ===================================================================*/ LDD_TError IntI2cLdd1_MasterSendBlock(LDD_TDeviceData *DeviceDataPtr, LDD_TData *BufferPtr, LDD_I2C_TSize Size, LDD_I2C_TSendStop SendStop) { IntI2cLdd1_TDeviceData *DeviceDataPrv = (IntI2cLdd1_TDeviceData *)DeviceDataPtr; if (Size == 0x00U) { /* Test variable Size on zero */ return ERR_OK; /* If zero then OK */ } if (DeviceDataPrv->SendStop == LDD_I2C_SEND_STOP) { if ((I2C_PDD_GetBusStatus(I2C0_BASE_PTR) == I2C_PDD_BUS_BUSY) || /* Is the bus busy? */ \ ((DeviceDataPrv->SerFlag & MASTER_IN_PROGRES) != 0x00U) || \ (DeviceDataPrv->OutLenM != 0x00U)) { return ERR_BUSY; /* If yes then error */ } } else { if (((DeviceDataPrv->SerFlag & MASTER_IN_PROGRES) != 0x00U) || /* Is the bus busy? */ \ (DeviceDataPrv->OutLenM != 0x00U)) { return ERR_BUSY; /* If yes then error */ } } /* {Default RTOS Adapter} Critical section begin, general PE function is used */ EnterCritical(); DeviceDataPrv->SerFlag |= MASTER_IN_PROGRES; /* Set flag "busy" */ DeviceDataPrv->OutPtrM = (uint8_t *)BufferPtr; /* Save pointer to data for transmitting */ DeviceDataPrv->OutByteMNum = 0x00U; /* Set data counter */ DeviceDataPrv->OutLenM = Size; /* Set the counter of output bufer's content */ DeviceDataPrv->SendStop = SendStop; /* Set generating stop condition */ I2C_PDD_SetTransmitMode(I2C0_BASE_PTR, I2C_PDD_TX_DIRECTION); /* Set TX mode */ if (I2C_PDD_GetMasterMode(I2C0_BASE_PTR) == I2C_PDD_MASTER_MODE) { /* Is device in master mode? */ I2C_PDD_RepeatStart(I2C0_BASE_PTR); /* If yes then repeat start cycle generated */ } else { I2C_PDD_SetMasterMode(I2C0_BASE_PTR, I2C_PDD_MASTER_MODE); /* If no then start signal generated */ } if ((DeviceDataPrv->SerFlag & ADDR_7) != 0x00U) { /* Is 7-bit addressing set ? */ DeviceDataPrv->SerFlag |= (ADDR_COMPLETE | REP_ADDR_COMPLETE); /* Only one byte of address will be sent 7-bit address mode*/ I2C_PDD_WriteDataReg(I2C0_BASE_PTR, DeviceDataPrv->SlaveAddr); /* Send slave address */ } else { if ((DeviceDataPrv->SerFlag & ADDR_10) != 0x00U) { /* Is 10-bit addressing set ? */ DeviceDataPrv->SerFlag &= (uint8_t)~(ADDR_COMPLETE | REP_ADDR_COMPLETE); /* Second byte of address will be sent later */ I2C_PDD_WriteDataReg(I2C0_BASE_PTR, DeviceDataPrv->SlaveAddrHigh); /* Send slave address - high byte */ } else { if ((DeviceDataPrv->SerFlag & GENERAL_CALL) != 0x00U) { /* Is general call command required ? */ DeviceDataPrv->SerFlag |= ADDR_COMPLETE; /* Only one byte of address will be sent in general call address mode*/ I2C_PDD_WriteDataReg(I2C0_BASE_PTR, 0x00U); /* Send general call address */ } } } /* {Default RTOS Adapter} Critical section end, general PE function is used */ ExitCritical(); return ERR_OK; /* OK */ }
int route_add(int flags, ipaddr_t net, ipaddr_t netmask, ipaddr_t dst) { route_entry_p routep; int bitcount; int i,location,ret; mk_ip_table_rw(); EnterCritical(); routep = get_route(net,netmask); if (routep) { /* route exists */ fprintf(stderr,"Route exists\n"); ret = -1; } else if (GETNUMROUTEENTRIES == ROUTETABLESZ) { /* no space left */ fprintf(stderr,"No space for new route\n"); ret = -1; } else { bitcount = get_ipaddr_bitcount(netmask); /* search for place of insertion: first entry that is smaller, and take previous */ for (i = 0 ; i < GETNUMROUTEENTRIES ; i++) { routep = GETROUTEP(i); if (bitcount >= routep->bitcount) break; } if (i == GETNUMROUTEENTRIES) { /* there were no entries, append at bottom */ location = GETNUMROUTEENTRIES; } else { location = i; /* shift down all entries, to make space */ for (i = GETNUMROUTEENTRIES; i >= location ; i--) { routep = GETROUTEP(i); *routep = *(GETROUTEP(i-1)); } } routep = GETROUTEP(location); INCNUMROUTEENTRIES; routep->flags = flags; routep->bitcount = bitcount; bcopy(net, routep->net,4); bcopy(netmask, routep->netmask,4); bcopy(dst, routep->dst,4); ret = 0; } ExitCritical(); mk_ip_table_ro(); return ret; }
void arp_print_table(void) { arp_entry_p e; if (!arp_table) kprintf("arp_table pointer is NULL\n"); EnterCritical(); printf("ARP_TABLE %p new_entry: %d envid: %d TIME: %qd\n",arp_table, arp_table->new_entry,arp_table->arp_envid,TICKS); if (arp_table == NULL) goto done; arp_iter_init(); while ((e = arp_iter())) if (!EISFREE(e)) arp_print_entry(e); done: ExitCritical(); }