自学教程：C++ CYASSERT函数代码示例

/* Main loop */int main(){    CYBLE_API_RESULT_T apiResult;        CyGlobalIntEnable;    Initialization();        for(;;)    {        /* Delayed start of advertisement */        if(initCounter == 6)        {            initCounter = 7;            WDT_DisableWcoEcoCounters();                        apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_CUSTOM);            if(apiResult != CYBLE_ERROR_OK)            {                CYASSERT(0);            }        }                CyBle_ProcessEvents(); /* BLE stack processing state machine interface */                LowPower();    }}

/******************************************************************************** Function Name: Midi_UpdateBufferPointers********************************************************************************** Summary:*  This function updates the MIDI buffer pointers** Parameters:*  void** Return:*  None********************************************************************************/static void Midi_UpdateBufferPointers(void){    if(midiBuffer.midiPacket[midiBuffer.packetIndex].packetStatus == MIDI_PACKET_VALID &&        midiBuffer.midiPacket[midiBuffer.packetIndex].dataIndex >= (CYBLE_GATT_MTU - MAX_MIDI_PACKET_LENGTH + 1))    {        midiBuffer.packetIndex++;                if(midiBuffer.packetIndex == MAX_NUMBER_OF_MIDI_PACKETS)        {            midiBuffer.packetIndex = 0;        }                if(midiBuffer.midiPacket[midiBuffer.packetIndex].packetStatus == MIDI_PACKET_VALID)        {            /* The updated packet is still valid and is not sent over BLE. Flag this as an overflow condition */            CYASSERT(0);        }    }        if(midiBuffer.midiPacket[midiBuffer.packetIndex].dataIndex == 0)    {        /* Insert the header byte to the packet structure */        midiBuffer.midiPacket[midiBuffer.packetIndex].midiNotificationPacket/        [midiBuffer.midiPacket[midiBuffer.packetIndex].dataIndex++] = MIDI_PACKET_HEADER;                midiBuffer.midiPacket[midiBuffer.packetIndex].packetStatus = MIDI_PACKET_VALID;    }}

/******************************************************************************** Function Name: adc_SetOffset********************************************************************************** Summary:*   Description: Sets the ADC offset which is used by the functions*   ADC_CountsTo_uVolts, ADC_CountsTo_mVolts and ADC_CountsTo_Volts*   to substract the offset from the given reading*   before calculating the voltage conversion.** Parameters:*  chan: ADC channel number.*  offset: This value is a measured value when the*          inputs are shorted or connected to the same input voltage.** Return:*  None.** Global variables:*  adc_Offset:  Modified to set the user provided offset.********************************************************************************/void adc_SetOffset(uint32 chan, int16 offset){    /* Halt CPU in debug mode if channel is out of valid range */    CYASSERT(chan < adc_TOTAL_CHANNELS_NUM);    adc_offset[chan] = offset;}

/******************************************************************************** Function Name: ADC_SAR_Seq_0_SetOffset********************************************************************************** Summary:*   Description: Sets the ADC offset which is used by the functions*   ADC_CountsTo_uVolts, ADC_CountsTo_mVolts and ADC_CountsTo_Volts*   to substract the offset from the given reading*   before calculating the voltage conversion.** Parameters:*  chan: ADC channel number.*  offset: This value is a measured value when the*          inputs are shorted or connected to the same input voltage.** Return:*  None.** Global variables:*  ADC_SAR_Seq_0_Offset:  Modified to set the user provided offset.********************************************************************************/void ADC_SAR_Seq_0_SetOffset(uint32 chan, int16 offset){    /* Halt CPU in debug mode if channel is out of valid range */    CYASSERT(chan < ADC_SAR_Seq_0_TOTAL_CHANNELS_NUM);    ADC_SAR_Seq_0_offset[chan] = offset;}

/******************************************************************************** Function Name: TPS_ADC_SAR_SetResolution********************************************************************************** Summary:*  Sets the Relution of the SAR.** Parameters:*  resolution:*  12 ->    RES12*  10 ->    RES10*  8  ->    RES8** Return:*  None.** Side Effects:*  The ADC resolution cannot be changed during a conversion cycle. The*  recommended best practice is to stop conversions with*  ADC_StopConvert(), change the resolution, then restart the*  conversions with ADC_StartConvert().*  If you decide not to stop conversions before calling this API, you*  should use ADC_IsEndConversion() to wait until conversion is complete*  before changing the resolution.*  If you call ADC_SetResolution() during a conversion, the resolution will*  not be changed until the current conversion is complete. Data will not be*  available in the new resolution for another 6 + "New Resolution(in bits)"*  clock cycles.*  You may need add a delay of this number of clock cycles after*  ADC_SetResolution() is called before data is valid again.*  Affects ADC_CountsTo_Volts(), ADC_CountsTo_mVolts(), and*  ADC_CountsTo_uVolts() by calculating the correct conversion between ADC*  counts and the applied input voltage. Calculation depends on resolution,*  input range, and voltage reference.********************************************************************************/void TPS_ADC_SAR_SetResolution(uint8 resolution){    uint8 tmpReg;    /* Set SAR ADC resolution and sample width: 18 conversion cycles at 12bits + 1 gap */    switch (resolution)    {        case (uint8)TPS_ADC_SAR__BITS_12:            tmpReg = TPS_ADC_SAR_SAR_RESOLUTION_12BIT | TPS_ADC_SAR_SAR_SAMPLE_WIDTH;            break;        case (uint8)TPS_ADC_SAR__BITS_10:            tmpReg = TPS_ADC_SAR_SAR_RESOLUTION_10BIT | TPS_ADC_SAR_SAR_SAMPLE_WIDTH;            break;        case (uint8)TPS_ADC_SAR__BITS_8:            tmpReg = TPS_ADC_SAR_SAR_RESOLUTION_8BIT | TPS_ADC_SAR_SAR_SAMPLE_WIDTH;            break;        default:            tmpReg = TPS_ADC_SAR_SAR_RESOLUTION_12BIT | TPS_ADC_SAR_SAR_SAMPLE_WIDTH;            /* Halt CPU in debug mode if resolution is out of valid range */            CYASSERT(0u != 0u);            break;    }    TPS_ADC_SAR_SAR_CSR2_REG = tmpReg;     /* Calculate gain for convert counts to volts */    TPS_ADC_SAR_CalcGain(resolution);}

/******************************************************************************** Function Name: ADC_SAR_Seq_0_SetGain********************************************************************************** Summary:*  Description: Sets the ADC gain in counts per 10 volt for the voltage*  conversion functions below. This value is set by default by the*  reference and input range settings. It should only be used to further*  calibrate the ADC with a known input or if an external reference is*  used. Affects the ADC_CountsTo_uVolts, ADC_CountsTo_mVolts*  and ADC_CountsTo_Volts functions by supplying the correct*  conversion between ADC counts and voltage.** Parameters:*  chan: ADC channel number.*  adcGain: ADC gain in counts per 10 volts.** Return:*  None.** Global variables:*  ADC_SAR_Seq_0_CountsPer10Volt:  modified to set the ADC gain in counts *   per 10 volt.********************************************************************************/void ADC_SAR_Seq_0_SetGain(uint32 chan, int32 adcGain){    /* Halt CPU in debug mode if channel is out of valid range */    CYASSERT(chan < ADC_SAR_Seq_0_TOTAL_CHANNELS_NUM);    ADC_SAR_Seq_0_countsPer10Volt[chan] = adcGain;}

/******************************************************************************** Function Name: BLE_StackEventHandler********************************************************************************** Summary:*   BLE stack generic event handler routine for handling connection, discovery, *   security etc. events.** Parameters:  *  event - event that triggered this callback*  eventParam - parameters for the event.** Return: *  None*******************************************************************************/void BLE_StackEventHandler(uint32 event, void* eventParam){    CYBLE_API_RESULT_T apiResult;        (void) eventParam;        switch(event)    {        case CYBLE_EVT_GAP_DEVICE_DISCONNECTED:                    break;                case CYBLE_EVT_STACK_ON:            /* Put the device into discoverable mode so that remote can search it. */            apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);                        if(apiResult != CYBLE_ERROR_OK)            {                CYASSERT(0);                }        break;                    /* ADD YOUR CODE TO HANDLE OTHER GENERIC BLE STACK EVENTS */                    /* All the BLE stack events can be found in BLE_Stack.h (see CYBLE_EVENT_T enum) and  BLE_eventHandler.h (see         * CYBLE_EVT_T enum ) */                        default:                break;    }}

/******************************************************************************** Function Name: TPS_ADC_SAR_CalcGain********************************************************************************** Summary:*  This function calculates the ADC gain in counts per 10 volt.** Parameters:*  uint8: resolution** Return:*  None.** Global Variables:*  TPS_ADC_SAR_shift variable initialized. This variable is used to*  convert the ADC counts to the 2s compliment form.*  TPS_ADC_SAR_countsPer10Volt variable initialized. This variable is used*  for gain calibration purpose.********************************************************************************/static void TPS_ADC_SAR_CalcGain( uint8 resolution ){    int32 counts;    #if(!((TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSS_TO_VREF) || /         (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDDA) || /         (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDAC)) )        uint16 diff_zero;    #endif /* End TPS_ADC_SAR_DEFAULT_RANGE */    switch (resolution)    {        case (uint8)TPS_ADC_SAR__BITS_12:            counts = (int32)TPS_ADC_SAR_SAR_WRK_MAX_12BIT;            #if(!((TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSS_TO_VREF) || /                 (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDDA) || /                 (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDAC)) )                diff_zero = TPS_ADC_SAR_SAR_DIFF_SHIFT;            #endif /* End TPS_ADC_SAR_DEFAULT_RANGE */            break;        case (uint8)TPS_ADC_SAR__BITS_10:            counts = (int32)TPS_ADC_SAR_SAR_WRK_MAX_10BIT;            #if(!((TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSS_TO_VREF) || /                 (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDDA) || /                 (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDAC)) )                diff_zero = TPS_ADC_SAR_SAR_DIFF_SHIFT >> 2u;            #endif /* End TPS_ADC_SAR_DEFAULT_RANGE */            break;        case (uint8)TPS_ADC_SAR__BITS_8:            counts = (int32)TPS_ADC_SAR_SAR_WRK_MAX_8BIT;            #if(!((TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSS_TO_VREF) || /                 (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDDA) || /                 (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDAC)) )                diff_zero = TPS_ADC_SAR_SAR_DIFF_SHIFT >> 4u;            #endif /* End TPS_ADC_SAR_DEFAULT_RANGE */            break;        default: /* Halt CPU in debug mode if resolution is out of valid range */            counts = 0;            #if(!((TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSS_TO_VREF) || /                 (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDDA) || /                 (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDAC)) )                diff_zero = 0u;            #endif /* End TPS_ADC_SAR_DEFAULT_RANGE */            CYASSERT(0u != 0u);            break;    }    TPS_ADC_SAR_countsPerVolt = 0; /* Clear obsolete variable */    /* Calculate gain in counts per 10 volts with rounding */    TPS_ADC_SAR_countsPer10Volt = (((counts * TPS_ADC_SAR_10MV_COUNTS) +                        TPS_ADC_SAR_DEFAULT_REF_VOLTAGE_MV) / (TPS_ADC_SAR_DEFAULT_REF_VOLTAGE_MV * 2));    #if( (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSS_TO_VREF) || /         (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDDA) || /         (TPS_ADC_SAR_DEFAULT_RANGE == TPS_ADC_SAR__VSSA_TO_VDAC) )        TPS_ADC_SAR_shift = 0;    #else        TPS_ADC_SAR_shift = diff_zero;    #endif /* End TPS_ADC_SAR_DEFAULT_RANGE */}

/******************************************************************************** Function Name: WaveDAC8_1_BuffAmp_SetPower********************************************************************************** Summary:*  Sets power level of Analog buffer.** Parameters: *  power: PSoC3: Sets power level between low (1) and high power (3).*         PSoC5: Sets power level High (0)** Return:*  void***********************************************************************************/void WaveDAC8_1_BuffAmp_SetPower(uint8 power) {    #if (CY_PSOC3 || CY_PSOC5LP)        WaveDAC8_1_BuffAmp_CR_REG &= (uint8)(~WaveDAC8_1_BuffAmp_PWR_MASK);        WaveDAC8_1_BuffAmp_CR_REG |= power & WaveDAC8_1_BuffAmp_PWR_MASK;      /* Set device power */    #else        CYASSERT(WaveDAC8_1_BuffAmp_HIGHPOWER == power);    #endif /* CY_PSOC3 || CY_PSOC5LP */}

/******************************************************************************** Function Name: Opamp_L_SetPower********************************************************************************** Summary:*  Sets power level of Analog buffer.** Parameters: *  power: PSoC3: Sets power level between low (1) and high power (3).*         PSoC5: Sets power level High (0)** Return:*  void***********************************************************************************/void Opamp_L_SetPower(uint8 power) {    #if (CY_PSOC3 || CY_PSOC5LP)        Opamp_L_CR_REG &= (uint8)(~Opamp_L_PWR_MASK);        Opamp_L_CR_REG |= power & Opamp_L_PWR_MASK;      /* Set device power */    #else        CYASSERT(Opamp_L_HIGHPOWER == power);    #endif /* CY_PSOC3 || CY_PSOC5LP */}

int main() {    CYBLE_API_RESULT_T apiResult;    uint32 count = 0;    uint8   triggerNotification = 0;    // Enable global interrupts    CyGlobalIntEnable;        // Initialize the watchdog timer    CySysWdtSetIsrCallback(CY_SYS_WDT_COUNTER0, Watchdog0_cb);    // Initialize the BLE device.    apiResult = CyBle_Start(StackEventHandler);    // Validate BLE stack initialization successed    CYASSERT(apiResult == CYBLE_ERROR_OK);    for (;;) {        // Service all the BLE stack events.        // Must be called at least once in a BLE connection interval        CyBle_ProcessEvents();        if (deviceConnected) {            if (counterCccDescriptor.dirty) {                // Update Counter CCCD                updateCounterCccDescriptor();            } else if (triggerNotification) {                // Send notification if required                if (enableCounterNotification) {                    sendCounterNotification(count);                }                triggerNotification = 0;            } else if (triggerUpdateCounter) {                // Update counter value                count++;                updateCounter(count);                triggerNotification = ((count & 0x0000000F) == 0);                triggerUpdateCounter = 0;            }        }                // Scan update queue        if (rgbDescriptor.dirty) {            // Update RGB Descriptor            updateRgbDescriptor();        }        // Enter to deep sleep mode        {            CYBLE_LP_MODE_T state;            state = CyBle_EnterLPM(CYBLE_BLESS_DEEPSLEEP);            if (state == CYBLE_BLESS_DEEPSLEEP) {                CySysPmDeepSleep();            }        }    }}

/******************************************************************************** Function Name: ADC_SAR_1_CalcGain********************************************************************************** Summary:*  This function calculates the ADC gain in counts per volt.** Parameters:*  uint8: resolution** Return:*  None.** Global Variables:*  ADC_SAR_1_shift variable initialized. This variable is used to*  convert the ADC counts to the 2's compliment form.*  ADC_SAR_1_countsPerVolt variable initialized. This variable is used*  for gain calibration purpose.********************************************************************************/static void ADC_SAR_1_CalcGain( uint8 resolution ){    int32 counts;    #if(!((ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSS_TO_VREF) || /         (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDDA) || /         (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDAC)) )        uint16 diff_zero;    #endif /* End ADC_SAR_1_DEFAULT_RANGE */    switch (resolution)    {        case (uint8)ADC_SAR_1__BITS_12:            counts = (int32)ADC_SAR_1_SAR_WRK_MAX;            #if(!((ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSS_TO_VREF) || /                 (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDDA) || /                 (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDAC)) )                diff_zero = ADC_SAR_1_SAR_DIFF_SHIFT;            #endif /* End ADC_SAR_1_DEFAULT_RANGE */            break;        case (uint8)ADC_SAR_1__BITS_10:            counts = (int32)(ADC_SAR_1_SAR_WRK_MAX >> 2u);            #if(!((ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSS_TO_VREF) || /                 (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDDA) || /                 (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDAC)) )                diff_zero = ADC_SAR_1_SAR_DIFF_SHIFT >> 2u;            #endif /* End ADC_SAR_1_DEFAULT_RANGE */            break;        case (uint8)ADC_SAR_1__BITS_8:            counts = (int32)(ADC_SAR_1_SAR_WRK_MAX >> 4u);            #if(!((ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSS_TO_VREF) || /                 (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDDA) || /                 (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDAC)) )                diff_zero = ADC_SAR_1_SAR_DIFF_SHIFT >> 4u;            #endif /* End ADC_SAR_1_DEFAULT_RANGE */            break;        default: /* Halt CPU in debug mode if resolution is out of valid range */            counts = 0;            #if(!((ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSS_TO_VREF) || /                 (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDDA) || /                 (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDAC)) )                diff_zero = 0u;            #endif /* End ADC_SAR_1_DEFAULT_RANGE */            CYASSERT(0u != 0u);            break;    }    counts *= 1000; /* To avoid float point arithmetic*/    ADC_SAR_1_countsPerVolt = (int16)(counts / ADC_SAR_1_DEFAULT_REF_VOLTAGE_MV / 2);    #if( (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSS_TO_VREF) || /         (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDDA) || /         (ADC_SAR_1_DEFAULT_RANGE == ADC_SAR_1__VSSA_TO_VDAC) )        ADC_SAR_1_shift = 0;    #else        ADC_SAR_1_shift = diff_zero;    #endif /* End ADC_SAR_1_DEFAULT_RANGE */}

 /******************************************************************************* * Function Name: USBUART_1_PutData ******************************************************************************** * * Summary: *  This function sends a specified number of bytes from the location specified *  by a pointer to the PC. The USBUART_1_CDCIsReady() function should be *  called before sending new data, to be sure that the previous data has *  finished sending. *  If the last sent packet is less than maximum packet size the USB transfer *  of this short packet will identify the end of the segment. If the last sent *  packet is exactly maximum packet size, it shall be followed by a zero-length *  packet (which is a short packet) to assure the end of segment is properly *  identified. To send zero-length packet, use USBUART_1_PutData() API *  with length parameter set to zero. * * Parameters: *  pData: pointer to the buffer containing data to be sent. *  length: Specifies the number of bytes to send from the pData *  buffer. Maximum length will be limited by the maximum packet *  size for the endpoint. Data will be lost if length is greater than Max *  Packet Size. * * Return: *  None. * * Global variables: *   USBUART_1_cdc_data_in_ep: CDC IN endpoint number used for sending *     data. * * Reentrant: *  No. * *******************************************************************************/ void USBUART_1_PutData(const uint8* pData, uint16 length)  {     /* Limits length to maximum packet size for the EP */     if(length > USBUART_1_EP[USBUART_1_cdc_data_in_ep].bufferSize)     {         /* Caution: Data will be lost if length is greater than Max Packet Length */         length = USBUART_1_EP[USBUART_1_cdc_data_in_ep].bufferSize;          /* Halt CPU in debug mode */         CYASSERT(0u != 0u);     }     USBUART_1_LoadInEP(USBUART_1_cdc_data_in_ep, pData, length); }

/******************************************************************************** Function Name: hallTickCounter_WriteCounter********************************************************************************* Summary:*   This funtion is used to set the counter to a specific value** Parameters:  *  counter:  New counter value. ** Return: *  void ********************************************************************************/void hallTickCounter_WriteCounter(uint8 counter) /                                   {    #if(hallTickCounter_UsingFixedFunction)        /* assert if block is already enabled */        CYASSERT (0u == (hallTickCounter_GLOBAL_ENABLE & hallTickCounter_BLOCK_EN_MASK));        /* If block is disabled, enable it and then write the counter */        hallTickCounter_GLOBAL_ENABLE |= hallTickCounter_BLOCK_EN_MASK;        CY_SET_REG16(hallTickCounter_COUNTER_LSB_PTR, (uint16)counter);        hallTickCounter_GLOBAL_ENABLE &= ((uint8)(~hallTickCounter_BLOCK_EN_MASK));    #else        CY_SET_REG8(hallTickCounter_COUNTER_LSB_PTR, counter);    #endif /* (hallTickCounter_UsingFixedFunction) */}

/******************************************************************************** Function Name: QuadDecoder_Cnt16_WriteCounter********************************************************************************* Summary:*   This funtion is used to set the counter to a specific value** Parameters:  *  counter:  New counter value. ** Return: *  void ********************************************************************************/void QuadDecoder_Cnt16_WriteCounter(uint16 counter) /                                   {    #if(QuadDecoder_Cnt16_UsingFixedFunction)        /* assert if block is already enabled */        CYASSERT (0u == (QuadDecoder_Cnt16_GLOBAL_ENABLE & QuadDecoder_Cnt16_BLOCK_EN_MASK));        /* If block is disabled, enable it and then write the counter */        QuadDecoder_Cnt16_GLOBAL_ENABLE |= QuadDecoder_Cnt16_BLOCK_EN_MASK;        CY_SET_REG16(QuadDecoder_Cnt16_COUNTER_LSB_PTR, (uint16)counter);        QuadDecoder_Cnt16_GLOBAL_ENABLE &= ((uint8)(~QuadDecoder_Cnt16_BLOCK_EN_MASK));    #else        CY_SET_REG16(QuadDecoder_Cnt16_COUNTER_LSB_PTR, counter);    #endif /* (QuadDecoder_Cnt16_UsingFixedFunction) */}

/******************************************************************************** Function Name: Counter_1_WriteCounter********************************************************************************* Summary:*   This funtion is used to set the counter to a specific value** Parameters:  *  counter:  New counter value. ** Return: *  void ********************************************************************************/void Counter_1_WriteCounter(uint16 counter) /                                   {    #if(Counter_1_UsingFixedFunction)        /* assert if block is already enabled */        CYASSERT (0u == (Counter_1_GLOBAL_ENABLE & Counter_1_BLOCK_EN_MASK));        /* If block is disabled, enable it and then write the counter */        Counter_1_GLOBAL_ENABLE |= Counter_1_BLOCK_EN_MASK;        CY_SET_REG16(Counter_1_COUNTER_LSB_PTR, (uint16)counter);        Counter_1_GLOBAL_ENABLE &= ((uint8)(~Counter_1_BLOCK_EN_MASK));    #else        CY_SET_REG16(Counter_1_COUNTER_LSB_PTR, counter);    #endif /* (Counter_1_UsingFixedFunction) */}

/******************************************************************************** Function Name: Phase_Counter_WriteCounter********************************************************************************* Summary:*   This funtion is used to set the counter to a specific value** Parameters:  *  counter:  New counter value. ** Return: *  void ********************************************************************************/void Phase_Counter_WriteCounter(uint32 counter) /                                   {    #if(Phase_Counter_UsingFixedFunction)        /* assert if block is already enabled */        CYASSERT (0u == (Phase_Counter_GLOBAL_ENABLE & Phase_Counter_BLOCK_EN_MASK));        /* If block is disabled, enable it and then write the counter */        Phase_Counter_GLOBAL_ENABLE |= Phase_Counter_BLOCK_EN_MASK;        CY_SET_REG16(Phase_Counter_COUNTER_LSB_PTR, (uint16)counter);        Phase_Counter_GLOBAL_ENABLE &= ((uint8)(~Phase_Counter_BLOCK_EN_MASK));    #else        CY_SET_REG32(Phase_Counter_COUNTER_LSB_PTR, counter);    #endif /* (Phase_Counter_UsingFixedFunction) */}

/******************************************************************************** Function Name: BLE_AppEventHandler********************************************************************************** Summary:*   BLE stack generic event handler routine for handling connection, discovery, *   security etc. events.** Parameters:  *  event - event that triggered this callback*  eventParam - parameters for the event.** Return: *  None*******************************************************************************/void BLE_AppEventHandler(uint32 event, void* eventParam){    CYBLE_API_RESULT_T apiResult;        (void)eventParam;    switch (event)	{        /**********************************************************        *                       General Events        ***********************************************************/		case CYBLE_EVT_STACK_ON: /* This event is received when component is Started */            /* Enter in to discoverable mode so that remote can search it. */            apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);                        if(apiResult != CYBLE_ERROR_OK)            {                CYASSERT(0);            }        break;                    case CYBLE_EVT_GAPP_ADVERTISEMENT_START_STOP:            if(CyBle_GetState() == CYBLE_STATE_DISCONNECTED)            {                /* On advertisement timeout, restart advertisement */                apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);                if(apiResult != CYBLE_ERROR_OK)                {                    CYASSERT(0);                }            }        break;            		default:        break;	}}

/******************************************************************************** Function Name: CyFlash_SetWaitCycles********************************************************************************** Summary:*  Sets the number of clock cycles the cache will wait before it samples data*  coming back from the Flash. This function must be called before increasing*  the CPU clock frequency. It can optionally be called after lowering the CPU*  clock frequency in order to improve the CPU performance.** Parameters:*  uint8 freq:*   Frequency of operation in Megahertz.** Return:*  None********************************************************************************/void CyFlash_SetWaitCycles(uint8 freq) {    uint8 interruptState;    /* Save current global interrupt enable and disable it */    interruptState = CyEnterCriticalSection();    /***************************************************************************    * The number of clock cycles the cache will wait before it samples data    * coming back from the Flash must be equal or greater to to the CPU frequency    * outlined in clock cycles.    ***************************************************************************/    if (freq < CY_FLASH_CACHE_WS_1_FREQ_MAX)    {        CY_FLASH_CONTROL_REG = (CY_FLASH_CONTROL_REG & (uint8)(~CY_FLASH_CACHE_WS_VALUE_MASK)) |                                    CY_FLASH_CACHE_WS_1_VALUE_MASK;    }    else if (freq < CY_FLASH_CACHE_WS_2_FREQ_MAX)    {        CY_FLASH_CONTROL_REG = (CY_FLASH_CONTROL_REG & (uint8)(~CY_FLASH_CACHE_WS_VALUE_MASK)) |                                    CY_FLASH_CACHE_WS_2_VALUE_MASK;    }    else if (freq < CY_FLASH_CACHE_WS_3_FREQ_MAX)    {        CY_FLASH_CONTROL_REG = (CY_FLASH_CONTROL_REG & (uint8)(~CY_FLASH_CACHE_WS_VALUE_MASK)) |                                    CY_FLASH_CACHE_WS_3_VALUE_MASK;    }#if (CY_PSOC5)    else if (freq < CY_FLASH_CACHE_WS_4_FREQ_MAX)    {        CY_FLASH_CONTROL_REG = (CY_FLASH_CONTROL_REG & (uint8)(~CY_FLASH_CACHE_WS_VALUE_MASK)) |                                    CY_FLASH_CACHE_WS_4_VALUE_MASK;    }    else if (freq <= CY_FLASH_CACHE_WS_5_FREQ_MAX)    {        CY_FLASH_CONTROL_REG = (CY_FLASH_CONTROL_REG & (uint8)(~CY_FLASH_CACHE_WS_VALUE_MASK)) |                                    CY_FLASH_CACHE_WS_5_VALUE_MASK;    }#endif  /* (CY_PSOC5) */    else    {        /* Halt CPU in debug mode if frequency is invalid */        CYASSERT(0u != 0u);    }    /* Restore global interrupt enable state */    CyExitCriticalSection(interruptState);}

/******************************************************************************** Function Name: BLE_Engine_Start********************************************************************************** Summary:*  Application level API for starting the BLE interface. The API internally calls*  other BLE interface init APIs to setup the system.** Parameters:  *  None** Return: *  None********************************************************************************/CYBLE_API_RESULT_T BLE_Engine_Start(void){    CYBLE_API_RESULT_T apiResult;        apiResult = CyBle_Start(BLE_StackEventHandler);        if(apiResult != CYBLE_ERROR_OK)    {        CYASSERT(0);        }        /* ADD YOUR CODE TO REGISTER OTHER BLE SERVICE SPECIFIC EVENT HANDLERS */       return apiResult;}

/******************************************************************************** Function Name: USBUART_PutData****************************************************************************//****  This function sends a specified number of bytes from the location specified*  by a pointer to the PC. The USBUART_CDCIsReady() function should be*  called before sending new data, to be sure that the previous data has*  finished sending.*  If the last sent packet is less than maximum packet size the USB transfer*  of this short packet will identify the end of the segment. If the last sent*  packet is exactly maximum packet size, it shall be followed by a zero-length*  packet (which is a short packet) to assure the end of segment is properly*  identified. To send zero-length packet, use USBUART_PutData() API*  with length parameter set to zero.**  /param pData: pointer to the buffer containing data to be sent.*  /param length: Specifies the number of bytes to send from the pData*  buffer. Maximum length will be limited by the maximum packet*  size for the endpoint. Data will be lost if length is greater than Max*  Packet Size.** /globalvars**   USBUART_cdcDataInEp: CDC IN endpoint number used for sending*     data.** /reentrant*  No.********************************************************************************/void USBUART_PutData(const uint8* pData, uint16 length) {    uint8 epNumber = USBUART_cdcDataInEp[USBUART_activeCom];    /* Limit length to maximum packet size for endpoint. */    if (length > USBUART_EP[epNumber].bufferSize)    {        /* Caution: Data will be lost if length is greater than Max Packet Size. */        length = USBUART_EP[epNumber].bufferSize;        /* Halt CPU in debug mode */        CYASSERT(0u != 0u);    }    USBUART_LoadInEP(epNumber, pData, length);}

/******************************************************************************** Function Name: ADC_SAR_1_SetResolution********************************************************************************** Summary:*  Sets the Relution of the SAR.*  This function does not affect the actual conversion with PSoC5 ES1 silicon.** Parameters:*  resolution:*  12 ->    RES12*  10 ->    RES10*  8  ->    RES8** Return:*  None.** Side Effects:*  The ADC resolution cannot be changed during a conversion cycle. The*  recommended best practice is to stop conversions with*  ADC_StopConvert(), change the resolution, then restart the*  conversions with ADC_StartConvert().*  If you decide not to stop conversions before calling this API, you*  should use ADC_IsEndConversion() to wait until conversion is complete*  before changing the resolution.*  If you call ADC_SetResolution() during a conversion, the resolution will*  not be changed until the current conversion is complete. Data will not be*  available in the new resolution for another 6 + "New Resolution(in bits)"*  clock cycles.*  You may need add a delay of this number of clock cycles after*  ADC_SetResolution() is called before data is valid again.*  Affects ADC_CountsTo_Volts(), ADC_CountsTo_mVolts(), and*  ADC_CountsTo_uVolts() by calculating the correct conversion between ADC*  counts and the applied input voltage. Calculation depends on resolution,*  input range, and voltage reference.********************************************************************************/void ADC_SAR_1_SetResolution(uint8 resolution){    uint8 tmpReg;    /* remember resolution for the GetResult APIs */    #if(CY_PSOC5A)        ADC_SAR_1_resolution = resolution;    #endif /* End CY_PSOC5A */    /* Set SAR ADC resolution and sample width: 18 conversion cycles at 12bits + 1 gap */    switch (resolution)    {        case (uint8)ADC_SAR_1__BITS_12:            tmpReg = ADC_SAR_1_SAR_RESOLUTION_12BIT | ADC_SAR_1_SAR_SAMPLE_WIDTH;            break;        case (uint8)ADC_SAR_1__BITS_10:            /* Use 12bits for PSoC5 production silicon and shift the            *  results for lower resolution in GetResult16() API            */            #if(CY_PSOC5A)                tmpReg = ADC_SAR_1_SAR_RESOLUTION_12BIT | ADC_SAR_1_SAR_SAMPLE_WIDTH;            #else                tmpReg = ADC_SAR_1_SAR_RESOLUTION_10BIT | ADC_SAR_1_SAR_SAMPLE_WIDTH;            #endif /* End CY_PSOC5A */            break;        case (uint8)ADC_SAR_1__BITS_8:            #if(CY_PSOC5A)                tmpReg = ADC_SAR_1_SAR_RESOLUTION_12BIT | ADC_SAR_1_SAR_SAMPLE_WIDTH;            #else                tmpReg = ADC_SAR_1_SAR_RESOLUTION_8BIT | ADC_SAR_1_SAR_SAMPLE_WIDTH;            #endif /* End CY_PSOC5A */            break;        default:            tmpReg = ADC_SAR_1_SAR_RESOLUTION_12BIT | ADC_SAR_1_SAR_SAMPLE_WIDTH;            /* Halt CPU in debug mode if resolution is out of valid range */            CYASSERT(0u != 0u);            break;    }    ADC_SAR_1_SAR_CSR2_REG = tmpReg;     /* Calculate gain for convert counts to volts */    ADC_SAR_1_CalcGain(resolution);}

/******************************************************************************** Function Name: main********************************************************************************** Summary:*  Main function.** Parameters:*  None** Return:*  None********************************************************************************/int main(){    CYBLE_API_RESULT_T apiResult;    CYBLE_STATE_T bleState;    CyGlobalIntEnable;	    PWM_Start();	UART_Start();	UART_UartPutString("Welcome to BLE OOB Pairing Demo/r/n");    apiResult = CyBle_Start(StackEventHandler);    if(apiResult != CYBLE_ERROR_OK)    {        /* BLE stack initialization failed, check your configuration */        CYASSERT(0);    }    CyBle_IasRegisterAttrCallback(IasEventHandler);    for(;;)    {        /* Single API call to service all the BLE stack events. Must be         * called at least once in a BLE connection interval */        CyBle_ProcessEvents();        bleState = CyBle_GetState();        if(bleState != CYBLE_STATE_STOPPED &&            bleState != CYBLE_STATE_INITIALIZING)        {            /* Configure BLESS in DeepSleep mode  */            CyBle_EnterLPM(CYBLE_BLESS_DEEPSLEEP);            /* Configure PSoC 4 BLE system in sleep mode */            CySysPmSleep();            /* BLE link layer timing interrupt will wake up the system */        }    }}

/******************************************************************************** Function Name: InitializeSystem********************************************************************************** Summary:*  This routine initializes all the componnets and firmware state.** Parameters:*  None** Return:*  None********************************************************************************/void InitializeSystem(void){    CYBLE_API_RESULT_T apiResult;    CyGlobalIntEnable;    apiResult = CyBle_Start(StackEventHandler); /* Init the BLE stack and register an applicaiton callback */    if(apiResult != CYBLE_ERROR_OK)    {        /* BLE stack initialization failed, check your configuration */        CYASSERT(0);    }    /* Set XTAL divider to 3MHz mode */    CySysClkWriteEcoDiv(CY_SYS_CLK_ECO_DIV8);    /* ILO is no longer required, shut it down */    CySysClkIloStop();}

    /*******************************************************************************    * Function Name: ADC_SAR_Seq_0_CountsTo_Volts    ********************************************************************************    *    * Summary:    *  Converts the ADC output to Volts as a floating point number.    *  This function is not available when left data format justification selected.    *    * Parameters:    *  chan: The ADC channel number.    *  Result from the ADC conversion    *    * Return:    *  Results in Volts    *    * Global variables:    *  ADC_SAR_Seq_0_countsPer10Volt:  used to convert ADC counts to Volts.    *  ADC_SAR_Seq_0_Offset:  Used as the offset while converting ADC counts     *   to mVolts.    *    *******************************************************************************/    float32 ADC_SAR_Seq_0_CountsTo_Volts(uint32 chan, int16 adcCounts)    {        float32 volts;        /* Halt CPU in debug mode if channel is out of valid range */        CYASSERT(chan < ADC_SAR_Seq_0_TOTAL_CHANNELS_NUM);        /* Divide the adcCount when accumulate averaging mode selected */        #if(ADC_SAR_Seq_0_DEFAULT_AVG_MODE == ADC_SAR_Seq_0__ACCUMULATE)            if((ADC_SAR_Seq_0_channelsConfig[chan] & ADC_SAR_Seq_0_AVERAGING_EN) != 0u)            {                adcCounts /= ADC_SAR_Seq_0_DEFAULT_AVG_SAMPLES_DIV;            }            #endif /* ADC_SAR_Seq_0_DEFAULT_AVG_MODE == ADC_SAR_Seq_0__ACCUMULATE */        /* Subtract ADC offset */        adcCounts -= ADC_SAR_Seq_0_offset[chan];        volts = ((float32)adcCounts * ADC_SAR_Seq_0_10V_COUNTS) / (float32)ADC_SAR_Seq_0_countsPer10Volt[chan];        return( volts );    }

/******************************************************************************** Function Name: ADC_SAR_Seq_0_GetResult16********************************************************************************** Summary:*  Gets the data available in the SAR DATA register.** Parameters:*  chan: The ADC channel in which to return the result. The first channel*  is 0 and the injection channel if enabled is the number of valid channels.** Return:*  Returns converted data as a signed 16-bit integer********************************************************************************/int16 ADC_SAR_Seq_0_GetResult16(uint32 chan){    uint32 result;    /* Halt CPU in debug mode if channel is out of valid range */    CYASSERT(chan < ADC_SAR_Seq_0_TOTAL_CHANNELS_NUM);    if(chan < ADC_SAR_Seq_0_SEQUENCED_CHANNELS_NUM)    {        result = CY_GET_REG32((reg32 *)(ADC_SAR_Seq_0_SAR_CHAN_RESULT_IND + (uint32)(chan << 2u))) &                ADC_SAR_Seq_0_RESULT_MASK;    }    else    {        #if(ADC_SAR_Seq_0_INJ_CHANNEL_ENABLED)            result = ADC_SAR_Seq_0_SAR_INJ_RESULT_REG & ADC_SAR_Seq_0_RESULT_MASK;        #else            result = 0u;        #endif /* ADC_SAR_Seq_0_INJ_CHANNEL_ENABLED */    }    return ( (int16)result );}