void ESP8266proClient::onDataReceive(uint8_t connectionId, char* buffer, int length, DataReceiveAction action)
{
if (action == eDRA_Begin) return; // Nothing here
if (dataCallback != NULL)
dataCallback(this, buffer, length, action == eDRA_End);
//Serial.print(buffer);
}
void MyGateway::serial(const char *fmt, ... ) {
va_list args;
va_start (args, fmt );
vsnprintf_P(serialBuffer, MAX_SEND_LENGTH, fmt, args);
va_end (args);
Serial.print(serialBuffer);
if (useWriteCallback) {
// We have a registered write callback (probably Ethernet)
dataCallback(serialBuffer);
}
}
kj::Own<TlsPskAdaptor> TlsPskAdaptorFactory::addServerTlsAdaptor(kj::Own<kj::AsyncIoStream>&& stream) {
auto adaptor = kj::heap<TlsPskAdaptor>(kj::mv(stream));
adaptor->setChannel(kj::heap<Botan::TLS::Server>(adaptor->outputFunction(),
adaptor->dataCallback(),
adaptor->alertCallback(),
adaptor->handshakeCallback(),
equipment->sessionManager,
equipment->credentialsManager,
equipment->policy,
equipment->rng));
return kj::mv(adaptor);
}
void DTCGateway::serial(const char *fmt, ...)
{
//va_list args;
//va_start(args, fmt);
//vsnprintf_P(serialBuffer, MAX_SEND_LENGTH, fmt, args);
//va_end(args);
//Serial.print(serialBuffer);
if (dataCallback != NULL) // we have a registered write callback (probably Ethernet)
dataCallback(serialBuffer);
}
status_t BnCameraClient::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case NOTIFY_CALLBACK: {
ALOGV("NOTIFY_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
int32_t msgType = data.readInt32();
int32_t ext1 = data.readInt32();
int32_t ext2 = 0;
if ((msgType == CAMERA_MSG_PREVIEW_FRAME) && (ext1 == CAMERA_FRAME_DATA_FD)) {
ext2 = data.readFileDescriptor();
ALOGD("onTransact: CAMERA_MSG_PREVIEW_FRAME fd = %d", ext2);
} else {
ext2 = data.readInt32();
}
notifyCallback(msgType, ext1, ext2);
return NO_ERROR;
} break;
case DATA_CALLBACK: {
ALOGV("DATA_CALLBACK");
CHECK_INTERFACE(ICameraClient, data, reply);
int32_t msgType = data.readInt32();
sp<IMemory> imageData = interface_cast<IMemory>(data.readStrongBinder());
camera_frame_metadata_t *metadata = NULL;
if (data.dataAvail() > 0) {
metadata = new camera_frame_metadata_t;
metadata->number_of_faces = data.readInt32();
metadata->faces = (camera_face_t *) data.readInplace(
sizeof(camera_face_t) * metadata->number_of_faces);
}
dataCallback(msgType, imageData, metadata);
if (metadata) delete metadata;
return NO_ERROR;
} break;
case DATA_CALLBACK_TIMESTAMP: {
ALOGV("DATA_CALLBACK_TIMESTAMP");
CHECK_INTERFACE(ICameraClient, data, reply);
nsecs_t timestamp = data.readInt64();
int32_t msgType = data.readInt32();
sp<IMemory> imageData = interface_cast<IMemory>(data.readStrongBinder());
dataCallbackTimestamp(timestamp, msgType, imageData);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
void
CertificateFetcherFromNetwork::doFetch(const shared_ptr<CertificateRequest>& certRequest,
const shared_ptr<ValidationState>& state,
const ValidationContinuation& continueValidation)
{
m_face.expressInterest(certRequest->interest,
[=] (const Interest& interest, const Data& data) {
dataCallback(data, certRequest, state, continueValidation);
},
[=] (const Interest& interest, const lp::Nack& nack) {
nackCallback(nack, certRequest, state, continueValidation);
},
[=] (const Interest& interest) {
timeoutCallback(certRequest, state, continueValidation);
});
}
void mythen::acquisitionTask()
{
size_t nread, nread_expect;
size_t nwrite;
int eventStatus;
int imageMode;
epicsInt32 acquire, eomReason;
double acquireTime;
asynStatus status = asynSuccess;
int dataOK;
static const char *functionName = "acquisitionTask";
this->lock();
while (1) {
/* Is acquisition active? */
getIntegerParam(ADAcquire, &acquire);
/* If we are not acquiring then wait for a semaphore that is given when acquisition is started */
if (!acquire || !acquiring_) {
setIntegerParam(ADStatus, ADStatusIdle);
callParamCallbacks();
/* Release the lock while we wait for an event that says acquire has started, then lock again */
asynPrint(this->pasynUserSelf, ASYN_TRACE_FLOW,
"%s:%s: waiting for acquire to start\n", driverName, functionName);
this->unlock();
eventStatus = epicsEventWait(this->startEventId_);
// setStringParam(ADStatusMessage, "Acquiring data");
// setIntegerParam(ADNumImagesCounter, 0);
// getIntegerParam(ADAcquire, &acquire);
//printf("Read Mode: %d\tnModules: %d\t chanperline: %d\n", readmode_,this->nmodules,chanperline_);
if (readmode_==0) //Raw Mode
nread_expect = sizeof(epicsInt32)*this->nmodules*(1280/chanperline_);
else
nread_expect = sizeof(epicsInt32)*this->nmodules*(1280);
dataOK = 1;
eventStatus = getStatus();
setIntegerParam(ADStatus, eventStatus);
if (eventStatus!=ADStatusError) {
getDoubleParam(ADAcquireTime,&acquireTime);
// printf("Acquisition start - expect %d\n",nread_expect);
// Work on the cases of what are you getting from getstatus
do {
nread=0;
if (readmode_==0)
strcpy(outString_, "-readoutraw");
else
strcpy(outString_, "-readout");
status = pasynOctetSyncIO->writeRead(pasynUserMeter_, outString_, strlen(outString_), (char *)detArray_,
nread_expect, M1K_TIMEOUT+acquireTime, &nwrite, &nread, &eomReason); //Timeout is M1K_TIMEOUT + AcquireTime
//printf("nread_expected = %d\tnread = %d\n", nread_expect,nread);
if(nread == nread_expect) {
this->lock();
dataOK = dataCallback(detArray_);
this->unlock();
if (!dataOK) {
eventStatus = getStatus();
setIntegerParam(ADStatus, eventStatus);
}
}
else {
eventStatus = getStatus();
setIntegerParam(ADStatus, eventStatus);
//printf("Data not size expected ADStatus: %d\n",eventStatus);
}
if(status != asynSuccess) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: error using readout command status=%d, nRead=%d, eomReason=%d\n",
driverName, functionName, status, (int)nread, eomReason);
}
}
while (status == asynSuccess && (eventStatus==ADStatusAcquire||eventStatus==ADStatusReadout) && acquiring_);
}
this->lock();
}
if (eventStatus!=ADStatusError ) {
printf("Acquisition finish\n");
getIntegerParam(ADImageMode, &imageMode);
if (imageMode == ADImageSingle || imageMode == ADImageMultiple) {
printf("ADAcquire Callback\n");
acquiring_ = 0;
setIntegerParam(ADAcquire, 0);
callParamCallbacks();
}
}
else {
//Abort read
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: error timed out waiting for data\n",
driverName, functionName);
acquiring_ = 0;
setAcquire(0);
setIntegerParam(ADAcquire, 0);
callParamCallbacks();
}
}
}
