/* MAINLINE */ int main(int argc, const char *argv[]){ printf("MakeTreeSpawn - Gareth Bradshaw Feb 2003\n"); /* parse command line */ decodeIntParam(argc, argv, intParams); decodeBoolParam(argc, argv, boolParams); printf("Options : \n"); writeParam(stdout, intParams); writeParam(stdout, boolParams); /* look for filenames and construct trees */ int numFiles = 0; for (int i = 1; i < argc; i++){ if (argv[i] != NULL){ constructTree(argv[i], yaml); numFiles++; } } /* check we had a file name */ if (numFiles == 0) error("no files given :("); waitForKey(); }
// Write VIS Mode void Adafruit_SI1145::writeVisSen(boolean high) { if (high) { writeParam(SI1145_PARAM_ALSIRADCMISC, 0x00); } else { writeParam(SI1145_PARAM_ALSIRADCMISC, SI1145_PARAM_ALSIRADCMISC_RANGE); } }
void imageGLWidget::setYTParam(int value) { //value is 0 to 1000, map onto range 0.25,0.35 yTParam=0.0001*(value+2500); functionParam.coordinate[1].x = yTParam; emit writeParam((char *)&functionParam); }
void imageGLWidget::setZTParam(int value) { //value is 0 to 1000, map onto range 0.2,0.3 zTParam=0.0001*(value+2000); functionParam.coordinate[2].x = zTParam; emit writeParam((char *)&functionParam); }
void imageGLWidget::setPParam(int value) { //value is 0 to 1000, map onto range 0.25,0.75 PParam=0.0005*(value+500); functionParam.coordinate[3].x = PParam; emit writeParam((char *)&functionParam); }
void imageGLWidget::setXTParam(int value) { //value is 0 to 1000, map onto range 0.45,0.55 xTParam=0.0001*(value+4500); functionParam.coordinate[0].x = xTParam; emit writeParam((char *)&functionParam); }
xml::Element& operator<<(xml::Element& elemFields, const Field& field) { if (field.name.size() != 0 && field.dataType.name != "void") { xml::Element& elemField = elemFields.createElement("field", ""); writeParam(elemFields, elemField, field); } return elemFields; }
xml::Element& operator<<(xml::Element& elemParams, const Param& param) { if (param.name.size() != 0 && param.dataType.name != "void") { xml::Element& elemParam = elemParams.createElement("param", ""); writeParam(elemParams, elemParam, param); } return elemParams; }
void PulsePlug::initSensor() { PulsePlug::setReg(PulsePlug::HW_KEY, 0x17); // pulsePlug.setReg(PulsePlug::COMMAND, PulsePlug::RESET_Cmd); // setReg(PulsePlug::INT_CFG, 0x03); // turn on interrupts setReg(PulsePlug::IRQ_ENABLE, 0x10); // turn on interrupt on PS3 setReg(PulsePlug::IRQ_MODE2, 0x01); // interrupt on ps3 measurement setReg(PulsePlug::MEAS_RATE, 0x84); // 10ms measurement rate setReg(PulsePlug::ALS_RATE, 0x08); // ALS 1:1 with MEAS setReg(PulsePlug::PS_RATE, 0x08); // PS 1:1 with MEAS // Current setting for LEDs pulsed while taking readings // PS_LED21 Setting for LEDs 1 & 2. LED 2 is high nibble // each LED has 16 possible (0-F in hex) possible settings // see the SI114x datasheet. // These settings should really be automated with feedback from output // On my todo list but your patch is appreciated :) // support at moderndevice dot com. setReg(PulsePlug::PS_LED21, 0x39); // LED current for 2 (IR1 - high nibble) & LEDs 1 (red - low nibble) setReg(PulsePlug::PS_LED3, 0x02); // LED current for LED 3 (IR2) writeParam(PulsePlug::PARAM_CH_LIST, 0x77); // all measurements on // increasing PARAM_PS_ADC_GAIN will increase the LED on time and ADC window // you will see increase in brightness of visible LED's, ADC output, & noise // datasheet warns not to go beyond 4 because chip or LEDs may be damaged writeParam(PulsePlug::PARAM_PS_ADC_GAIN, 0x00); // You can select which LEDs are energized for each reading. // The settings below (in the comments) // turn on only the LED that "normally" would be read // ie LED1 is pulsed and read first, then LED2 & LED3. writeParam(PulsePlug::PARAM_PSLED12_SELECT, 0x21); // 21 select LEDs 2 & 1 (red) only writeParam(PulsePlug::PARAM_PSLED3_SELECT, 0x04); // 4 = LED 3 only // Sensors for reading the three LEDs // 0x03: Large IR Photodiode // 0x02: Visible Photodiode - cannot be read with LEDs on - just for ambient measurement // 0x00: Small IR Photodiode writeParam(PulsePlug::PARAM_PS1_ADCMUX, 0x03); // PS1 photodiode select writeParam(PulsePlug::PARAM_PS2_ADCMUX, 0x03); // PS2 photodiode select writeParam(PulsePlug::PARAM_PS3_ADCMUX, 0x03); // PS3 photodiode select writeParam(PulsePlug::PARAM_PS_ADC_COUNTER, B01110000); // B01110000 is default setReg(PulsePlug::COMMAND, PulsePlug::PSALS_AUTO_Cmd); // starts an autonomous read loop }
boolean FOXFIRE_Si1132::begin(void) { //Initialize the I2C bus if not already enabled if (!Wire.isEnabled()) { Wire.begin(); } reset(); // enable UVindex measurement coefficients! //write8(Si1132_REG_UCOEF0, 0x29); //write8(Si1132_REG_UCOEF1, 0x89); //write8(Si1132_REG_UCOEF2, 0x02); //write8(Si1132_REG_UCOEF3, 0x00); write8(Si1132_REG_UCOEF0, 0x7B); write8(Si1132_REG_UCOEF1, 0x6B); write8(Si1132_REG_UCOEF2, 0x01); write8(Si1132_REG_UCOEF3, 0x00); // enable UV, IR and Visible light sensors writeParam(Si1132_PARAM_CHLIST, Si1132_PARAM_CHLIST_ENUV | Si1132_PARAM_CHLIST_ENALSIR | Si1132_PARAM_CHLIST_ENALSVIS); write8(Si1132_REG_INTCFG, Si1132_REG_INTCFG_INTOE); write8(Si1132_REG_IRQEN, Si1132_REG_IRQEN_ALSEVERYSAMPLE); writeParam(Si1132_PARAM_ALSIRADCMUX, Si1132_PARAM_ADCMUX_SMALLIR); // fastest clocks, clock div 1 writeParam(Si1132_PARAM_ALSIRADCGAIN, 0x00); // take 511 clocks to measure writeParam(Si1132_PARAM_ALSIRADCCOUNTER, Si1132_PARAM_ADCCOUNTER_511CLK); // in high range mode writeParam(Si1132_PARAM_ALSIRADCMISC, Si1132_PARAM_ALSIRADCMISC_RANGE); // fastest clocks writeParam(Si1132_PARAM_ALSVISADCGAIN, 0x00); // take 511 clocks to measure writeParam(Si1132_PARAM_ALSVISADCCOUNTER, Si1132_PARAM_ADCCOUNTER_511CLK); // in high range mode (not normal signal) writeParam(Si1132_PARAM_ALSVISADCMISC, Si1132_PARAM_ALSVISADCMISC_VISRANGE); // measure rate for auto, 32 * 31.25us = 1000us = 1ms write8(Si1132_REG_MEASRATE0, 0xFF); //write8(Si1132_REG_MEASRATE1, 0xFF); write8(Si1132_REG_COMMAND, Si1132_ALS_AUTO); return true; }
// allow sensor to be initialised with a specific I2c address boolean Adafruit_SI1145::begin( uint8_t addr ) { boolean begun; Wire.begin(); if ( !_reset ) reset(); _reset = true; writeParam( 0x00, addr ); write8( SI1145_REG_COMMAND, SI1145_BUSADDR ); _addr = addr; begun = begin(); _reset = false; return begun; }
/* * Output results to file after simulation is completed. */ void ClusterHistogram::output() { // Write parameter file fileMaster().openOutputFile(outputFileName(".prm"), outputFile_); writeParam(outputFile_); outputFile_.close(); // Write histogram output fileMaster().openOutputFile(outputFileName(".hist"), outputFile_); // hist_.output(outputFile_); int min = hist_.min(); int nBin = hist_.nBin(); for (int i = 0; i < nBin; ++i) { outputFile_ << Int(i + min) << " " << Dbl(double(hist_.data()[i])/double(nSample_)) << "\n"; } outputFile_.close(); }
/* * Output results to file after simulation is completed. */ void McMuExchange::output() { fileMaster().openOutputFile(outputFileName(".prm"), outputFile_); writeParam(outputFile_); outputFile_.close(); double ave, err; double sumAve = 0.0; double sumAveSq = 0.0; double sumErrSq = 0.0; for (int iMol=0; iMol < nMolecule_; ++iMol) { ave = accumulators_[iMol].average(); err = accumulators_[iMol].blockingError(); sumAve += ave; sumAveSq += ave*ave; sumErrSq += err*err; } double rMol = double(nMolecule_); ave = sumAve/rMol; err = sqrt(sumErrSq/rMol); double dev = sqrt((sumAveSq/rMol) - ave*ave); fileMaster().openOutputFile(outputFileName(".ave"), outputFile_); outputFile_ << "Average = " << ave << " +- " << dev/sqrt(rMol) << std::endl; outputFile_ << "Error via molecule variance = " << dev/sqrt(rMol) << std::endl; outputFile_ << "Error via time series analysis = " << err/sqrt(rMol) << std::endl; outputFile_ << std::endl; //for (int iMol=0; iMol < nMolecule_; ++iMol) { // accumulators_[iMol].output(outputFile_); //} outputFile_.close(); }
void ConfigChannel::writeParam(cvg_int id, cvg_float value) { float_hton(&value); writeParam(id, (cvg_char *)&value, sizeof(cvg_float)); }
void RecordWorkThread::run() { recorderFlag = false; anares.clear(); CurrentStaus cstatus; workbook *wb = new workbook(); xf_t* xf = wb->xformat(); worksheet* ws; ws = wb->sheet("sheet1"); setTitle(ws,xf); int cnt = 1; int sheetNUM = 1; overflow = false; bool first = true; Util::SysLogD("charge type : %d %f %f %f\n ",charge_type,power_charge_normal,power_charge_peak,power_charge_valley); Util::SysLogD("normal : %d %d %d %d %d %d\n ",normal_period[0],normal_period[1],normal_period[2],normal_period[3],normal_period[4],normal_period[5]); Util::SysLogD("peak : %d %d %d %d %d %d\n ",peak_period[0],peak_period[1],peak_period[2],peak_period[3],peak_period[4],peak_period[5]); Util::SysLogD("valley : %d %d %d %d %d %d\n ",valley_period[0],valley_period[1],valley_period[2],valley_period[3],valley_period[4],valley_period[5]); while(!recorderFlag) { if(overflow) { usleep(300000); } usleep(300000); EnergyParam param = dataWoker->getEnergyParam(); if(first) { anares.start_measure_time = param.time; first = false; mutex.lock(); initStatus(&cstatus,¶m); anares.vsp_cnt = cstatus.acc_vsp_cnt; mutex.unlock(); writeParam(ws,xf,param,cnt); } if(cstatus.lastTime < param.time) { cnt++; mutex.lock(); updateResult(&cstatus,¶m); anares.vsp_cnt = cstatus.acc_vsp_cnt; mutex.unlock(); writeParam(ws,xf,param,cnt); } acc_flow = anares.acc_flow; acc_power = anares.acc_power; load_radio = ((float)anares.load_time/(float)(anares.load_time + anares.unload_time))*100.0; if(cnt>SHEET_MAX_LINE) { if(sheetNUM < SHEET_MAX_INDEX) { char temp[10]; sprintf(temp,"sheet%d",sheetNUM+1); ws = wb->sheet(temp); setTitle(ws,xf); sheetNUM++; }else { emit recordoverflow(1); overflow = true; } cnt = 0; } } if(cstatus.state == STAGE_LOAD ) { // anares.load_cnt++; // anares.load_time += cstatus.duration; if(anares.max_load_time < cstatus.duration) { anares.max_load_time = cstatus.duration; } }else if(cstatus.state == STAGE_UNLOAD ) { // anares.unload_cnt++; // anares.unload_time += cstatus.duration; if(anares.max_unload_time < cstatus.duration) { anares.max_unload_time = cstatus.duration; } } if(cstatus.acc_vsp_cnt>0) anares.ave_vsp = anares.ave_vsp/(float)cstatus.acc_vsp_cnt; anares.end_measure_time = cstatus.lastTime; anares.worktime = anares.load_time + anares.unload_time; anares.stanby_time = anares.end_measure_time - anares.start_measure_time - anares.worktime; Util::SysLogD("start and end time : %d %d\n",anares.start_measure_time,anares.end_measure_time); Util::SysLogD("load and unload time : %d %d\n",anares.load_time,anares.unload_time); Util::SysLogD("acc_flow : %f\n",anares.acc_flow); Util::SysLogD("cur : %d %d\n",max_cur_standby,max_cur_unload); Util::SysLogD("max time : %d %d\n",anares.max_load_time,anares.max_unload_time); Util::SysLogD("max time : %d %d\n",anares.max_load_time,anares.max_unload_time); Util::SysLogD("vas : %f %d\n",anares.ave_vsp,cstatus.acc_vsp_cnt); if(anares.worktime != 0) { anares.load_radio = ((float)anares.load_time)/(float)anares.worktime*100.0; anares.unload_radio = ((float)anares.unload_time)/(float)anares.worktime*100.0; } anares.acc_flow = anares.acc_flow/60;//m3/min anares.acc_power = anares.acc_power/3600;//kwh anares.load_power /= 3600; anares.unload_power /= 3600; if(charge_type == 1) { anares.acc_charge_normal = anares.acc_charge_normal*power_charge_normal/3600; anares.acc_charge_peak = anares.acc_charge_peak*power_charge_peak/3600; anares.acc_charge_valley = anares.acc_charge_valley*power_charge_valley/3600; anares.acc_charge = anares.acc_charge_normal+anares.acc_charge_peak+anares.acc_charge_valley; anares.load_charge /= 3600; anares.unload_chargd /= 3600; }else if(charge_type == 0) { anares.acc_charge = anares.acc_power*power_charge; anares.load_charge = anares.load_power*power_charge; anares.unload_chargd = anares.unload_power*power_charge; } anares.permanent_magnet_frequency_conversion = anares.unload_power+anares.load_power*0.1; anares.first_order_energy_efficiency = -7.2*anares.acc_flow/60 + anares.acc_power; anares.permanent_magnet_frequency_conversion_day = anares.permanent_magnet_frequency_conversion * 12 / anares.worktime *3600; anares.permanent_magnet_frequency_conversion_month = anares.permanent_magnet_frequency_conversion * 30 * 12 / anares.worktime *3600; anares.permanent_magnet_frequency_conversion_year = anares.permanent_magnet_frequency_conversion * 365 * 30 * 12 / anares.worktime *3600; if(anares.first_order_energy_efficiency <0.00001) { anares.first_order_energy_efficiency = 0; anares.first_order_energy_efficiency_day = 0; anares.first_order_energy_efficiency_month = 0; anares.first_order_energy_efficiency_year = 0; }else { anares.first_order_energy_efficiency_day = anares.first_order_energy_efficiency * 12 / anares.worktime *3600; anares.first_order_energy_efficiency_month = anares.first_order_energy_efficiency * 30 * 12 / anares.worktime *3600; anares.first_order_energy_efficiency_year = anares.first_order_energy_efficiency * 365 * 30 * 12 / anares.worktime *3600; } anares.load_charge_radio = anares.load_charge/ anares.acc_charge *100.0; anares.unload_charge_radio = anares.unload_chargd/ anares.acc_charge *100.0; anares.ave_cost = anares.acc_charge / anares.acc_flow; anares.ave_power_cost = anares.acc_power / anares.acc_flow; // char temp[10]; // sprintf(temp,"sheet%d",sheetNUM+1); ws = wb->sheet("分析结果"); Util::writeResultWithFormat(ws,xf,anares); string path_post = title.toStdString(); string path = path_pre + path_post; wb->Dump(path); delete wb; Util::fileSync(path.c_str()); Util::SysLogD("save file : %s\n",path.c_str()); emit recordoverflow(2); }
void ConfigChannel::writeParam(cvg_int id, cvg_int value) { value = htonl(value); writeParam(id, (cvg_char *)&value, sizeof(cvg_int)); }
void ConfigChannel::writeParam(cvg_int id, const cvgString &value) { writeParam(id, value.c_str(), value.length()); }
/* construct sphere-tree for the model */ bool constructTree(const boost::filesystem::path& input_file, bool toYAML) { boost::filesystem::path output_file = input_file.parent_path () / boost::filesystem::basename (input_file); if (toYAML) output_file += "-spawn.yml"; else output_file += "-spawn.sph"; printf("Input file: %s\n", input_file.c_str ()); printf("Output file: %s\n\n", output_file.c_str ()); /* load the surface model */ Surface sur; bool loaded = false; std::string extension = boost::algorithm::to_lower_copy (input_file.extension ().string ()); if (extension == ".obj") loaded = loadOBJ(&sur, input_file.c_str ()); else loaded = sur.loadSurface(input_file.c_str ()); if (!loaded){ printf("ERROR : Unable to load input file (%s)\n\n", input_file.c_str ()); return false; } /* scale box */ // FIXME: Disable scaling for now (wrong result if a transformation is applied after) //float boxScale = sur.fitIntoBox(1000); float boxScale = 1.; /* make medial tester */ MedialTester mt; mt.setSurface(sur); mt.useLargeCover = true; /* setup evaluator */ SEConvex convEval; convEval.setTester(mt); SEBase *eval = &convEval; Array<Point3D> sphPts; SESphPt sphEval; if (testerLevels > 0){ // <= 0 will use convex tester SSIsohedron::generateSamples(&sphPts, testerLevels-1); sphEval.setup(mt, sphPts); eval = &sphEval; printf("Using concave tester (%d)\n\n", sphPts.getSize()); } /* verify model */ if (verify){ bool ok = verifyModel(sur); if (!ok){ printf("ERROR : model is not usable\n\n"); return false; } } /* setup for the set of cover points */ Array<Surface::Point> coverPts; MSGrid::generateSamples(&coverPts, numCoverPts, sur, TRUE, minCoverPts); printf("%d cover points\n", coverPts.getSize()); /* setup SPAWN algorithm */ SRSpawn spawn; spawn.setup(mt); spawn.useIterativeSelect = false; spawn.eval = eval; /* setup SphereTree constructor - using dynamic construction */ STGGeneric treegen; treegen.eval = eval; treegen.useRefit = true; treegen.setSamples(coverPts); treegen.reducer = &spawn; /* make sphere-tree */ SphereTree tree; tree.setupTree(branch, depth+1); waitForKey(); treegen.constructTree(&tree); /* save sphere-tree */ if (tree.saveSphereTree(output_file, 1.0f/boxScale)){ Array<LevelEval> evals; if (eval){ evaluateTree(&evals, tree, eval); writeEvaluation(stdout, evals); } if (!yaml) { FILE *f = fopen(output_file.c_str (), "a"); if (f){ fprintf(f, "\n\n"); fprintf(f, "Options : \n"); writeParam(stdout, intParams); writeParam(stdout, boolParams); fprintf(f, "\n\n"); writeEvaluation(f, evals); fclose(f); } } return true; } else{ return false; } }
// Write Vis ADC Counter void Adafruit_SI1145::writeVisAdcCnt(uint8_t cnt) { cnt = cnt & 0x7; cnt = cnt << 4; writeParam(SI1145_PARAM_ALSVISADCOUNTER, cnt); }
// Write Vis ADC Gain void Adafruit_SI1145::writeVisAdcGain(uint8_t gain) { gain = gain & 0x07; writeParam(SI1145_PARAM_ALSVISADCGAIN, gain); }
void pfPrcHelper::writeParam(const char* name, const char* value) { writeParam(name, ST::string(value)); }
boolean Adafruit_SI1145::begin(void) { Wire.begin(); uint8_t id = read8(SI1145_REG_PARTID); if (id != 0x45) return false; // look for SI1145 reset(); /***********************************/ // enable UVindex measurement coefficients! write8(SI1145_REG_UCOEFF0, 0x29); write8(SI1145_REG_UCOEFF1, 0x89); write8(SI1145_REG_UCOEFF2, 0x02); write8(SI1145_REG_UCOEFF3, 0x00); // enable UV sensor writeParam(SI1145_PARAM_CHLIST, SI1145_PARAM_CHLIST_ENUV | SI1145_PARAM_CHLIST_ENALSIR | SI1145_PARAM_CHLIST_ENALSVIS | SI1145_PARAM_CHLIST_ENPS1); // enable interrupt on every sample write8(SI1145_REG_INTCFG, SI1145_REG_INTCFG_INTOE); write8(SI1145_REG_IRQEN, SI1145_REG_IRQEN_ALSEVERYSAMPLE); /****************************** Prox Sense 1 */ // program LED current write8(SI1145_REG_PSLED21, 0x03); // 20mA for LED 1 only writeParam(SI1145_PARAM_PS1ADCMUX, SI1145_PARAM_ADCMUX_LARGEIR); // prox sensor #1 uses LED #1 writeParam(SI1145_PARAM_PSLED12SEL, SI1145_PARAM_PSLED12SEL_PS1LED1); // fastest clocks, clock div 1 writeParam(SI1145_PARAM_PSADCGAIN, 0); // take 511 clocks to measure writeParam(SI1145_PARAM_PSADCOUNTER, SI1145_PARAM_ADCCOUNTER_511CLK); // in prox mode, high range writeParam(SI1145_PARAM_PSADCMISC, SI1145_PARAM_PSADCMISC_RANGE| SI1145_PARAM_PSADCMISC_PSMODE); writeParam(SI1145_PARAM_ALSIRADCMUX, SI1145_PARAM_ADCMUX_SMALLIR); // fastest clocks, clock div 1 writeParam(SI1145_PARAM_ALSIRADCGAIN, 0); // take 511 clocks to measure writeParam(SI1145_PARAM_ALSIRADCOUNTER, SI1145_PARAM_ADCCOUNTER_511CLK); // in high range mode writeParam(SI1145_PARAM_ALSIRADCMISC, SI1145_PARAM_ALSIRADCMISC_RANGE); // fastest clocks, clock div 1 writeParam(SI1145_PARAM_ALSVISADCGAIN, SI1145_PARAM_ADCGAIN_128); // take 511 clocks to measure writeParam(SI1145_PARAM_ALSVISADCOUNTER, SI1145_PARAM_ADCCOUNTER_511CLK); // in normal range mode (normal signal) writeParam(SI1145_PARAM_ALSVISADCMISC, SI1145_PARAM_ALSVISADCMISC_VISLRANGE); /************************/ // measurement rate for auto write8(SI1145_REG_MEASRATE0, 0xFF); // 255 * 31.25uS = 8ms // auto run write8(SI1145_REG_COMMAND, SI1145_PSALS_AUTO); return true; }
void pfPrcHelper::writeParam(const char* name, float value) { writeParam(name, (double)value); }