bool ServerDeviceView::poll()
{
bool bSuccessfullyUpdated= true;
IDeviceInterface* device = getDevice();
// Only poll data from open, bluetooth controllers
if (device != nullptr && device->getIsReadyToPoll())
{
switch (device->poll())
{
case IDeviceInterface::_PollResultSuccessNoData:
{
long max_failure= device->getMaxPollFailureCount();
++m_pollNoDataCount;
if (m_pollNoDataCount > max_failure)
{
SERVER_LOG_INFO("ServerDeviceView::poll") <<
"Device id " << getDeviceID() << " closing due to no data (" << max_failure << " failed poll attempts)";
device->close();
bSuccessfullyUpdated= false;
}
}
break;
case IDeviceInterface::_PollResultSuccessNewData:
{
m_pollNoDataCount= 0;
m_lastNewDataTimestamp= std::chrono::high_resolution_clock::now();
// If we got new sensor data, then we have new state to publish
markStateAsUnpublished();
bSuccessfullyUpdated= true;
}
break;
case IDeviceInterface::_PollResultFailure:
{
SERVER_LOG_INFO("ServerDeviceView::poll") <<
"Device id " << getDeviceID() << " closing due to failed read";
device->close();
bSuccessfullyUpdated= false;
}
break;
}
}
return bSuccessfullyUpdated;
}
bool Adafruit_ADXL345_Unified::begin() {
// if (_i2c)
TinyWireM.begin();
// else {
// pinMode(_cs, OUTPUT);
// pinMode(_clk, OUTPUT);
// digitalWrite(_clk, HIGH);
// pinMode(_do, OUTPUT);
// pinMode(_di, INPUT);
// }
/* Check connection */
uint8_t deviceid = getDeviceID();
if (deviceid != 0xE5)
{
/* No ADXL345 detected ... return false */
// Serial.println(deviceid, HEX);
return false;
}
// Enable measurements
writeRegister(ADXL345_REG_POWER_CTL, 0x08);
return true;
}
/*
* Verify the device info
*/
void VerifyDevInfo(void) {
if (!ignore_dev_info && !cpci_reprog) {
/* Read the device info from the board */
nf2_read_info(&nf2);
/* Print the device information */
printf(getDeviceInfoStr(&nf2));
/* Check the CPCI version info */
if (getDeviceID(&nf2) == -1) {
fprintf(log_file, "WARNING: NetFPGA device info not found. Cannot verify that the CPCI version matches.\n");
}
else {
if (getCPCIVersion(&nf2) != getDeviceCPCIVersion(&nf2)) {// ||
// Commented out so the script will not give an error on revision number changes. Revisions should be small changes that do not need users to upgrade the CPCI. The users should only be forced to change the CPCI on a major release.
// cpci_revision != nf2_cpci_revision) {
fprintf(stderr, "Error: Virtex design compiled against a different CPCI version\n");
fprintf(stderr, " Active CPCI version : %d (rev %d)\n", getCPCIVersion(&nf2), getCPCIRevision(&nf2));
fprintf(stderr, " Device built against: %d (rev %d)\n", getDeviceCPCIVersion(&nf2), getDeviceCPCIRevision(&nf2));
exit(1);
}
else {
fprintf(stderr,"Virtex design compiled against active CPCI version\n");
}
}
}
}
bool ADXL345::begin() {
if (_i2c)
Wire.begin();
else {
pinMode(_cs, OUTPUT);
pinMode(_clk, OUTPUT);
digitalWrite(_clk, HIGH);
pinMode(_do, OUTPUT);
pinMode(_di, INPUT);
}
/* Check connection */
uint8_t deviceid = getDeviceID();
if (deviceid != 0xE5)
{
/* No ADXL345 detected ... return false */
Serial.println(deviceid, HEX);
return false;
}
// Enable measurements
writeRegister(ADXL345_REG_POWER_CTL, 0x08);
return true;
}
SEXP ocl_get_device_info_char(SEXP device, SEXP item) {
cl_device_id device_id = getDeviceID(device);
cl_device_info pn = (cl_device_info) Rf_asInteger(item);
*infobuf = 0;
if ((last_ocl_error = clGetDeviceInfo(device_id, pn, sizeof(infobuf), &infobuf, NULL)) != CL_SUCCESS)
ocl_err("clGetDeviceInfo");
return Rf_mkString(infobuf);
}
SEXP ocl_get_device_info_char(SEXP device, SEXP item) {
char buf[512];
cl_device_id device_id = getDeviceID(device);
cl_device_info pn = (cl_device_info) Rf_asInteger(item);
buf[0] = 0;
if (clGetDeviceInfo(device_id, pn, sizeof(buf), &buf, NULL) != CL_SUCCESS)
ocl_err("clGetDeviceInfo");
return Rf_mkString(buf);
}
uint16_t encryptNumber(uint32_t num){
uint16_t e = getDeviceID();
uint32_t n = getModulus();
uint32_t result = 1;
for(uint16_t j = 0; j < e; j++){
result = (result * num % n);
}
result = (result % n);
return (uint16_t)result;
}
void ADS1299::printDeviceID(void)
{
boolean wasRunning;
boolean prevverbosityState = verbosity;
if (isRunning){ stopADS(); wasRunning = true;}
verbosity = true;
getDeviceID();
verbosity = prevverbosityState;
if (wasRunning){ startADS(); }
}
/** Verify the I2C connection.
* Make sure the device is connected and responds as expected.
* @return True if connection is valid, false otherwise
*/
bool MPU6050::testConnection()
{
#ifdef useDebugSerial
debugSerial.printf("MPU6050::testConnection start\n\r");
#endif
uint8_t deviceId = getDeviceID();
#ifdef useDebugSerial
debugSerial.printf("DeviceId = %d\n\r",deviceId);
#endif
return deviceId == 0x34;
}
SEXP ocl_ez_kernel(SEXP device, SEXP k_name, SEXP code, SEXP prec) {
cl_context ctx;
int err;
SEXP sctx;
cl_device_id device_id = getDeviceID(device);
cl_program program;
cl_kernel kernel;
if (TYPEOF(k_name) != STRSXP || LENGTH(k_name) != 1)
Rf_error("invalid kernel name");
if (TYPEOF(code) != STRSXP || LENGTH(code) < 1)
Rf_error("invalid kernel code");
if (TYPEOF(prec) != STRSXP || LENGTH(prec) != 1)
Rf_error("invalid precision specification");
ctx = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
if (!ctx)
ocl_err("clCreateContext");
sctx = PROTECT(mkContext(ctx));
{
int sn = LENGTH(code), i;
const char **cptr;
cptr = (const char **) malloc(sizeof(char*) * sn);
for (i = 0; i < sn; i++)
cptr[i] = CHAR(STRING_ELT(code, i));
program = clCreateProgramWithSource(ctx, sn, cptr, NULL, &err);
free(cptr);
if (!program)
ocl_err("clCreateProgramWithSource");
}
err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS) {
size_t len;
clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
clReleaseProgram(program);
Rf_error("clGetProgramBuildInfo failed: %s", buffer);
}
kernel = clCreateKernel(program, CHAR(STRING_ELT(k_name, 0)), &err);
clReleaseProgram(program);
if (!kernel)
ocl_err("clCreateKernel");
{
SEXP sk = PROTECT(mkKernel(kernel));
Rf_setAttrib(sk, Rf_install("device"), device);
Rf_setAttrib(sk, Rf_install("precision"), prec);
Rf_setAttrib(sk, Rf_install("context"), sctx);
Rf_setAttrib(sk, Rf_install("name"), k_name);
UNPROTECT(2); /* sk + context */
return sk;
}
}
//--------------------------------------------------------------
void ofxCLEye::setDeviceGUID(GUID deviceGUID){
int id = getDeviceID(deviceGUID);
if(id < 0){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setdeviceGUID(): can't find device with this GUID.";
return;
}
if(initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setdeviceGUID(): can't set device while grabber is running.";
return;
}
requestedDeviceID = id;
}
/** Power on and prepare for general usage.
* This will prepare the SPI communication interface for accessing the BMI160
* on the Curie module, before calling BMI160::initialize() to activate the
* BMI160 accelerometer and gyroscpoe with default settings.
*/
bool CurieImuClass::begin()
{
ss_spi_init(SPI_SENSING_1, 2000, SPI_BUSMODE_0, SPI_8_BIT, SPI_SE_1);
/* Perform a dummy read from 0x7f to switch to spi interface */
uint8_t dummy_reg = 0x7F;
serial_buffer_transfer(&dummy_reg, 1, 1);
/* The SPI interface is ready - now invoke the base class initialization */
BMI160Class::initialize();
/** Verify the SPI connection.
* MakgetGyroRatee sure the device is connected and responds as expected.
* @return True if connection is valid, false otherwise
*/
return (CURIE_IMU_CHIP_ID == getDeviceID());
}
bool Adafruit_ADXL345_Unified::begin() {
Wire.begin();
/* Check connection */
uint8_t deviceid = getDeviceID();
if (deviceid != 0xE5)
{
/* No ADXL345 detected ... return false */
Serial.println(deviceid, HEX);
return false;
}
// Enable measurements
writeRegister(ADXL345_REG_POWER_CTL, 0x08);
return true;
}
SEXP ocl_get_device_info(SEXP device) {
SEXP res;
cl_device_id device_id = getDeviceID(device);
const char *names[] = { "name", "vendor", "version", "profile", "exts", "driver.ver" };
SEXP nv = PROTECT(Rf_allocVector(STRSXP, 6));
int i;
for (i = 0; i < LENGTH(nv); i++) SET_STRING_ELT(nv, i, mkChar(names[i]));
res = PROTECT(Rf_allocVector(VECSXP, LENGTH(nv)));
Rf_setAttrib(res, R_NamesSymbol, nv);
SET_VECTOR_ELT(res, 0, getDeviceInfo(device_id, CL_DEVICE_NAME));
SET_VECTOR_ELT(res, 1, getDeviceInfo(device_id, CL_DEVICE_VENDOR));
SET_VECTOR_ELT(res, 2, getDeviceInfo(device_id, CL_DEVICE_VERSION));
SET_VECTOR_ELT(res, 3, getDeviceInfo(device_id, CL_DEVICE_PROFILE));
SET_VECTOR_ELT(res, 4, getDeviceInfo(device_id, CL_DEVICE_EXTENSIONS));
SET_VECTOR_ELT(res, 5, getDeviceInfo(device_id, CL_DRIVER_VERSION));
UNPROTECT(2);
return res;
}
//void Init_MPU6050(MPU6050Init_Typedef *MPU6050_Config)
void Init_MPU6050(void)
{
unsigned char Rdata[5]={0};
unsigned char MPU_ID=0;
// Single_read = MPU6050_Config->Read_Data;
// Single_write= MPU6050_Config->Write_Data;
MPU_ID=getDeviceID();
if(MPU_ID == 0x68)
rt_kprintf("MPU6050 init OK!\n");
else
rt_kprintf("MPU6050 init ERROR!\n");
// MPU6050_swrite(PWR_MGMT_1,0x07);
MPU6050_swrite(PWR_MGMT_1,0x00);
MPU6050_swrite(SMPLRT_DIV,0x07);
MPU6050_swrite(CONFIG,0x06);
MPU6050_swrite(GYRO_CONFIG,0x08);
MPU6050_swrite(ACCEL_CONFIG,0x08);
}
void PCI::scan_devices()
{
int device_count = 0;
for (uint32_t bus = 0; bus < 256; bus++)
{
for (uint32_t slot = 0; slot < 32; slot++)
{
for (uint32_t function = 0; function < 8; function++)
{
//根据配置空间的第0个寄存器是否返回0FFFFH值来判断是否存在该PCI设备
uint32_t vendor = getVendorID(bus, slot, function);
if (vendor == 0xffff) break;
uint32_t device = getDeviceID(bus, slot, function);
uint32_t baseclass = getBaseClass(bus, slot, function);
uint32_t subclass = getSubClass(bus, slot, function);
uint32_t progif = getProgIF(bus, slot, function);
PCI_IDS* pci_ids = get_device_ids(vendor, device, 0, 0);
PCI_DEVICE_CLASS* pci_class = get_device_class(baseclass, subclass, progif);
if (pci_ids != NULL)
{
printf("%d %02X:%02X:%X device: %s\n",
device_count++, bus, slot, function, pci_ids->device_name);
}
else
{
printf("%d %02X:%02X:%X vendor: %x device: %x class: %x subclass: %x \n",
device_count++, bus, slot, function, vendor, device, baseclass, subclass);
}
uint32_t header_type = getHeaderType(bus, slot, function);
if ( (header_type & 0x80) == 0) break;
/*pci_device *pdev = (pci_device *)malloc(sizeof(pci_device));
pdev->vendor = vendor;
pdev->device = device;
pdev->func = function;
pdev->driver = 0;
add_pci_device(pdev);*/
}
}
}
}
DeviceTracker::ID DeviceTracker::registerDevice(const Name& name, DeviceTracker* device) {
// Check that the device exists, if not exit
if (!device) {
return INVALID_DEVICE;
}
// Look if the name is not already used
ID deviceID = getDeviceID(name);
if (deviceID >= 0) {
return INVALID_DEVICE_NAME;
}
// Good to register the device
deviceID = Singleton::get()->_devicesVector.size();
Singleton::get()->_devicesMap.insert(Map::value_type(name, deviceID));
Singleton::get()->_devicesVector.push_back(device);
device->assignIDAndName(deviceID, name);
return deviceID;
}
void init()
{
printf("start init \n");
initArrays();
if(initDatabaseConnection() == 1)
{
printf("error setting up database connection\n");
}
if(initUart() == 1)
{
printf("error connecting to serial device\n");
}
if(initServerConnection() == 1)
{
printf("error setting up database connection\n");
}
getDeviceID();
sendDeviceIP();
printf("init done\n");
}
void GraphDog::setup(string appID,string secretKey,string _packageName,int _appVersion){
aID=appID;
sKey=secretKey;
this->packageName=_packageName;
string deviceId = getDeviceID();
this->setUdid(deviceId);
std::ostringstream ostr;
ostr << _appVersion;
this->appVersion=ostr.str();
#if COCOS2D_VERSION<0x00020000
// in cocos2d-x 1.x
CCScheduler::sharedScheduler()->scheduleSelector(schedule_selector(GraphDog::receivedCommand), this, 0,false);
#else
// in cocos2d-x 2.x
// CCDirector::sharedDirector()->getScheduler()->scheduleSelector(schedule_selector(GraphDog::receivedCommand), this, 0.f, false, kCCRepeatForever, 0);
CCDirector::sharedDirector()->getScheduler()->scheduleSelector(schedule_selector(GraphDog::receivedCommand), this, 0.f, 0xFFFFFFFF, 0, false);
#endif
setLanguage(GraphDogLib::getLocalCode());
}
void pci_probe()
{
for(uint32_t bus = 0; bus < 256; bus++)
{
for(uint32_t slot = 0; slot < 32; slot++)
{
for(uint32_t function = 0; function < 8; function++)
{
uint16_t vendor = getVendorID(bus, slot, function);
if(vendor == 0xffff) continue;
uint16_t device = getDeviceID(bus, slot, function);
mprint("vendor: 0x%x device: 0x%x\n", vendor, device);
pci_device *pdev = (pci_device *)malloc(sizeof(pci_device));
pdev->vendor = vendor;
pdev->device = device;
pdev->func = function;
pdev->driver = 0;
add_pci_device(pdev);
}
}
}
}
/** Power on and prepare for general usage.
* This will prepare the SPI communication interface for accessing the BMI160
* on the Curie module, before calling BMI160::initialize() to activate the
* BMI160 accelerometer and gyroscpoe with default settings.
*/
bool CurieIMUClass::begin()
{
/* Configure pin-mux settings on the Intel Curie module to
* enable SPI mode usage */
SET_PIN_MODE(35, QRK_PMUX_SEL_MODEA); // SPI1_SS_MISO
SET_PIN_MODE(36, QRK_PMUX_SEL_MODEA); // SPI1_SS_MOSI
SET_PIN_MODE(37, QRK_PMUX_SEL_MODEA); // SPI1_SS_SCK
SET_PIN_MODE(38, QRK_PMUX_SEL_MODEA); // SPI1_SS_CS_B[0]
ss_spi_init();
/* Perform a dummy read from 0x7f to switch to spi interface */
uint8_t dummy_reg = 0x7F;
serial_buffer_transfer(&dummy_reg, 1, 1);
/* The SPI interface is ready - now invoke the base class initialization */
BMI160Class::initialize();
/** Verify the SPI connection.
* MakgetGyroRatee sure the device is connected and responds as expected.
* @return True if connection is valid, false otherwise
*/
return (CURIE_IMU_CHIP_ID == getDeviceID());
}
/** Verify the I2C connection.
* Make sure the device is connected and responds as expected.
* @return True if connection is valid, false otherwise
*/
bool MPU6050::testConnection() {
return getDeviceID() == 0b110100;
}
BtF411_4_dev::~BtF411_4_dev() {
qDebug() << getDeviceID() << " ~btf411_1_dev ";
}
/* .External */
SEXP ocl_call(SEXP args) {
struct arg_chain *float_args = 0;
ocl_call_context_t *occ;
int on, an = 0, ftype = FT_DOUBLE, ftsize, ftres, async;
SEXP ker = CADR(args), olen, arg, res, octx, dimVec;
cl_kernel kernel = getKernel(ker);
cl_context context;
cl_command_queue commands;
cl_device_id device_id = getDeviceID(getAttrib(ker, Rf_install("device")));
cl_mem output;
cl_int err;
size_t wdims[3] = {0, 0, 0};
int wdim = 1;
if (clGetKernelInfo(kernel, CL_KERNEL_CONTEXT, sizeof(context), &context, NULL) != CL_SUCCESS || !context)
Rf_error("cannot obtain kernel context via clGetKernelInfo");
args = CDDR(args);
res = Rf_getAttrib(ker, install("precision"));
if (TYPEOF(res) == STRSXP && LENGTH(res) == 1 && CHAR(STRING_ELT(res, 0))[0] != 'd')
ftype = FT_SINGLE;
ftsize = (ftype == FT_DOUBLE) ? sizeof(double) : sizeof(float);
olen = CAR(args); /* size */
args = CDR(args);
on = Rf_asInteger(olen);
if (on < 0)
Rf_error("invalid output length");
ftres = (Rf_asInteger(CAR(args)) == 1) ? 1 : 0; /* native.result */
if (ftype != FT_SINGLE) ftres = 0;
args = CDR(args);
async = (Rf_asInteger(CAR(args)) == 1) ? 0 : 1; /* wait */
args = CDR(args);
dimVec = coerceVector(CAR(args), INTSXP); /* dim */
wdim = LENGTH(dimVec);
if (wdim > 3)
Rf_error("OpenCL standard only supports up to three work item dimensions - use index vectors for higher dimensions");
if (wdim) {
int i; /* we don't use memcpy in case int and size_t are different */
for (i = 0; i < wdim; i++)
wdims[i] = INTEGER(dimVec)[i];
}
if (wdim < 1 || wdims[0] < 1 || (wdim > 1 && wdims[1] < 1) || (wdim > 2 && wdims[2] < 1))
Rf_error("invalid dimensions - muse be a numeric vector with positive values");
args = CDR(args);
occ = (ocl_call_context_t*) calloc(1, sizeof(ocl_call_context_t));
if (!occ) Rf_error("unable to allocate ocl_call context");
octx = PROTECT(R_MakeExternalPtr(occ, R_NilValue, R_NilValue));
R_RegisterCFinalizerEx(octx, ocl_call_context_fin, TRUE);
occ->output = output = clCreateBuffer(context, CL_MEM_WRITE_ONLY, ftsize * on, NULL, &err);
if (!output)
Rf_error("failed to create output buffer of %d elements via clCreateBuffer (%d)", on, err);
if (clSetKernelArg(kernel, an++, sizeof(cl_mem), &output) != CL_SUCCESS)
Rf_error("failed to set first kernel argument as output in clSetKernelArg");
if (clSetKernelArg(kernel, an++, sizeof(on), &on) != CL_SUCCESS)
Rf_error("failed to set second kernel argument as output length in clSetKernelArg");
occ->commands = commands = clCreateCommandQueue(context, device_id, 0, &err);
if (!commands)
ocl_err("clCreateCommandQueue");
if (ftype == FT_SINGLE) /* need conversions, create floats buffer */
occ->float_args = float_args = arg_alloc(0, 32);
while ((arg = CAR(args)) != R_NilValue) {
int n, ndiv = 1;
void *ptr;
size_t al;
switch (TYPEOF(arg)) {
case REALSXP:
if (ftype == FT_SINGLE) {
int i;
float *f;
double *d = REAL(arg);
n = LENGTH(arg);
f = (float*) malloc(sizeof(float) * n);
if (!f)
Rf_error("unable to allocate temporary single-precision memory for conversion from a double-precision argument vector of length %d", n);
for (i = 0; i < n; i++) f[i] = d[i];
ptr = f;
al = sizeof(float);
arg_add(float_args, ptr);
} else {
ptr = REAL(arg);
al = sizeof(double);
}
break;
case INTSXP:
ptr = INTEGER(arg);
al = sizeof(int);
break;
case LGLSXP:
ptr = LOGICAL(arg);
al = sizeof(int);
break;
case RAWSXP:
if (inherits(arg, "clFloat")) {
ptr = RAW(arg);
ndiv = al = sizeof(float);
break;
}
default:
Rf_error("only numeric or logical kernel arguments are supported");
/* no-ops but needed to make the compiler happy */
ptr = 0;
al = 0;
}
n = LENGTH(arg);
if (ndiv != 1) n /= ndiv;
if (n == 1) {/* scalar */
if (clSetKernelArg(kernel, an++, al, ptr) != CL_SUCCESS)
Rf_error("Failed to set scalar kernel argument %d (size=%d)", an, al);
} else {
cl_mem input = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, al * n, ptr, &err);
if (!input)
Rf_error("Unable to create buffer (%d elements, %d bytes each) for vector argument %d (oclError %d)", n, al, an, err);
if (!occ->mem_objects)
occ->mem_objects = arg_alloc(0, 32);
arg_add(occ->mem_objects, input);
#if 0 /* we used this before CL_MEM_USE_HOST_PTR */
if (clEnqueueWriteBuffer(commands, input, CL_TRUE, 0, al * n, ptr, 0, NULL, NULL) != CL_SUCCESS)
Rf_error("Failed to transfer data (%d elements) for vector argument %d", n, an);
#endif
if (clSetKernelArg(kernel, an++, sizeof(cl_mem), &input) != CL_SUCCESS)
Rf_error("Failed to set vector kernel argument %d (size=%d, length=%d)", an, al, n);
/* clReleaseMemObject(input); */
}
args = CDR(args);
}
if (clEnqueueNDRangeKernel(commands, kernel, wdim, NULL, wdims, NULL, 0, NULL, async ? &occ->event : NULL) != CL_SUCCESS)
Rf_error("Error during kernel execution");
if (async) { /* asynchronous call -> get out and return the context */
#if USE_OCL_COMPLETE_CALLBACK
clSetEventCallback(occ->event, CL_COMPLETE, ocl_complete_callback, occ);
#endif
clFlush(commands); /* the specs don't guarantee execution unless clFlush is called */
occ->ftres = ftres;
occ->ftype = ftype;
occ->on = on;
Rf_setAttrib(octx, R_ClassSymbol, mkString("clCallContext"));
UNPROTECT(1);
return octx;
}
clFinish(commands);
occ->finished = 1;
/* we can release input memory objects now */
if (occ->mem_objects) {
arg_free(occ->mem_objects, (afin_t) clReleaseMemObject);
occ->mem_objects = 0;
}
if (float_args) {
arg_free(float_args, 0);
float_args = occ->float_args = 0;
}
res = ftres ? Rf_allocVector(RAWSXP, on * sizeof(float)) : Rf_allocVector(REALSXP, on);
if (ftype == FT_SINGLE) {
if (ftres) {
if ((err = clEnqueueReadBuffer( commands, output, CL_TRUE, 0, sizeof(float) * on, RAW(res), 0, NULL, NULL )) != CL_SUCCESS)
Rf_error("Unable to transfer result vector (%d float elements, oclError %d)", on, err);
PROTECT(res);
Rf_setAttrib(res, R_ClassSymbol, mkString("clFloat"));
UNPROTECT(1);
} else {
/* float - need a temporary buffer */
float *fr = (float*) malloc(sizeof(float) * on);
double *r = REAL(res);
int i;
if (!fr)
Rf_error("unable to allocate memory for temporary single-precision output buffer");
occ->float_out = fr;
if ((err = clEnqueueReadBuffer( commands, output, CL_TRUE, 0, sizeof(float) * on, fr, 0, NULL, NULL )) != CL_SUCCESS)
Rf_error("Unable to transfer result vector (%d float elements, oclError %d)", on, err);
for (i = 0; i < on; i++)
r[i] = fr[i];
}
} else if ((err = clEnqueueReadBuffer( commands, output, CL_TRUE, 0, sizeof(double) * on, REAL(res), 0, NULL, NULL )) != CL_SUCCESS)
Rf_error("Unable to transfer result vector (%d double elements, oclError %d)", on, err);
ocl_call_context_fin(octx);
UNPROTECT(1);
return res;
}
bool APDS9900::testConnection() {
return getDeviceID() == 0x29;
}
void Worker::ProcessIterations(PPM* engine) {
u_int64_t photonPerIteration = engine->photonsFirstIteration;
uint iterationCount;
resetRayBuffer();
UpdateBBox();
LookupSetHitPoints(hitPointsStaticInfo_iterationCopy, hitPoints_iterationCopy);
uint iter = 0;
double previousIterTime = WallClockTime();
fprintf(stdout, "iteration, photons_iter, photons_total, photons_sec, total_time, radius, device\n");
while (iter < config->max_iters) {
++iter;
double start = WallClockTime();
iterationCount = engine->IncIteration();
if (engine->GetIterationNumber() > MAX_ITERATIONS) {
break;
}
photonPerIteration = engine->photonsFirstIteration;
#if defined USE_SPPMPA || defined USE_SPPM
BuildHitPoints(iterationCount);
UpdateBBox();
#endif
#if defined USE_SPPM || defined USE_PPM
if (iterationCount == 1)
InitRadius(iterationCount);
#else
InitRadius(iterationCount);
#endif
updateDeviceHitPoints();
ReHash(currentPhotonRadius2);//argument ignored in non-PA
updateDeviceLookupAcc();
photonPerIteration = AdvancePhotonPath(photonPerIteration);
getDeviceHitpoints();
#if defined USE_PPM
AccumulateFluxPPM(iterationCount, photonPerIteration);
#endif
#if defined USE_SPPM
AccumulateFluxSPPM(iterationCount, photonPerIteration);
#endif
#if defined USE_SPPMPA
AccumulateFluxSPPMPA(iterationCount, photonPerIteration);
#endif
#if defined USE_PPMPA
AccumulateFluxPPMPA(iterationCount, photonPerIteration);
#endif
UpdateSampleFrameBuffer(photonPerIteration);
/**
* iteration lock required in PhotonTracedTotal
*/
engine->incPhotonTracedTotal(photonPerIteration);
//PushHitPoints();
profiler->additeratingTime(WallClockTime() - start);
profiler->addIteration(1);
if (profiler->iterationCount % 100 == 0)
profiler->printStats(deviceID);
// if (iterationCount % 50 == 0)
// engine->SaveImpl(to_string<uint> (iterationCount, std::dec) + engine->fileName);
#if defined USE_SPPM || defined USE_PPM
const float radius = hitPoints_iterationCopy[0].accumPhotonRadius2;
#else
const float radius = currentPhotonRadius2;
#endif
const double time = WallClockTime();
const double totalTime = time - engine->startTime;
const double iterTime = time - previousIterTime;
// const float itsec = engine->GetIterationNumber() / totalTime;
const uint photonTotal = engine->getPhotonTracedTotal();
const float photonSec = photonTotal / (totalTime * 1000.f);
fprintf(stdout, "%d, %lu, %u, %f, %f, %f, %f, %d\n", iterationCount, photonPerIteration, photonTotal, photonSec, iterTime, totalTime, radius, getDeviceID());
previousIterTime = time;
}
}
int main( int argc, char **argv )
{
//int ret = 0;
PTZControlInit();
demo_setting * ext_gSettings = NULL;
// Allocate the "global" settings
ext_gSettings = (demo_setting*)malloc( sizeof( demo_setting ) );
if ( NULL == ext_gSettings ) {
printf( "main::out of memory!\n" );
return -1;
}
sig_init();
atexit(appExit);
//init the setting struct
Settings_Initialize( ext_gSettings );
read_Parse(ext_gSettings);
//printf("video type = %d \n", ext_gSettings->video_types);
//...do your job
//close the led
setled_off();
//init dma memory
akuio_pmem_init();
encode_init();
printf("encode_init ok\n");
//open camera
camera_open(ext_gSettings->width, ext_gSettings->height);
printf("camera_open ok\n");
//encode_open
T_ENC_INPUT encInput;
encInput.width = ext_gSettings->width; //实际编码图像的宽度，能被4整除
encInput.height = ext_gSettings->height; //实际编码图像的长度，能被2整除
encInput.kbpsmode = ext_gSettings->kbpsmode;
encInput.qpHdr = ext_gSettings->qpHdr; //初始的QP的值
encInput.iqpHdr = ext_gSettings->iqpHdr; //初始的QP的值
encInput.bitPerSecond = ext_gSettings->bitPerSecond; //目标bps
encInput.minQp = ext_gSettings->minQp;
encInput.maxQp = ext_gSettings->maxQp;
encInput.framePerSecond = ext_gSettings->framePerSecond;
encInput.video_tytes = ext_gSettings->video_types;
encode_open(&encInput);
printf("encode_open ok\n");
//set mux
mux_input.rec_path = ext_gSettings->rec_path;
mux_input.m_MediaRecType = MEDIALIB_REC_AVI_NORMAL;
if (ext_gSettings->bhasAudio)
{
bHasAudio = 1;
//mux_input.m_bCaptureAudio = 1;
}
else
{
bHasAudio = 0;
//mux_input.m_bCaptureAudio = 0;
}
mux_input.m_bCaptureAudio = 1;
//mux video
if(parse.format2 == 0)
{
mux_input.m_eVideoType = MEDIALIB_VIDEO_H264;
}
else if(parse.format2 == 1)
{
mux_input.m_eVideoType = MEDIALIB_VIDEO_MJPEG;
}
mux_input.m_nWidth = parse.width2;
mux_input.m_nHeight = parse.height2;
//mux audio
mux_input.m_eAudioType = MEDIALIB_AUDIO_AAC;
mux_input.m_nSampleRate = 8000;
//mux_input.abitsrate = ext_gSettings->abitsrate;
printf("mux_open ok\n");
//if (ext_gSettings->bhasAudio)
{
T_AUDIO_INPUT audioInput;
audioInput.enc_type = (AUDIO_ENCODE_TYPE_CC)ext_gSettings->audioType;
audioInput.nBitsRate = ext_gSettings->abitsrate;
audioInput.nBitsPerSample = 16;
audioInput.nChannels = 1;
audioInput.nSampleRate = ext_gSettings->aSamplerate;
audio_open(&audioInput);
printf("audio_open ok\n");
audio_start();
}
//start ftp server
//startFTPSrv();
Init_photograph();
//PTZControlInit();
//start video process
video_process_start();
InitMotionDetect();
DemuxForLiveSetCallBack();
TaskScheduler* scheduler = BasicTaskScheduler::createNew();
env = BasicUsageEnvironment::createNew(*scheduler);
UserAuthenticationDatabase* authDB = NULL;
#ifdef ACCESS_CONTROL
// To implement client access control to the RTSP server, do the following:
authDB = new UserAuthenticationDatabase;
authDB->addUserRecord("username1", "password1"); // replace these with real strings
// Repeat the above with each <username>, <password> that you wish to allow
// access to the server.
#endif
// Create the RTSP server:
RTSPServer* rtspServer = AKRTSPServer::createNew(*env, RTSPPORT, authDB);
if (rtspServer == NULL)
{
*env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
appExit();
exit(1);
}
char const* descriptionString = "Session streamed by \"testOnDemandRTSPServer\"";
// Set up each of the possible streams that can be served by the
// RTSP server. Each such stream is implemented using a
// "ServerMediaSession" object, plus one or more
// "ServerMediaSubsession" objects for each audio/video substream.
int vsIndex = 0;
VIDEO_MODE vm[2] = {VIDEO_MODE_VGA,VIDEO_MODE_VGA};
const char* streamName1 = "vs1";
const char* streamName2 = "vs2";
((AKRTSPServer*)rtspServer)->SetStreamName(streamName1, streamName2);
if(ext_gSettings->video_types == 1)
{
if(ext_gSettings->width == 640)
{
vm[0] = VIDEO_MODE_VGA;
}
else if(ext_gSettings->width == 320)
{
vm[0] = VIDEO_MODE_QVGA;
}
else if(ext_gSettings->width == 720)
{
vm[0] = VIDEO_MODE_D1;
}
AKIPCMJPEGFramedSource* ipcMJPEGSourcecam = NULL;
ServerMediaSession* smsMJPEGcam = ServerMediaSession::createNew(*env, streamName1, 0, descriptionString);
AKIPCMJPEGOnDemandMediaSubsession* subsMJPEGcam = AKIPCMJPEGOnDemandMediaSubsession::createNew(*env,ipcMJPEGSourcecam, ext_gSettings->width, ext_gSettings->height, vsIndex);
smsMJPEGcam->addSubsession(subsMJPEGcam);
subsMJPEGcam->getframefunc = video_process_get_buf;
subsMJPEGcam->setledstart = setled_view_start;
subsMJPEGcam->setledexit = setled_view_stop;
if(bHasAudio)
smsMJPEGcam->addSubsession(AKIPCAACAudioOnDemandMediaSubsession::createNew(*env,True,getAACBuf, vsIndex));
rtspServer->addServerMediaSession(smsMJPEGcam);
char* url1 = rtspServer->rtspURL(smsMJPEGcam);
*env << "using url \"" << url1 <<"\"\n";
delete[] url1;
}
else if(ext_gSettings->video_types == 0)
{
if(ext_gSettings->width == 1280)
{
vm[0] = VIDEO_MODE_720P;
}
else if(ext_gSettings->width == 640)
{
vm[0] = VIDEO_MODE_VGA;
}
else if(ext_gSettings->width == 320)
{
vm[0] = VIDEO_MODE_QVGA;
}
else if(ext_gSettings->width == 720)
{
vm[0] = VIDEO_MODE_D1;
}
AKIPCH264FramedSource* ipcSourcecam = NULL;
ServerMediaSession* smscam = ServerMediaSession::createNew(*env, streamName1, 0, descriptionString);
AKIPCH264OnDemandMediaSubsession* subscam = AKIPCH264OnDemandMediaSubsession::createNew(*env,ipcSourcecam, 0, vsIndex);
smscam->addSubsession(subscam);
if(bHasAudio)
smscam->addSubsession(AKIPCAACAudioOnDemandMediaSubsession::createNew(*env,True,getAACBuf, vsIndex));
subscam->getframefunc = video_process_get_buf;
subscam->setledstart = setled_view_start;
subscam->setledexit = setled_view_stop;
rtspServer->addServerMediaSession(smscam);
char* url1 = rtspServer->rtspURL(smscam);
*env << "using url \"" << url1 <<"\"\n";
delete[] url1;
}
vsIndex = 1;
if(parse.format2 == 0)//264
{
if(parse.width2 == 1280)
{
vm[1] = VIDEO_MODE_720P;
}
else if(parse.width2 == 640)
{
vm[1] = VIDEO_MODE_VGA;
}
else if(parse.width2 == 320)
{
vm[1] = VIDEO_MODE_QVGA;
}
else if(parse.width2 == 720)
{
vm[1] = VIDEO_MODE_D1;
}
AKIPCH264FramedSource* ipcSourcecam = NULL;
ServerMediaSession* smscam = ServerMediaSession::createNew(*env, streamName2, 0, descriptionString);
AKIPCH264OnDemandMediaSubsession* subscam = AKIPCH264OnDemandMediaSubsession::createNew(*env,ipcSourcecam, 0, vsIndex);
smscam->addSubsession(subscam);
if(bHasAudio)
smscam->addSubsession(AKIPCAACAudioOnDemandMediaSubsession::createNew(*env,True,getAACBuf, vsIndex));
subscam->getframefunc = video_process_get_buf;
subscam->setledstart = setled_view_start;
subscam->setledexit = setled_view_stop;
rtspServer->addServerMediaSession(smscam);
char* url2 = rtspServer->rtspURL(smscam);
*env << "using url \"" << url2 <<"\"\n";
delete[] url2;
}
else if(parse.format2 == 1)//mjpeg
{
if(parse.width2 == 640)
{
vm[1] = VIDEO_MODE_VGA;
}
else if(parse.width2 == 320)
{
vm[1] = VIDEO_MODE_QVGA;
}
else if(parse.width2 == 720)
{
vm[1] = VIDEO_MODE_D1;
}
AKIPCMJPEGFramedSource* ipcMJPEGSourcecam = NULL;
ServerMediaSession* smsMJPEGcam = ServerMediaSession::createNew(*env, streamName2, 0, descriptionString);
AKIPCMJPEGOnDemandMediaSubsession* subsMJPEGcam = AKIPCMJPEGOnDemandMediaSubsession::createNew(*env,ipcMJPEGSourcecam, parse.width2, parse.height2, vsIndex);
smsMJPEGcam->addSubsession(subsMJPEGcam);
subsMJPEGcam->getframefunc = video_process_get_buf;
subsMJPEGcam->setledstart = setled_view_start;
subsMJPEGcam->setledexit = setled_view_stop;
if(bHasAudio)
smsMJPEGcam->addSubsession(AKIPCAACAudioOnDemandMediaSubsession::createNew(*env,True,getAACBuf, vsIndex));
rtspServer->addServerMediaSession(smsMJPEGcam);
char* url2 = rtspServer->rtspURL(smsMJPEGcam);
*env << "using url \"" << url2 <<"\"\n";
delete[] url2;
}
#if 0
if (rtspServer->setUpTunnelingOverHTTP(80) || rtspServer->setUpTunnelingOverHTTP(8000) || rtspServer->setUpTunnelingOverHTTP(8080))
{
*env << "\n(We use port " << rtspServer->httpServerPortNum() << " for optional RTSP-over-HTTP tunneling.)\n";
}
else
{
*env << "\n(RTSP-over-HTTP tunneling is not available.)\n";
}
#endif
//printf("streamName:%s,Port:%d\n", streamName1, RTSPPORT);
NetCtlSrvPar ncsp;
memset(&ncsp, 0, sizeof(ncsp));
getDeviceID(ncsp.strDeviceID);
printf("device id:**%s**\n", ncsp.strDeviceID);
strcpy(ncsp.strStreamName1, streamName1);
strcpy(ncsp.strStreamName2, streamName2);
ncsp.vm1 = vm[0];
ncsp.vm2 = vm[1];
ncsp.nRtspPort = RTSPPORT;
ncsp.nMainFps = parse.fps1;
ncsp.nSubFps = parse.fps2;
//start net command server
startNetCtlServer(&ncsp);
printf("[##]start record...\n");
auto_record_file();
printf("[##]auto_record_file() called..\n");
//at last,start rtsp loop
env->taskScheduler().doEventLoop(); // does not return
return 0;
}
int main (void)
{
initI2C1 ();
initUsart ();
#if 0
/*
* +----------------+
* | Initialization |
* +----------------+
*/
accelgyro.initialize();
setClockSource(MPU6050_CLOCK_PLL_XGYRO/*0x01*/);
/*
* Excerpt from domcumentation : Upon power up, the MPU-60X0 clock source defaults to the internal oscillator.
* However, it is highly recommended that the device be configured to use one of the gyroscopes. Below is the code
* which does it:
*/
I2Cdev::writeBits(devAddr, MPU6050_RA_PWR_MGMT_1/*0x6B*/, MPU6050_PWR1_CLKSEL_BIT/*2*/, MPU6050_PWR1_CLKSEL_LENGTH/*3*/, source/*MPU6050_CLOCK_PLL_XGYRO 0x01*/);
setFullScaleGyroRange(MPU6050_GYRO_FS_250/*0x00*/);
/*
* 0x1b register is used to trigger gyroscope self-test and configure the gyroscopes’ full scale range. Below
* we set ful scale to be +/- 250 units (seconds?)
*/
I2Cdev::writeBits(devAddr, MPU6050_RA_GYRO_CONFIG/*0x1B*/, MPU6050_GCONFIG_FS_SEL_BIT/*4*/, MPU6050_GCONFIG_FS_SEL_LENGTH/*2*/, range/*0x00*/);
setFullScaleAccelRange(MPU6050_ACCEL_FS_2/*0x00*/);
/*
* Set accelerometer full scale to be +/- 2g.
*/
I2Cdev::writeBits(devAddr, MPU6050_RA_ACCEL_CONFIG/*0x1C*/, MPU6050_ACONFIG_AFS_SEL_BIT/*4*/, MPU6050_ACONFIG_AFS_SEL_LENGTH/*2*/, range/*0*/);
setSleepEnabled(false); // thanks to Jack Elston for pointing this one out!
/*
* By default MPU6050 is in sleep mode after powering up. Below we are waking it back on. This
* is done using the same register as in first line,
*/
I2Cdev::writeBit(devAddr, MPU6050_RA_PWR_MGMT_1/*0x6B*/, MPU6050_PWR1_SLEEP_BIT/*6*/, enabled/*false*/);
accelgyro.testConnection()
getDeviceID() == 0x34;
/*
* This register is used to verify the identity of the device. The contents of WHO_AM_I are
* the upper 6 bits of the MPU-60X0’s 7-bit I C address. The Power-On-Reset value of Bit6:Bit1 is 0b110100 == 0x34.
*/
I2Cdev::readBits(devAddr, MPU6050_RA_WHO_AM_I/*0x75*/, MPU6050_WHO_AM_I_BIT/*6*/, MPU6050_WHO_AM_I_LENGTH/*6*/, buffer);
return buffer[0];
/*
* +----------------+
* | Main loop |
* +----------------+
*/
int16_t ax, ay, az;
int16_t gx, gy, gz;
accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
/*
* In MPU-6000 and MPU-6050 Product Specification Rev 3.3 on pages 36 and 37 we read, that I²C reads and writes
* can be performed with single byte or multiple bytes. In single byte mode, we issue (after sending slave
* address ofcourse) a register address, and send or receive one byte of data. Multiple byte reads and writes, at the
* other hand consist of slave address, regiser address and multiple consecutive bytes od data. Slave puts or gets
* first byte from the register with the address we've just sent, and increases this addres by 1 after each byte.
*
* This is very useful in case of accelerometer and gyroscope because manufacturer has set up the apropriate registers
* cnsecutively, so one can read accel, internal temp and gyro data in one read command. Below is the code which does
* exactly this:
*/
I2Cdev::readBytes(devAddr, MPU6050_RA_ACCEL_XOUT_H/*0x3B*/, 14, buffer);
*ax = (((int16_t)buffer[0]) << 8) | buffer[1];
*ay = (((int16_t)buffer[2]) << 8) | buffer[3];
*az = (((int16_t)buffer[4]) << 8) | buffer[5];
*gx = (((int16_t)buffer[8]) << 8) | buffer[9];
*gy = (((int16_t)buffer[10]) << 8) | buffer[11];
*gz = (((int16_t)buffer[12]) << 8) | buffer[13];
#endif
// Configuration:
I2C_start (I2C1, MPU6050_ADDRESS_AD0_LOW, I2C_Direction_Transmitter); // start a transmission in Master transmitter mode
I2C_write_slow (I2C1, MPU6050_RA_PWR_MGMT_1); // Register address
I2C_write (I2C1, MPU6050_CLOCK_PLL_XGYRO); // Register value = 0x01. Which means, that DEVICE_RESET, SLEEP, CYCLE and TEMP_DIS are all 0.
I2C_stop (I2C1);
I2C_start (I2C1, MPU6050_ADDRESS_AD0_LOW, I2C_Direction_Transmitter);
I2C_write (I2C1, MPU6050_RA_GYRO_CONFIG);
I2C_write (I2C1, MPU6050_GYRO_FS_250); // All bits set to zero.
I2C_stop (I2C1);
I2C_start (I2C1, MPU6050_ADDRESS_AD0_LOW, I2C_Direction_Transmitter);
I2C_write (I2C1, MPU6050_RA_ACCEL_CONFIG);
I2C_write (I2C1, MPU6050_ACCEL_FS_2); // All bits set to zero.
I2C_stop (I2C1);
// Simple test if communication is working
I2C_start (I2C1, MPU6050_ADDRESS_AD0_LOW, I2C_Direction_Transmitter);
I2C_write (I2C1, MPU6050_RA_WHO_AM_I);
I2C_stop (I2C1);
I2C_start (I2C1, MPU6050_ADDRESS_AD0_LOW, I2C_Direction_Receiver);
uint8_t whoAmI = I2C_read_nack (I2C1); // read one byte and don't request another byte
I2C_stop (I2C1);
if (whoAmI == 0x34) {
usartSendString (USART1, "Accelerometer has been found!\r\n");
}
else {
usartSendString (USART1, "*NO* Accelerometer has been found!\r\n");
}
while (1) {
I2C_start (I2C1, MPU6050_ADDRESS_AD0_LOW, I2C_Direction_Transmitter);
I2C_write (I2C1, MPU6050_RA_ACCEL_XOUT_H);
I2C_stop (I2C1);
I2C_start (I2C1, MPU6050_ADDRESS_AD0_LOW, I2C_Direction_Receiver);
uint16_t ax = ((uint16_t)I2C_read_ack (I2C1) << 8) | I2C_read_ack (I2C1);
uint16_t ay = ((uint16_t)I2C_read_ack (I2C1) << 8) | I2C_read_ack (I2C1);
uint16_t az = ((uint16_t)I2C_read_ack (I2C1) << 8) | I2C_read_ack (I2C1);
uint16_t temp = ((uint16_t)I2C_read_ack (I2C1) << 8) | I2C_read_ack (I2C1);
uint16_t gx = ((uint16_t)I2C_read_ack (I2C1) << 8) | I2C_read_ack (I2C1);
uint16_t gy = ((uint16_t)I2C_read_ack (I2C1) << 8) | I2C_read_ack (I2C1);
uint16_t gz = ((uint16_t)I2C_read_ack (I2C1) << 8) | I2C_read_nack (I2C1);
I2C_stop (I2C1);
printf ("Accel : (%d, %d, %d), temperature : %d, gyro : (%d, %d, %d)\r\n", ax, ay, az, temp, gx, gy, gz);
}
}
void ofBaseSoundStream::applySoundStreamOriginInfo( ofSoundBuffer& buffer ) {
buffer.tickCount = getTickCount();
buffer.soundStreamDeviceID = getDeviceID();
}
DeviceTracker* DeviceTracker::getDevice(const Name& name) {
return getDevice(getDeviceID(name));
}
