/** Connect this plugin to an NDArray port driver; disconnect from any existing driver first, register * for callbacks if enabled. */ asynStatus NDPluginGather::connectToArrayPort(void) { asynStatus status; asynInterface *pasynInterface; int enableCallbacks; char arrayPort[20]; int arrayAddr; int i; NDGatherNDArraySource_t *pArraySrc = NDArraySrc_; static const char *functionName = "connectToArrayPort"; getIntegerParam(NDPluginDriverEnableCallbacks, &enableCallbacks); for (i=0; i<maxPorts_; i++, pArraySrc++) { getStringParam(i, NDPluginDriverArrayPort, sizeof(arrayPort), arrayPort); getIntegerParam(i, NDPluginDriverArrayAddr, &arrayAddr); /* If we are currently connected to an array port cancel interrupt request */ if (pArraySrc->connectedToArrayPort) { status = setArrayInterrupt(0); } /* Disconnect the array port from our asynUser. Ignore error if there is no device * currently connected. */ pasynManager->disconnect(pArraySrc->pasynUserGenericPointer); pArraySrc->connectedToArrayPort = false; /* Connect to the array port driver if the arrayPort string is not zero-length */ if (strlen(arrayPort) == 0) continue; status = pasynManager->connectDevice(pArraySrc->pasynUserGenericPointer, arrayPort, arrayAddr); if (status != asynSuccess) { asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s::%s Error calling pasynManager->connectDevice to array port %s address %d, status=%d, error=%s\n", driverName, functionName, arrayPort, arrayAddr, status, pArraySrc->pasynUserGenericPointer->errorMessage); return (status); } /* Find the asynGenericPointer interface in that driver */ pasynInterface = pasynManager->findInterface(pArraySrc->pasynUserGenericPointer, asynGenericPointerType, 1); if (!pasynInterface) { asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s::connectToPort ERROR: Can't find asynGenericPointer interface on array port %s address %d\n", driverName, arrayPort, arrayAddr); return(asynError); } pArraySrc->pasynGenericPointer = (asynGenericPointer *)pasynInterface->pinterface; pArraySrc->asynGenericPointerPvt = pasynInterface->drvPvt; pArraySrc->connectedToArrayPort = true; } /* Enable or disable interrupt callbacks */ status = setArrayInterrupt(enableCallbacks); return(status); }
BObjectImp* StorageExecutorModule::mf_FindStorageArea() { const String* str = getStringParam(0); if ( str != NULL ) { StorageArea *area = storage.find_area(str->value()); if ( area ) return new BApplicPtr(&storage_area_type, area); } return new BLong(0); // non-string passed, or not found. }
void mar345::getImageData() { char fullFileName[MAX_FILENAME_LEN]; size_t dims[2]; int itemp; int imageCounter; NDArray *pImage; char statusMessage[MAX_MESSAGE_SIZE]; char errorBuffer[MAX_MESSAGE_SIZE]; FILE *input; const char *functionName = "getImageData"; /* Inquire about the image dimensions */ getStringParam(NDFullFileName, MAX_FILENAME_LEN, fullFileName); getIntegerParam(NDArraySizeX, &itemp); dims[0] = itemp; getIntegerParam(NDArraySizeY, &itemp); dims[1] = itemp; getIntegerParam(NDArrayCounter, &imageCounter); pImage = this->pNDArrayPool->alloc(2, dims, NDUInt16, 0, NULL); epicsSnprintf(statusMessage, sizeof(statusMessage), "Reading mar345 file %s", fullFileName); setStringParam(ADStatusMessage, statusMessage); callParamCallbacks(); input = fopen(fullFileName, "rb"); if (input == NULL) { (void) strerror_r(errno, errorBuffer, sizeof(errorBuffer)); asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s%s: unable to open input file %s, error=%s\n", driverName, functionName, fullFileName, errorBuffer); return; } get_pck(input, (epicsInt16 *)pImage->pData); fclose(input); /* Put the frame number and time stamp into the buffer */ pImage->uniqueId = imageCounter; pImage->timeStamp = this->acqStartTime.secPastEpoch + this->acqStartTime.nsec / 1.e9; /* Get any attributes that have been defined for this driver */ this->getAttributes(pImage->pAttributeList); /* Call the NDArray callback */ /* Must release the lock here, or we can get into a deadlock, because we can * block on the plugin lock, and the plugin can be calling us */ this->unlock(); asynPrint(this->pasynUserSelf, ASYN_TRACE_FLOW, "%s:%s: calling NDArray callback\n", driverName, functionName); doCallbacksGenericPointer(pImage, NDArrayData, 0); this->lock(); /* Free the image buffer */ pImage->release(); }
BObjectImp* PolSystemExecutorModule::mf_GetPackageByName() { const String* pkgname; if ( !getStringParam(0, pkgname) ) return new BError("Invalid parameter type."); //pkgname->toLower(); Package* pkg = find_package(pkgname->value()); if ( !pkg ) return new BError("No package found by that name."); else return new PackageObjImp(PackagePtrHolder(pkg)); }
int FastCCD::uploadFirmware(void){ int _status = 0; char path[256]; getStringParam(FastCCDFirmwarePath, sizeof(path), path); setIntegerParam(FastCCDFirmwareUpload, 1); // Power off the cin setStringParam(ADStatusMessage, "Powering CIN OFF"); callParamCallbacks(); if(cin_ctl_pwr(&cin_ctl_port, 0)){ goto error; } sleep(5); getCameraStatus(); // Power on the cin setStringParam(ADStatusMessage, "Powering CIN ON"); callParamCallbacks(); if(cin_ctl_pwr(&cin_ctl_port, 1)){ goto error; } sleep(5); getCameraStatus(); setStringParam(ADStatusMessage, "Uploading Firmware to CIN"); callParamCallbacks(); _status |= cin_ctl_load_firmware(&cin_ctl_port, &cin_ctl_port_stream, path); if(!_status){ _status |= cin_ctl_set_fabric_address(&cin_ctl_port, (char *)cinFabricIP); _status |= cin_data_send_magic(); } setIntegerParam(FastCCDFirmwareUpload, 0); error: if(_status){ setStringParam(ADStatusMessage, "ERROR Uploading Firmware"); } else { setStringParam(ADStatusMessage, "Firmware uploaded to CIN"); } return _status; }
/** Base method for opening a file * Creates the file name with NDPluginBase::createFileName, then calls the pure virtual function openFile * in the derived class. */ asynStatus NDPluginFile::openFileBase(NDFileOpenMode_t openMode, NDArray *pArray) { /* Opens a file for reading or writing */ asynStatus status = asynSuccess; char fullFileName[MAX_FILENAME_LEN]; char tempSuffix[MAX_FILENAME_LEN]; char errorMessage[256]; static const char* functionName = "openFileBase"; if (this->useAttrFilePrefix) this->attrFileNameSet(); setIntegerParam(NDFileWriteStatus, NDFileWriteOK); setStringParam(NDFileWriteMessage, ""); status = (asynStatus)createFileName(MAX_FILENAME_LEN, fullFileName); if (status) { asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s::%s error creating full file name, fullFileName=%s, status=%d\n", driverName, functionName, fullFileName, status); setIntegerParam(NDFileWriteStatus, NDFileWriteError); setStringParam(NDFileWriteMessage, "Error creating full file name"); return(status); } setStringParam(NDFullFileName, fullFileName); getStringParam(NDFileTempSuffix, sizeof(tempSuffix), tempSuffix); if ( *tempSuffix != 0 && (strlen(fullFileName) + strlen(tempSuffix)) < sizeof(fullFileName) ) { strcat( fullFileName, tempSuffix ); } /* Call the openFile method in the derived class */ /* Do this with the main lock released since it is slow */ this->unlock(); epicsMutexLock(this->fileMutexId); this->registerInitFrameInfo(pArray); status = this->openFile(fullFileName, openMode, pArray); if (status) { epicsSnprintf(errorMessage, sizeof(errorMessage)-1, "Error opening file %s, status=%d", fullFileName, status); asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s::%s %s\n", driverName, functionName, errorMessage); setIntegerParam(NDFileWriteStatus, NDFileWriteError); setStringParam(NDFileWriteMessage, errorMessage); } epicsMutexUnlock(this->fileMutexId); this->lock(); return(status); }
void ReadASCII::readFilePoll(void) { //Thread to poll the file used in the PID lookup and update the array of values when the file is modified char localDir[DIR_LENGTH], dirBase[DIR_LENGTH]; asynStatus status; while (1) { //wait for a file change epicsThreadSleep(2.0); if (true == fileBad) continue; lock(); //get directory in this thread getStringParam(P_DirBase, DIR_LENGTH, dirBase); getStringParam(P_Dir, DIR_LENGTH, localDir); //release lock unlock(); strcat(dirBase, "/"); strcat(dirBase, localDir); if (false == isModified(dirBase)) { continue; } lock(); status = readFile(dirBase); unlock(); } }
/** Called when asyn clients call pasynOctet->write(). * This function performs actions for some parameters, including AttributesFile. * For all parameters it sets the value in the parameter library and calls any registered callbacks.. * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Address of the string to write. * \param[in] nChars Number of characters to write. * \param[out] nActual Number of characters actually written. */ asynStatus NDPosPlugin::writeOctet(asynUser *pasynUser, const char *value, size_t nChars, size_t *nActual) { int addr=0; int function = pasynUser->reason; asynStatus status = asynSuccess; char *fileName = new char[MAX_POS_STRING_LEN]; fileName[MAX_POS_STRING_LEN - 1] = '\0'; const char *functionName = "writeOctet"; status = getAddress(pasynUser, &addr); if (status != asynSuccess) return(status); // Set the parameter in the parameter library. status = (asynStatus)setStringParam(addr, function, (char *)value); if (status != asynSuccess) return(status); if (function == NDPos_Filename){ // Read the filename parameter getStringParam(NDPos_Filename, MAX_POS_STRING_LEN-1, fileName); // Now validate the XML NDPosPluginFileReader fr; if (fr.validateXML(fileName) == asynSuccess){ setIntegerParam(NDPos_FileValid, 1); } else { setIntegerParam(NDPos_FileValid, 0); status = asynError; } // If the status of validation is OK then load the file if (status == asynSuccess){ // Call the loadFile function status = loadFile(); } } else if (function < FIRST_NDPOS_PARAM){ // If this parameter belongs to a base class call its method status = NDPluginDriver::writeOctet(pasynUser, value, nChars, nActual); } // Do callbacks so higher layers see any changes callParamCallbacks(addr, addr); if (status){ epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, value=%s", driverName, functionName, status, function, value); } else { asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, value=%s\n", driverName, functionName, function, value); } *nActual = nChars; return status; }
/** Checks whether the directory specified NDFilePath parameter exists. * * This is a convenience function that determines the directory specified NDFilePath parameter exists. * It sets the value of NDFilePathExists to 0 (does not exist) or 1 (exists). * It also adds a trailing '/' character to the path if one is not present. * Returns a error status if the directory does not exist. */ asynStatus asynNDArrayDriver::checkPath() { asynStatus status; std::string filePath; int pathExists; getStringParam(NDFilePath, filePath); if (filePath.size() == 0) return asynSuccess; pathExists = checkPath(filePath); status = pathExists ? asynSuccess : asynError; setStringParam(NDFilePath, filePath); setIntegerParam(NDFilePathExists, pathExists); return status; }
/** Check whether the attributes defining the filename has changed since last write. * If this is the first frame (NDFileNumCaptured == 1) then the file is opened. * For other frames we check whether the attribute file name or number has changed * since last write. If this is the case then the current file is closed a new one opened. */ asynStatus NDPluginFile::attrFileNameCheck() { asynStatus status = asynSuccess; NDAttribute *NDattrFileName, *NDattrFileNumber; int compare, attrFileNumber, ndFileNumber; char attrFileName[MAX_FILENAME_LEN]; char ndFileName[MAX_FILENAME_LEN]; int numCapture, numCaptured; bool reopenFile = false; if (!this->useAttrFilePrefix) return status; getIntegerParam(NDFileNumCapture, &numCapture); getIntegerParam(NDFileNumCaptured, &numCaptured); if (numCaptured == 1) { status = this->openFileBase(NDFileModeWrite | NDFileModeMultiple, this->pArrays[0]); return status; } NDattrFileName = this->pArrays[0]->pAttributeList->find(FILEPLUGIN_NAME); if (NDattrFileName != NULL) { NDattrFileName->getValue(NDAttrString, attrFileName, MAX_FILENAME_LEN); getStringParam(NDFileName, MAX_FILENAME_LEN, ndFileName); compare = epicsStrnCaseCmp(attrFileName, ndFileName, strlen(attrFileName)); if (compare != 0) reopenFile = true; } NDattrFileNumber = this->pArrays[0]->pAttributeList->find(FILEPLUGIN_NUMBER); if (NDattrFileNumber != NULL) { NDattrFileNumber->getValue(NDAttrInt32, (void*) &attrFileNumber, 0); getIntegerParam(NDFileNumber, &ndFileNumber); if (ndFileNumber != attrFileNumber) { reopenFile = true; setIntegerParam( NDFileNumber, attrFileNumber); } } asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "attrFileNameCheck: name=%s(%s) num=%d (%s) reopen=%d\n", attrFileName, ndFileName, attrFileNumber, NDattrFileNumber->getSource(), (int)reopenFile ); if (reopenFile) { this->closeFileBase(); setIntegerParam(NDFileNumCaptured, 1); status = this->openFileBase(NDFileModeWrite | NDFileModeMultiple, this->pArrays[0]); } return status; }
/* default constructor */ GStreamerFilter::GStreamerFilter ( MediaSet &mediaSet, std::shared_ptr<MediaPipeline> parent, const std::map<std::string, KmsMediaParam> ¶ms) : Filter (mediaSet, parent, g_KmsMediaGStreamerFilterType_constants.TYPE_NAME, params) { std::string commandLine, command, rest_token; GstElement *gstreamerFilter; getStringParam (commandLine, params, g_KmsMediaGStreamerFilterType_constants.CONSTRUCTOR_PARAM_GSTREAMER_COMMAND); command = commandLine.substr (0, commandLine.find (' ') ); GST_DEBUG ("Command %s", command.c_str() ); element = gst_element_factory_make ("filterelement", NULL); g_object_set (element, "filter-factory", command.c_str(), NULL); g_object_ref (element); gst_bin_add (GST_BIN (parent->pipeline), element); gst_element_sync_state_with_parent (element); g_object_get (G_OBJECT (element), "filter", &gstreamerFilter, NULL); if (gstreamerFilter == NULL) { KmsMediaServerException except; createKmsMediaServerException (except, g_KmsMediaErrorCodes_constants.MEDIA_OBJECT_TYPE_NOT_FOUND, "Media Object type not found"); throw except; } this->filter = gstreamerFilter; g_object_unref (gstreamerFilter); rest_token = commandLine.substr (command.length(), commandLine.length() - 1); if (rest_token.front() == ' ') { rest_token = rest_token.substr (rest_token.find_first_not_of (" "), rest_token.length() - 1); } if (rest_token.length() != 0) { setCommandProperties (rest_token); } }
void NDFileNexus::loadTemplateFile() { bool loadStatus; int addr = 0; char fullFilename[2*MAX_FILENAME_LEN] = ""; char template_path[MAX_FILENAME_LEN] = ""; char template_file[MAX_FILENAME_LEN] = ""; static const char *functionName = "loadTemplateFile"; /* get the filename to be used for nexus template */ getStringParam(addr, NDFileNexusTemplatePath, sizeof(template_path), template_path); getStringParam(addr, NDFileNexusTemplateFile, sizeof(template_file), template_file); sprintf(fullFilename, "%s%s", template_path, template_file); if (strlen(fullFilename) == 0) return; /* Load the Nexus template file */ loadStatus = this->configDoc.LoadFile(fullFilename); if (loadStatus != true ){ asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s:%s: Parameter file %s is invalid\n", driverName, functionName, fullFilename); setIntegerParam(addr, NDFileNexusTemplateValid, 0); callParamCallbacks(addr, addr); return; } else { asynPrint(this->pasynUserSelf, ASYN_TRACE_FLOW, "%s:%s: Parameter file %s was successfully loaded\n", driverName, functionName, fullFilename); setIntegerParam(addr, NDFileNexusTemplateValid, 1); callParamCallbacks(addr, addr); } this->rootNode = this->configDoc.RootElement(); }
BObjectImp* FileAccessExecutorModule::mf_AppendToFile() { const String* filename; ObjArray* contents; if (!getStringParam( 0, filename ) || !getObjArrayParam( 1, contents )) { return new BError( "Invalid parameter type" ); } const Package* outpkg; string path; if (!pkgdef_split( filename->value(), exec.prog()->pkg, &outpkg, &path )) return new BError( "Error in filename descriptor" ); if (path.find( ".." ) != string::npos) return new BError( "No parent path traversal please." ); if (!HasAppendAccess( exec.prog()->pkg, outpkg, path )) return new BError( "Access denied" ); string filepath; if (outpkg == NULL) filepath = path; else filepath = outpkg->dir() + path; ofstream ofs( filepath.c_str(), ios::out|ios::app ); if (!ofs.is_open()) return new BError( "Unable to open file: " + filepath ); for( unsigned i = 0; i < contents->ref_arr.size(); ++i ) { BObjectRef& ref = contents->ref_arr[i]; BObject* obj = ref.get(); if (obj != NULL) { ofs << (*obj)->getStringRep(); } ofs << endl; } if (ofs.fail()) return new BError( "Error during write." ); return new BLong(1); }
BObjectImp* PolSystemExecutorModule::mf_DeleteRealm(/*name*/) { const String* realm_name; if ( !(getStringParam(0, realm_name))) return new BError("Invalid parameter"); Realm* realm = find_realm(realm_name->value()); if ( !realm ) return new BError("Realm not found."); if ( !realm->is_shadowrealm ) return new BError("Realm is not a ShadowRealm."); if ( realm->mobile_count > 0 ) return new BError("Mobiles in Realm."); if ( realm->toplevel_item_count > 0 ) return new BError("Items in Realm."); remove_realm(realm_name->value()); return new BLong(1); }
/** Checks whether the directory specified NDFilePath parameter exists. * * This is a convenience function that determinesthe directory specified NDFilePath parameter exists. * It sets the value of NDFilePathExists to 0 (does not exist) or 1 (exists). * It also adds a trailing '/' character to the path if one is not present. * Returns a error status if the directory does not exist. */ asynStatus asynNDArrayDriver::checkPath() { /* Formats a complete file name from the components defined in NDStdDriverParams */ asynStatus status = asynError; char filePath[MAX_FILENAME_LEN]; char lastChar; int hasTerminator=0; struct stat buff; int istat; size_t len; int isDir=0; int pathExists=0; getStringParam(NDFilePath, sizeof(filePath), filePath); len = strlen(filePath); if (len == 0) return(asynSuccess); /* If the path contains a trailing '/' or '\' remove it, because Windows won't find * the directory if it has that trailing character */ lastChar = filePath[len-1]; #ifdef _WIN32 if ((lastChar == '/') || (lastChar == '\\')) #else if (lastChar == '/') #endif { filePath[len-1] = 0; len--; hasTerminator=1; } istat = stat(filePath, &buff); if (!istat) isDir = (S_IFDIR & buff.st_mode); if (!istat && isDir) { pathExists = 1; status = asynSuccess; } /* If the path did not have a trailing terminator then add it if there is room */ if (!hasTerminator) { if (len < MAX_FILENAME_LEN-2) strcat(filePath, delim); setStringParam(NDFilePath, filePath); } setIntegerParam(NDFilePathExists, pathExists); return status; }
BObjectImp* FileAccessExecutorModule::mf_FileExists() { const String* filename; if ( !getStringParam(0, filename) ) return new BError("Invalid parameter type."); const Package* outpkg; string path; if ( !pkgdef_split(filename->value(), exec.prog()->pkg, &outpkg, &path) ) return new BError("Error in filename descriptor."); if ( path.find("..") != string::npos ) return new BError("No parent path traversal allowed."); string filepath; if ( outpkg == NULL ) filepath = path; else filepath = outpkg->dir() + path; return new BLong(FileExists(filepath)); }
asynStatus NDFileFITS::WriteKeys(fitsfile *fitsFilePtr, int* fitsStatus) { *fitsStatus = 0; std::ifstream fHeader; char filePath[MAX_PATH] = {0}; *fitsStatus = getStringParam(NDFITSFileHeaderFullPathname, sizeof(filePath), filePath); if (*fitsStatus) return asynSuccess; fHeader.open(filePath, std::ios_base::in); if(fHeader.fail()) return asynSuccess; // If the file does not exists there is nothing to add char lineBuf[256], keyword[FLEN_KEYWORD], value[FLEN_VALUE], comment[FLEN_COMMENT]; char *pToken; char *context = NULL; while (fHeader.getline(lineBuf, sizeof(lineBuf), '\n')) { if (strstr(lineBuf, "//")) continue;// It is a comment pToken= strtok_s(lineBuf, "\n\t ", &context); if (!pToken) continue;// It is an empty line strncpy_s(keyword, sizeof(keyword), pToken, _TRUNCATE); pToken= strtok_s(0, "\n\t ", &context); if (!pToken) continue;// No value specified.. skip entire line strncpy_s(value, sizeof(value), pToken, _TRUNCATE); pToken= strtok_s(0, "\n", &context); if (pToken) strncpy_s(comment, sizeof(comment), pToken, _TRUNCATE); else strncpy_s(comment, sizeof(comment), "", _TRUNCATE); fits_update_key(fitsFilePtr, CFITSIO_TSTRING, keyword, value, comment, fitsStatus); } fits_close_file(fitsFilePtr, fitsStatus); // close the fits file fHeader.close(); if(*fitsStatus) return asynError; return asynSuccess; }
bool DvornikovDifferentiator::initFilter(const ParameterMap& params, const StreamInfo& in) { // get order int order = 0; string orderStr = getStringParam("DDOrder",params); if (orderStr[orderStr.size()-1]=='s') { double dur = strtod(orderStr.substr(0,orderStr.size()-1).c_str(),NULL); dur /= 2; order = (int) floor(dur*in.sampleRate/in.sampleStep); order = 2 * order + 1; } else { order = atoi(orderStr.c_str()); if (order%2) { cerr << "ERROR: DDOrder parameter must be odd in " << getIdentifier() << " component !" << endl; return false; } } // build filter m_length = order; m_filter = new double[order]; for (int i=0;i<order;i++) m_filter[i] = 0; int halfOrder = (order - 1) / 2; m_delay = halfOrder; for (int m=1;m<=halfOrder;m++) { double r1 = 1; for (int k=1;k<=halfOrder;k++) if (k!=m) r1 *= 1 - pow2((double)m/k); r1 = 1 / (2*r1*m); m_filter[halfOrder-m] = -r1; m_filter[halfOrder+m] = r1; } return true; }
int FastCCD::uploadConfig(int status, int path){ int _status = 0; char _path[256]; getStringParam(path, sizeof(_path), _path); setIntegerParam(status, 1); setStringParam(ADStatusMessage, "Uploading Config File"); callParamCallbacks(); _status = cin_ctl_load_config(&cin_ctl_port, _path); setIntegerParam(status, 0); if(!_status){ setStringParam(ADStatusMessage, "Config Uploaded to CIN"); setParamStatus(path, asynSuccess); } else { setStringParam(ADStatusMessage, "ERROR Uploading Config to CIN"); setParamStatus(path, asynError); } return _status; }
BObjectImp* FileAccessExecutorModule::mf_CreateDirectory() { const String* dirname; if (!getStringParam( 0, dirname )) return new BError( "Invalid parameter type" ); const Package* outpkg; string path; if (!pkgdef_split( dirname->value(), exec.prog()->pkg, &outpkg, &path )) return new BError( "Error in dirname descriptor" ); if (path.find( ".." ) != string::npos) return new BError( "No parent path traversal please." ); if (outpkg != NULL) path = outpkg->dir() + path; path = normalized_dir_form(path); if ( IsDirectory( path.c_str() ) ) return new BError( "Directory already exists." ); int res = make_dir(path.c_str()); if (res != 0) return new BError( "Could not create directory." ); return new BLong(1); }
BObjectImp* UOExecutorModule::mf_MoveObjectToLocation(/*object, x, y, z, realm, flags*/) { UObject* obj; unsigned short x, y; short z; long flags; const String* realm_name; // Initialize variables if ( !(getUObjectParam( exec, 0, obj) && getParam(1, x) && getParam(2, y) && getParam(3, z, WORLD_MIN_Z, WORLD_MAX_Z) && getStringParam(4, realm_name) && getParam(5, flags)) ) { return new BError("Invalid parameter"); } Realm* realm = find_realm(realm_name->value()); if( !realm ) return new BError("Realm not found."); else if( !realm->valid(x, y, z) ) return new BError("Invalid coordinates for realm."); if ( obj->script_isa(POLCLASS_MOBILE) ) return internal_MoveCharacter(static_cast<Character*>(obj), x, y, z, flags, realm); else if ( obj->script_isa(POLCLASS_BOAT) ) return internal_MoveBoat(static_cast<UBoat*>(obj), x, y, z, flags, realm); else if ( obj->script_isa(POLCLASS_MULTI) ) return new BError("Can't move multis at this time."); else if ( obj->script_isa(POLCLASS_CONTAINER) ) return internal_MoveContainer(static_cast<UContainer*>(obj), x, y, z, flags, realm); else if ( obj->script_isa(POLCLASS_ITEM) ) return internal_MoveItem(static_cast<Item*>(obj), x ,y ,z , flags, realm); else return new BError("Can't handle that object type."); }
BObjectImp* FileAccessExecutorModule::mf_OpenBinaryFile() { const String* filename; unsigned short mode,bigendian; if ((!getStringParam( 0, filename )) || (!getParam(1,mode)) || (!getParam(2,bigendian))) return new BError( "Invalid parameter type" ); const Package* outpkg; string path; if (!pkgdef_split( filename->value(), exec.prog()->pkg, &outpkg, &path )) return new BError( "Error in filename descriptor" ); if (path.find( ".." ) != string::npos) return new BError( "No parent path traversal please." ); if (mode & 0x01) { if (!HasReadAccess( exec.prog()->pkg, outpkg, path )) return new BError( "Access denied" ); } if (mode & 0x02) { if (!HasWriteAccess( exec.prog()->pkg, outpkg, path )) return new BError( "Access denied" ); } string filepath; if (outpkg == NULL) filepath = path; else filepath = outpkg->dir() + path; return new BBinaryfile( filepath, mode, bigendian==1?true:false ); }
int main(int argc, char *argv[]) { char line[80]; char *xs, *ys, *zs, *fvis; int i, j, k; int x_dim, y_dim, z_dim; double fvi; double _box_x, _box_y, _box_z; char *outfile_name = "outfile.tif"; int sampleperpixel = 4; char *image; instream = stdin; setCommandLineParameters(argc, argv); if (getFlagParam("-usage")) { printf("usage: fvi2tif -box lll mmm nnn \n"); printf(" -o [outfile.tif] \n"); printf(" < file.fvi\n"); exit(0); } getStringParam("-o", &outfile_name); printf("using %s outfile...\n", outfile_name); getVectorParam("-box", &_box_x, &_box_y, &_box_z); x_dim = floor(_box_x); y_dim = floor(_box_y); z_dim = floor(_box_z); // else if (!strcmp(argv[i], "-o")) outfile_name = argv[++i]; // else if (!strcmp(argv[i], "-box")) { // x_dim = atoi(argv[++i]); // y_dim = atoi(argv[++i]); // z_dim = atoi(argv[++i]); // printf("xyz = %d\t%d\t%d\n", x_dim, y_dim, z_dim ); // } // } image = (char*)malloc(x_dim * y_dim * z_dim * sampleperpixel); for (k=0; k<z_dim; k++) for (j=0; j<y_dim; j++) for (i=0; i<x_dim; i++) { fgets(line, 80, instream); if (feof(instream)) break; xs = strtok(line, "\t"); ys = strtok(NULL, "\t"); zs = strtok(NULL, "\t"); fvis = strtok(NULL, "\n"); fvi = strtod(fvis, NULL); int voxel = sampleperpixel * (i + j*x_dim + k*x_dim*y_dim); char fvid = (char)floor(fvi*256); image[0 + voxel] = 0; // RED image[1 + voxel] = fvid; // GREEN image[2 + voxel] = 0; // BLUE // image[3 + voxel] = 255; image[3 + voxel] = 0; // ALPHA } makeTIFF(outfile_name, x_dim, y_dim, z_dim, image, sampleperpixel); }
/** Called when asyn clients call pasynOctet->write(). * Catch parameter changes. If the user changes the path or name of the template file * load the new template file. * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Address of the string to write. * \param[in] nChars Number of characters to write. * \param[out] nActual Number of characters actually written. */ asynStatus NDFileHDF5XML::writeOctet(asynUser *pasynUser, const char *value, size_t nChars, size_t *nActual) { int addr = 0; int function = pasynUser->reason; asynStatus status = asynSuccess; const char *functionName = "writeOctet"; char pathstr[512]; status = getAddress(pasynUser, &addr); if (status != asynSuccess) return (status); /* Set the parameter in the parameter library. */ status = (asynStatus) setStringParam(addr, function, (char *) value); char mesx[256]; char *mesx2; getParamName(function, (const char**)&mesx2); sprintf(longmsg,"NDFileHDF5XML::writeOctet, param=%s, value=%s",mesx2,value); lf.log(longmsg); if (function == NDFilePath) { int is_makedirs; int statx; getStringParam(NDFilePath, sizeof(pathstr), pathstr); getIntegerParam(NDFileHDF5XML_createDirs,&is_makedirs); statx = recursePath(pathstr, (bool)is_makedirs); printf("HDF5 Recurse path: statis = %d\n",statx); if (statx==0) setIntegerParam(NDFilePathExists, 1); else setIntegerParam(NDFilePathExists, 0); } if (function == NDFileHDF5XML_templatepath) { loadTemplateFile(); } if (function == NDFileHDF5XML_templatefile) { loadTemplateFile(); } else { /* If this parameter belongs to a base class call its method */ status = NDPluginFile::writeOctet(pasynUser, value, nChars, nActual); } /* Do callbacks so higher layers see any changes */ status = (asynStatus) callParamCallbacks(addr, addr); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, value=%s", driverName, functionName, status, function, value); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, value=%s\n", driverName, functionName, function, value); *nActual = nChars; return status; }
void NDFileHDF5XML::loadTemplateFile(void) { bool loadStatus = false; int status = asynSuccess; int addr = 0; static const char *functionName = "loadTemplateFile"; lf.log("NDFileHDF5XML::loadTemplateFile"); /* if (lockConfigFile() ==asynSuccess){ /* get the filename to be used for nexus template */ status = getStringParam(addr, NDFileHDF5XML_templatepath, sizeof(template_path), template_path); status = getStringParam(addr, NDFileHDF5XML_templatefile, sizeof(template_file), template_file); delete (configDoc); configDoc = new TiXmlDocument(); if ( strstr(template_file, "<?xml") == NULL) { sprintf(template_fullname, "%s%s", template_path, template_file); if (strlen(template_fullname) == 0) return; /* Load the HDF template file */ //!! lock(); loadStatus = configDoc->LoadFile(template_fullname); lf.log("Load template from file"); //!! unlock(); } else { //printf("Template contents:\n%s\n", template_file); //!! lock(); configDoc->Parse(template_file, 0, TIXML_ENCODING_UTF8); lf.log("Parse xml in the pv"); //!! unlock(); if (configDoc->Error()){ loadStatus = false; lf.log("parsing error in xml"); } else { loadStatus = true; lf.log("parsed xml correctly"); } } if (loadStatus != true) { lf.log("Cound not load xml"); asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s:%s: Parameter file %s is invalid\n", driverName, functionName, template_fullname); asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s:%s: XML parsing message on (row, col) (%d,%d)\n%s\n", driverName, functionName, configDoc->ErrorRow(), configDoc->ErrorCol(), configDoc->ErrorDesc()); setIntegerParam(addr, NDFileHDF5XML_TemplateValid, 0); callParamCallbacks(addr, addr); asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "xml not found- use default\n"); loadStatus = configDoc->Parse(default_xml); return; } else { lf.log("loaded xml"); asynPrint(this->pasynUserSelf, ASYN_TRACE_FLOW, "%s:%s: Parameter file %s was successfully loaded\n", driverName, functionName, template_fullname); setIntegerParam(addr, NDFileHDF5XML_TemplateValid, 1); callParamCallbacks(addr, addr); } /* unlockConfigFile(); } else { asynPrint(this->pasynUserSelf, ASYN_TRACE_FLOW, "%s:%s: Parameter file %s is locked. Cannot load a new file now.\n", driverName, functionName, template_fullname); setIntegerParam(addr, NDFileHDF5XML_TemplateValid, 0); callParamCallbacks(addr, addr); } */ }
/** This is called to open a TIFF file. */ asynStatus NDFileHDF5XML::openFile(const char *fileName, NDFileOpenMode_t openMode, NDArray *pArray) { char str0[256]; char str1[256]; int fn0, fn1; int is_update; static const char *functionName = "openFile"; /* if (lockConfigFile() != asynSuccess) { return asynError; } */ //enable retrig capture strat capture_trig = 1; lf.log("NDFileHDF5XML::openFile"); this->openModesave = openMode; /* We don't support reading yet */ if (openMode & NDFileModeRead) return (asynError); /* We don't support opening an existing file for appending yet */ if (openMode & NDFileModeAppend) return (asynError); /* Set the next record in the file to 0 */ //num_bad_fpgaheads=0; this->nextRecord = 0; #if 0 getStringParam(NDFileName,255,str0); getStringParam(NDFilePath,255,str1); getIntegerParam(NDFileNumber,&fn0); getIntegerParam(NDFileNumCapture,&fn1); // this is a kludge because base class uincs the NDFileNumber for us. we are negating that so // we can keep track ourselves here. getIntegerParam(NDAutoIncrement,&is_update); if (is_update==1 && filenum_kludge==0) { fn0=fn0-1; setIntegerParam(NDFileNumber,fn0); } // keep track of filenumber so if base class messes it up we are not consused... // last_filenumber = fn0; if (openMode&NDFileModeMultiple) { sprintf(hdf_fullname,"%s%s_%05d_%05d.hdf",str1,str0,fn0,fn1); } else { sprintf(hdf_fullname,"%s%s_%05d.hdf",str1,str0,fn0); } #endif strcpy(hdf_fullname, fileName); loadTemplateFile(); hdf_interface->pArray = pArray; hdfSetup->setFileName(hdf_fullname); hdfSetup->setLeaveOpen(true); //!! lock(); if (!configDoc->Accept(hdfSetup)){ return (asynError); is_file_open = false; } else{ is_file_open = true; } //!!unlock(); hdf5Writer->setFileName(hdf_fullname); hdf5Writer->setLeaveOpen(true); hdf5Writer->setHDFFilePtr(hdfSetup->getHDFFilePtr()); hdf5Writer->setHDFAccess(hdf_append); hdf5Closer->setFileName(hdf_fullname); hdf5Closer->setLeaveOpen(false); hdf5Closer->setHDFFilePtr(hdfSetup->getHDFFilePtr()); hdf5Closer->setHDFAccess(hdf_append); setStringParam(NDFullFileName, hdf_fullname); return (asynSuccess); }
asynStatus FileList::updateList() { char dirBase[INPUT_WAVEFORM_LIM]; char search[INPUT_WAVEFORM_LIM]; int caseSense; std::list<std::string> files; int status = asynSuccess; std::string out; lock(); //get all files in directory status |= getStringParam(P_DirBase, INPUT_WAVEFORM_LIM, dirBase); if (getFileList(dirBase, files) == -1) { std::cerr << "Directory not found: " << dirBase << std::endl; unlock(); return asynError; } //search files status |= getStringParam(P_Search, INPUT_WAVEFORM_LIM, search); status |= getIntegerParam(P_CaseSensitive, &caseSense); if (caseSense == 0) { status |= filterList(files, std::string("(?i)").append(search)); } else { status |= filterList(files, search); } if (m_fullPath) { std::string dir_prefix = std::string(dirBase) + "/"; std::replace(dir_prefix.begin(), dir_prefix.end(), '\\', '/'); for(std::list<std::string>::iterator it = files.begin(); it != files.end(); ++it) { it->insert(0, dir_prefix); } } //add appropriate files to PV std::string tOut = json_list_to_array(files); status |= compressString(tOut, out); if (out.size() < OUT_CHAR_LIM) std::copy(out.begin(), out.end(), pJSONOut_); else std::cerr << "File list too long: " << out.size() << std::endl; status |= setStringParam(P_JSONOutArr, pJSONOut_); /* Do callbacks so higher layers see any changes */ status |= (asynStatus)callParamCallbacks(); unlock(); return (asynStatus)status; }
int Component::getIntParam(const std::string& id, const ParameterMap& params) { return atoi(getStringParam(id, params).c_str()); }
double Component::getDoubleParam(const std::string& id, const ParameterMap& params) { return atof(getStringParam(id, params).c_str()); }
template<size_t NoOfPZD> bool CLeyboldSimPortDriver::process(asynUser* IOUser, USSPacket<NoOfPZD> const& USSReadPacket, USSPacket<NoOfPZD>& USSWritePacket, size_t TableIndex) { if ((TableIndex < 0) || (TableIndex >= m_RunRecord.size())) throw CException(IOUser, asynError, __FUNCTION__, "User / pump not configured"); RunStates RunState = static_cast<RunStates>(getIntegerParam(TableIndex, RUNNING)); // Means the running state is in effect or has been requested. bool Running = ((RunState == On) || (RunState == Accel)); // control bit 10 = 1 bool RemoteActivated = ((USSReadPacket.m_USSPacketStruct.m_PZD[0] & (1 << 10)) != 0); if (RemoteActivated) { // Running state change can be requested both ways! Running = (USSReadPacket.m_USSPacketStruct.m_PZD[0] & (1 << 0)); // 0 to 1 transition = Error reset Is only run provided if: // the cause for the error has been removed // and control bit 0 = 0 and control bit 10 = 1 if ((USSReadPacket.m_USSPacketStruct.m_PZD[0] & (1 << 7)) && (RunState==Off)) { // Clear the fault condition. setIntegerParam(TableIndex, FAULT, 0); } } { epicsGuard < epicsMutex > guard ( CLeyboldSimPortDriver::m_Mutex ); if ((Running) && (m_RunRecord[TableIndex].m_RunState != On)) { // The running state has just been enabled. if (m_RunRecord[TableIndex].m_RunState == Off) { setIntegerParam(TableIndex, RUNNING, Accel); setDoubleParam(TableIndex, MOTORCURRENT, 15.2); m_RunRecord[TableIndex].m_RunState = Accel; m_RunRecord[TableIndex].m_TimeStamp = getTickCount(); } else { // Accel. // It is intended that the (simulated) pump speed ramps up to full speed in Duration static const unsigned Duration = 2000; unsigned ElapsedTime = getTickCount() - m_RunRecord[TableIndex].m_TimeStamp; setIntegerParam(TableIndex, STATORFREQUENCY, (ElapsedTime * NormalStatorFrequency) / Duration); if (ElapsedTime >= Duration) { setDefaultValues(TableIndex); m_RunRecord[TableIndex].m_RunState = On; m_RunRecord[TableIndex].m_TimeStamp = getTickCount(); } } } else if ((!Running) && (m_RunRecord[TableIndex].m_RunState != Off)) { // The running state has just been disabled. if (m_RunRecord[TableIndex].m_RunState == On) { setIntegerParam(TableIndex, RUNNING, Decel); m_RunRecord[TableIndex].m_RunState = Decel; m_RunRecord[TableIndex].m_TimeStamp = getTickCount(); } else if (m_RunRecord[TableIndex].m_RunState == Decel) { // It is intended that the (simulated) pump speed ramps down to nothing in Duration static const int Duration = 2000; int ElapsedTime = getTickCount() - m_RunRecord[TableIndex].m_TimeStamp; int StatorFrequency = ((Duration - ElapsedTime) * NormalStatorFrequency) / Duration; if (StatorFrequency < 3) StatorFrequency = 3; setIntegerParam(TableIndex, STATORFREQUENCY, StatorFrequency); if (ElapsedTime >= Duration) { setIntegerParam(TableIndex, RUNNING, Moving); m_RunRecord[TableIndex].m_RunState = Moving; m_RunRecord[TableIndex].m_TimeStamp = getTickCount(); } } else if (m_RunRecord[TableIndex].m_RunState == Moving) { // It is intended that the pump remains in the 'Moving' state for another Duration static const unsigned Duration = 2000; unsigned ElapsedTime = getTickCount() - m_RunRecord[TableIndex].m_TimeStamp; if (ElapsedTime >= Duration) { setIntegerParam(TableIndex, STATORFREQUENCY, 0); setIntegerParam(TableIndex, RUNNING, Off); m_RunRecord[TableIndex].m_RunState = Off; m_RunRecord[TableIndex].m_TimeStamp = getTickCount(); } } } } USSWritePacket.m_USSPacketStruct.m_PZD[0] = 0; RunState = m_RunRecord[TableIndex].m_RunState; if (RunState == On) USSWritePacket.m_USSPacketStruct.m_PZD[0] |= (1 << 10); else if (RunState == Accel) USSWritePacket.m_USSPacketStruct.m_PZD[0] |= (1 << 4); else if (RunState == Decel) USSWritePacket.m_USSPacketStruct.m_PZD[0] |= (1 << 5); else if (RunState == Moving) USSWritePacket.m_USSPacketStruct.m_PZD[0] |= (1 << 11); // Remote has been activated 1 = start/stop (control bit 0) and reset(control bit 7) through serial interface is possible. USSWritePacket.m_USSPacketStruct.m_PZD[0] |= ((RemoteActivated ? 1 : 0) << 15); bool Fault = (getIntegerParam(TableIndex, FAULT) != 0); if (Fault) { // A fault condition causes the controller to stop the pump. USSWritePacket.m_USSPacketStruct.m_PZD[0] |= (1 << 3); setIntegerParam(TableIndex, STATORFREQUENCY, 0); setIntegerParam(TableIndex, RUNNING, Off); m_RunRecord[TableIndex].m_RunState = Off; } if (getIntegerParam(TableIndex, WARNINGTEMPERATURE) != 0) USSWritePacket.m_USSPacketStruct.m_PZD[0] |= (1 << 7); if (getIntegerParam(TableIndex, WARNINGHIGHLOAD) != 0) USSWritePacket.m_USSPacketStruct.m_PZD[0] |= (1 << 13); if (getIntegerParam(TableIndex, WARNINGPURGE) != 0) USSWritePacket.m_USSPacketStruct.m_PZD[0] |= (1 << 14); // Frequency - actual value. This is equivalent to parameter 3. Both packet types have this field. USSWritePacket.m_USSPacketStruct.m_PZD[1] = getIntegerParam(TableIndex, STATORFREQUENCY); epicsUInt16 PKE = 0; if (USSReadPacket.m_USSPacketStruct.m_PKE & (1 << 12)) // The requested parameter is in the least 12 bits. PKE = USSReadPacket.m_USSPacketStruct.m_PKE & 0X0FFF; switch (PKE) { case 3 : // Frequency - actual value. This is equivalent to PZD[1]. USSWritePacket.m_USSPacketStruct.m_PWE = getIntegerParam(TableIndex, STATORFREQUENCY); break; case 11: // Converter temperature - actual value. This is equivalent to PZD[2]. USSWritePacket.m_USSPacketStruct.m_PWE = getIntegerParam(TableIndex, CONVERTERTEMPERATURE); break; case 5 : // Motor current - actual value. This is equivalent to PZD[3]. USSWritePacket.m_USSPacketStruct.m_PWE = epicsUInt32(10.0 * getDoubleParam(TableIndex, MOTORCURRENT) + 0.5); break; case 7 : // Motor temperature - actual value. This is equivalent to PZD[4]. USSWritePacket.m_USSPacketStruct.m_PWE = getIntegerParam(TableIndex, PUMPTEMPERATURE); break; case 4 : // Intermediate circuit voltage Uzk. This is equivalent to PZD[5]. USSWritePacket.m_USSPacketStruct.m_PWE = epicsUInt32(10.0 * getDoubleParam(TableIndex, CIRCUITVOLTAGE) + 0.5); break; case 2 : // Software version (I assume this means firmware). e.g. 3.03.05 char CBuf[8]; // 7 chars plus null termination. int Major, Minor1, Minor2; getStringParam(TableIndex, FIRMWAREVERSION, sizeof(CBuf), CBuf); sscanf(CBuf, "%1d.%02d.%02d", &Major, &Minor1, &Minor2); USSWritePacket.m_USSPacketStruct.m_PWE = Major * 10000 + Minor1 * 100 + Minor2; break; case 171: // Error code USSWritePacket.m_USSPacketStruct.m_PWE = getIntegerParam(TableIndex, FAULT); break; case 227: // Temperature Warning code USSWritePacket.m_USSPacketStruct.m_PWE = getIntegerParam(TableIndex, WARNINGTEMPERATURE); break; case 228: // Load warning code. USSWritePacket.m_USSPacketStruct.m_PWE = getIntegerParam(TableIndex, WARNINGHIGHLOAD); break; case 230: // Purge warning code. USSWritePacket.m_USSPacketStruct.m_PWE = getIntegerParam(TableIndex, WARNINGPURGE); break; default: break; // No action. } USSWritePacket.GenerateChecksum(); USSWritePacket.m_USSPacketStruct.HToN(); size_t nbytesOut; asynStatus status = pasynOctetSyncIO->write(IOUser, reinterpret_cast<char*>(&USSWritePacket.m_Bytes), USSPacketStruct<NoOfPZD>::USSPacketSize, -1, &nbytesOut); if (status == asynDisconnected) return false; if (status != asynSuccess) throw CException(IOUser, status, __FUNCTION__, "Can't write/read:"); callParamCallbacks(int(TableIndex)); asynPrint(IOUser, ASYN_TRACE_FLOW, "Packet success %s %s\n", __FILE__, __FUNCTION__); return true; }