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

void  ySafeTrace(const char *file,u32 line,void *ptr){    u32 i;    YMEM_ENTRY *entry;        yEnterCriticalSection(&yMapCS);    for(i=0, entry=yMap; i< yMapUsed ; i++,entry++){        YASSERT(entry->state != YMEM_NOT_USED);        if(entry->ptr == ptr)            break;    }    if(i == yMapUsed){        dbglog("Update trace of unallocated pointer 0x%x at %s:%d/n/n",ptr,file,line);        ymemdump();        YASSERT(0);    }    if(entry->state == YMEM_FREED){        dbglog("Update trace of allready freed pointer (0x%x) at %s:%d/n",ptr,file,line);        dbglog("was allocated at %s:%d size =%d freed at %s:%d/n/n",               entry->malloc_file, entry->malloc_line, entry->malloc_size, entry->free_file,entry->free_line);        ymemdump();        YASSERT(0);    }    ymemdumpentry(entry,"trace");    entry->malloc_file = file;    entry->malloc_line = line;        yLeaveCriticalSection(&yMapCS);}

//return 0 if a read is still pendingint yyyReadIdle(yInterfaceSt *iface,char *errmsg){    yEnterCriticalSection(&iface->yyyCS);    if(iface->devref==NULL){        yLeaveCriticalSection(&iface->yyyCS);        return YERR(YAPI_DEVICE_NOT_FOUND);    }    yLeaveCriticalSection(&iface->yyyCS);    return  YAPI_SUCCESS;}

void ySafeMemoryInit(u32 nbentry){    YASSERT(yMap==NULL && yMapSize==0);    yInitializeCriticalSection(&yMapCS);    yEnterCriticalSection(&yMapCS);    yMap = malloc(nbentry *sizeof(YMEM_ENTRY));    if(yMap){        yMapSize = nbentry;        memset(yMap,0,nbentry *sizeof(YMEM_ENTRY));        yMapUsed=0;    }        yLeaveCriticalSection(&yMapCS);}

/** * Changes the primary unit for measuring humidity. That unit is a string. * If that strings starts with the letter 'g', the primary measured value is the absolute * humidity, in g/m3. Otherwise, the primary measured value will be the relative humidity * (RH), in per cents. * * Remember to call the saveToFlash() method of the module if the modification * must be kept. * * @param newval : a string corresponding to the primary unit for measuring humidity * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YHumidity::set_unit(const string& newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        rest_val = newval;        res = _setAttr("unit", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

/** * Changes the PWM duty cycle at device power on. Remember to call the matching * module saveToFlash() method, otherwise this call will have no effect. * * @param newval : a floating point number corresponding to the PWM duty cycle at device power on * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YPwmOutput::set_dutyCycleAtPowerOn(double newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        char buf[32]; sprintf(buf, "%" FMTs64, (s64)floor(newval * 65536.0 + 0.5)); rest_val = string(buf);        res = _setAttr("dutyCycleAtPowerOn", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

static void Handle_IOHIDDeviceIOHIDReportCallback(                void *          inContext,          // context from IOHIDDeviceRegisterInputReportCallback                IOReturn        inResult,           // completion result for the input report operation                void *          inSender,           // IOHIDDeviceRef of the device this report is from                IOHIDReportType inType,             // the report type                uint32_t        inReportID,         // the report ID                uint8_t *       inReport,           // pointer to the report data                CFIndex         InReportLength)     // the actual size of the input report{    yInterfaceSt *iface= (yInterfaceSt*) inContext;    yEnterCriticalSection(&iface->yyyCS);    yyPushNewPkt(iface,&iface->tmprxpkt);    memset(&iface->tmprxpkt,0xff,sizeof(USB_Packet));    yLeaveCriticalSection(&iface->yyyCS);}

/** * Changes the current expected position of the quadrature decoder. * Invoking this function implicitely activates the quadrature decoder. * * @param newval : a floating point number corresponding to the current expected position of the quadrature decoder * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YQuadratureDecoder::set_currentValue(double newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        char buf[32]; sprintf(buf, "%" FMTs64, (s64)floor(newval * 65536.0 + 0.5)); rest_val = string(buf);        res = _setAttr("currentValue", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

/** * Changes the electric signal sampling method to use. * The HIGH_RATE method uses the highest sampling frequency, without any filtering. * The HIGH_RATE_FILTERED method adds a windowed 7-sample median filter. * The LOW_NOISE method uses a reduced acquisition frequency to reduce noise. * The LOW_NOISE_FILTERED method combines a reduced frequency with the median filter * to get measures as stable as possible when working on a noisy signal. * * @param newval : a value among Y_SIGNALSAMPLING_HIGH_RATE, Y_SIGNALSAMPLING_HIGH_RATE_FILTERED, * Y_SIGNALSAMPLING_LOW_NOISE, Y_SIGNALSAMPLING_LOW_NOISE_FILTERED and Y_SIGNALSAMPLING_HIGHEST_RATE * corresponding to the electric signal sampling method to use * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YGenericSensor::set_signalSampling(Y_SIGNALSAMPLING_enum newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        char buf[32]; sprintf(buf, "%d", newval); rest_val = string(buf);        res = _setAttr("signalSampling", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

/** * Preset the state of the watchdog at device startup (A for the idle position, * B for the active position, UNCHANGED for no modification). Remember to call the matching module saveToFlash() * method, otherwise this call will have no effect. * * @param newval : a value among Y_STATEATPOWERON_UNCHANGED, Y_STATEATPOWERON_A and Y_STATEATPOWERON_B * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YWatchdog::set_stateAtPowerOn(Y_STATEATPOWERON_enum newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        char buf[32]; sprintf(buf, "%d", newval); rest_val = string(buf);        res = _setAttr("stateAtPowerOn", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

/** * Changes the loop current at device start up. Remember to call the matching * module saveToFlash() method, otherwise this call has no effect. * * @param newval : a floating point number corresponding to the loop current at device start up * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YCurrentLoopOutput::set_currentAtStartUp(double newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        char buf[32]; sprintf(buf, "%" FMTs64, (s64)floor(newval * 65536.0 + 0.5)); rest_val = string(buf);        res = _setAttr("currentAtStartUp", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

/** * Changes the sensibility for the input (between 1 and 1000) for triggering user callbacks. * The sensibility is used to filter variations around a fixed value, but does not preclude the * transmission of events when the input value evolves constantly in the same direction. * Special case: when the value 1000 is used, the callback will only be thrown when the logical state * of the input switches from pressed to released and back. * Remember to call the saveToFlash() method of the module if the modification must be kept. * * @param newval : an integer corresponding to the sensibility for the input (between 1 and 1000) for * triggering user callbacks * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YAnButton::set_sensitivity(int newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        char buf[32]; sprintf(buf, "%d", newval); rest_val = string(buf);        res = _setAttr("sensitivity", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

/** * Changes the number of seconds between current time and UTC time (time zone). * The timezone is automatically rounded to the nearest multiple of 15 minutes. * * @param newval : an integer corresponding to the number of seconds between current time and UTC time (time zone) * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YRealTimeClock::set_utcOffset(int newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        char buf[32]; sprintf(buf, "%d", newval); rest_val = string(buf);        res = _setAttr("utcOffset", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

int YGps::set_command(const string& newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        rest_val = newval;        res = _setAttr("command", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

/** * Changes the number of child nodes expected in normal conditions. * If the value is zero, no check is performed. If it is non-zero, the number * child nodes is checked on startup and the status will change to error if * the count does not match. * * @param newval : an integer corresponding to the number of child nodes expected in normal conditions * * @return YAPI_SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */int YDaisyChain::set_requiredChildCount(int newval){    string rest_val;    int res;    yEnterCriticalSection(&_this_cs);    try {        char buf[32]; sprintf(buf, "%d", newval); rest_val = string(buf);        res = _setAttr("requiredChildCount", rest_val);    } catch (std::exception) {         yLeaveCriticalSection(&_this_cs);         throw;    }    yLeaveCriticalSection(&_this_cs);    return res;}

void  ySafeMemoryDump(void *discard){    u32 i;    YMEM_ENTRY *entry;    yEnterCriticalSection(&yMapCS);    for(i=0, entry=yMap; i< yMapUsed ; i++,entry++){        if(entry->state == YMEM_MALLOCED && entry->ptr!=discard){            break;        }    }    if(i< yMapUsed){        ymemdump();    }    yLeaveCriticalSection(&yMapCS);}

void *ySafeMalloc(const char *file,u32 line,u32 size){    u32 i;    YMEM_ENTRY *entry;    void *ptr;    yEnterCriticalSection(&yMapCS);    if(yMapUsed < yMapSize){        //use a new one        entry=yMap+yMapUsed;    }else{        // find a freed entry        for(i=0; i< yMapSize;i++){            if(yMap[i].state == YMEM_FREED)                break;                        }        if(i==yMapSize){            dbglog("No more entry available for ySafeMalloc/n/n");            ymemdump();            yLeaveCriticalSection(&yMapCS);            return NULL;        }        entry = yMap+i;    }    ptr=malloc(size);    if(!ptr){        dbglog("No more memory available (unable to allocate %d bytes)/n/n",size);        ymemdump();        yLeaveCriticalSection(&yMapCS);        return NULL;    }    memset(entry,0,sizeof(YMEM_ENTRY));    entry->state = YMEM_MALLOCED;    entry->malloc_file = file;    entry->malloc_line = line;    entry->ptr  = ptr;    entry->malloc_size = size;    if(yMapUsed < yMapSize)        yMapUsed++;    yLeaveCriticalSection(&yMapCS);    return ptr;    }

void yyyPacketShutdown(yInterfaceSt  *iface){        yEnterCriticalSection(&iface->yyyCS);    if(iface->devref!=NULL){        IOHIDDeviceRegisterInputReportCallback( iface->devref,              // IOHIDDeviceRef for the HID device                                            (u8*) &iface->tmprxpkt,   // pointer to the report data (uint8_t's)                                            USB_PKT_SIZE,              // number of bytes in the report (CFIndex)                                            NULL,   // the callback routine                                            iface);                      // context passed to callback        IOHIDDeviceClose(iface->devref, kIOHIDOptionsTypeNone);        iface->devref=NULL;    }    yLeaveCriticalSection(&iface->yyyCS);    yDeleteCriticalSection(&iface->yyyCS);    yyyFreePktQueue(iface);}