// Dialog event handler
pascal OSStatus DialogWindowEventHandler (EventHandlerCallRef myHandler, EventRef event, void *userData)
{
OSStatus result = eventNotHandledErr;
HICommand command;
bool stopModalLoop = FALSE;
// Get the HI Command
GetEventParameter (event, kEventParamDirectObject, typeHICommand, NULL,
sizeof (HICommand), NULL, &command);
// Look for our 'YES ' and 'NO ' commands
switch (command.commandID)
{
case 'YES ':
HandleResponse(TRUE);
stopModalLoop = TRUE;
result = noErr;
break;
case 'NO ':
HandleResponse(FALSE);
stopModalLoop = TRUE;
result = noErr;
break;
}
// Stop the modal loop.
if (stopModalLoop)
{
QuitAppModalLoopForWindow((WindowRef)userData);
}
//Return how we handled the event.
return result;
}
void DoSetBit(struct lg_master *pLgMaster, struct parse_setbit_parms *pInp, uint32_t respondToWhom )
{
struct lg_xydata xydata;
struct parse_basic_resp *pResp=(struct parse_basic_resp *)pLgMaster->theResponseBuffer;
unsigned int bitID;
unsigned int bitValue;
memset((char *)&xydata, 0, sizeof(struct lg_xydata));
bitID = pInp->bit_id;
bitValue = pInp->bit_value;
pResp->hdr.status = RESPGOOD;
switch ( bitID )
{
case 1:
// unblank intensity (DIM?)
doLGSTOP(pLgMaster);
ioctl(pLgMaster->fd_laser, LGGETANGLE, &xydata);
doClearSearchBeam(pLgMaster);
xydata.ctrl_flags = 0;
if (bitValue == 0)
{
doWriteDevPoints(pLgMaster, (struct lg_xydata *)&xydata);
}
else if (bitValue == 1)
{
xydata.ctrl_flags = BEAMONISSET | LASERENBISSET;
doWriteDevPoints(pLgMaster, (struct lg_xydata *)&xydata);
}
else
pResp->hdr.status = RESPFAIL;
break;
case 2:
// search intensity (HIGH?)
doLGSTOP(pLgMaster);
ioctl(pLgMaster->fd_laser, LGGETANGLE, &xydata);
if (bitValue == 0)
{
doClearSearchBeam(pLgMaster);
xydata.ctrl_flags = 0;
doWriteDevPoints(pLgMaster, (struct lg_xydata *)&xydata);
}
else if (bitValue == 1)
{
doSetSearchBeam(pLgMaster);
xydata.ctrl_flags = BRIGHTBEAMISSET | BEAMONISSET | LASERENBISSET;
doWriteDevPoints(pLgMaster, (struct lg_xydata *)&xydata);
}
else {
pResp->hdr.status = RESPFAIL;
}
break;
default:
pResp->hdr.status = RESPFAIL;
break;
}
HandleResponse (pLgMaster, (sizeof(struct parse_basic_resp) -kCRCSize), respondToWhom);
return;
}
void CInputCodingTableBaiduPY::Process()
{
while (!m_bStop) //Make sure we don't exit the thread
{
AbortableWait(m_Event, -1); //Wait for work to appear
while (!m_bStop) //Process all queued work before going back to wait on the event
{
CSingleLock lock(m_CS);
if (m_work.empty())
break;
auto work = m_work.front();
m_work.pop_front();
lock.Leave();
std::string data;
XFILE::CCurlFile http;
std::string strUrl;
strUrl = StringUtils::Format(m_url.c_str(), work.c_str(), m_api_begin, m_api_end);
if (http.Get(strUrl, data))
HandleResponse(work, data);
}
}
}
int RDMResponder::Run(void) {
int16_t nLength;
//DMXReceiver::Run(nLength); //TODO Test!
const uint8_t *pDmxDataIn = DMXReceiver::Run(nLength);
if (m_IsEnableSubDevices && (nLength == -1)) {
if (m_IsSubDeviceActive) {
m_Responder.GetRDMSubDevices()->Stop();
m_IsSubDeviceActive = false;
}
} else if (pDmxDataIn != 0) {
m_Responder.GetRDMSubDevices()->SetData(pDmxDataIn, (uint16_t) nLength);
if (!m_IsSubDeviceActive) {
m_Responder.GetRDMSubDevices()->Start();
m_IsSubDeviceActive = true;
}
}
const uint8_t *pRdmDataIn = (uint8_t *) Rdm::Receive(0);
if (pRdmDataIn == NULL) {
return RDM_RESPONDER_NO_DATA;
}
#ifndef NDEBUG
RDMMessage::Print(pRdmDataIn);
#endif
if (pRdmDataIn[0] == E120_SC_RDM) {
const struct TRdmMessage *pRdmCommand = (struct TRdmMessage *) pRdmDataIn;
switch (pRdmCommand->command_class) {
case E120_DISCOVERY_COMMAND:
case E120_GET_COMMAND:
case E120_SET_COMMAND:
m_RDMHandler->HandleData(&pRdmDataIn[1], (uint8_t *)m_pRdmCommand);
return HandleResponse((uint8_t *)m_pRdmCommand);
break;
default:
#ifndef NDEBUG
printf("\t%s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);
#endif
return RDM_RESPONDER_INVALID_DATA_RECEIVED;
break;
}
}
#ifndef NDEBUG
printf("\t%s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);
#endif
return RDM_RESPONDER_DISCOVERY_RESPONSE;
}
bool
QuotaUsageRequestChild::Recv__delete__(const UsageRequestResponse& aResponse)
{
AssertIsOnOwningThread();
MOZ_ASSERT(mRequest);
switch (aResponse.type()) {
case UsageRequestResponse::Tnsresult:
HandleResponse(aResponse.get_nsresult());
break;
case UsageRequestResponse::TUsageResponse:
HandleResponse(aResponse.get_UsageResponse());
break;
default:
MOZ_CRASH("Unknown response type!");
}
return true;
}
void GetTargetsUsed(struct lg_master *pLgMaster, uint32_t respondToWhom)
{
struct parse_tgtsused_resp *pResp;
int i;
pResp = (struct parse_tgtsused_resp *)pLgMaster->theResponseBuffer;
memset((char *)pResp, 0, sizeof(struct parse_tgtsused_resp));
pResp->hdr.status = RESPGOOD;
pResp->tgtCount = pLgMaster->gBestTargetNumber;
for (i=0; i < pLgMaster->gBestTargetNumber; i++)
pResp->tgtNumber[i] = pLgMaster->gBestTargetArray[i];
HandleResponse(pLgMaster, (sizeof(struct parse_tgtsused_resp)-kCRCSize), respondToWhom);
return;
}
bool CBaseHttp::Http(HttpType type, HttpInfo *pInfo, bool bGetCookies/* = false*/)
{
LogObject;
assert(pInfo);
bool bRet = false;
try
{
CHttpResponse* pobjRes = NULL;
HandleParams(pInfo);
switch(type)
{
case ht_post:
{
m_httpObj.BeginPost(pInfo->strUrl.c_str());
const DWORD cbProceed = 1024;
do
{
// Place codes to report progress information to user.
} while (!(pobjRes = m_httpObj.Proceed (cbProceed)));
}
break;
case ht_get:
pobjRes = m_httpObj.RequestGetEx(pInfo->strUrl.c_str());
break;
default:
break;
}
std::auto_ptr<CHttpResponse> pAutoObj(pobjRes);
bRet = HandleResponse(pAutoObj.get(), pInfo, bGetCookies);
if(bRet)
HandleHttpData();
else
{
string str = "http没有应答";
//LogOutError(str.c_str());
}
}
catch (CHttpClient::Exception & e)
{
//LOG_ERROR("Exception error = %S", e.errmsg());
//LogOutError(e.errmsg());
m_httpObj.Cancel() ;
return false;
}
return bRet;
}
bool ReqTask::HandleMessage(Message *msg) {
Stanza *stanza = static_cast<Stanza *>(msg->pdata.get());
if(msg->message_id == 0
&& stanza->session_id() == req_data_->session_id()
&& stanza->stanza_type() == RES_STANZA_EVENT) {
return HandleResponse(msg);
}
if(msg->message_id == task_id_
&& stanza->session_id() == req_data_->session_id()) {
task_thread_->Post(this, task_id_, msg->pdata);
return true;
}
return false;
}
void RecvThread()
{
while(!done){
Command cmd;
if(cmdRecv->Dequeue(cmd)){
if((cmd.flags & CFResponse) != 0){
HandleResponse(cmd);
}else{
HandleCommand(cmd);
}
}
else{
SDL_Delay(100);
}
}
}
status_t
IMAPMailbox::StartWatchingMailbox(sem_id startedSem)
{
atomic_set(&fWatching, 1);
bool firstIDLE = true;
// refresh every 29 min
bigtime_t timeout = 1000 * 1000 * 60 * 29; // 29 min
status_t status;
while (true) {
int32 commandId = NextCommandId();
TRACE("IDLE ...\n");
status = SendCommand("IDLE", commandId);
if (firstIDLE) {
release_sem(startedSem);
firstIDLE = false;
}
if (status != B_OK)
break;
status = HandleResponse(commandId, timeout, false);
ProcessAfterQuacks(kIMAP4ClientTimeout);
if (atomic_get(&fWatching) == 0)
break;
if (status == B_TIMED_OUT) {
TRACE("Renew IDLE connection.\n");
status = SendRawCommand("DONE");
if (status != B_OK)
break;
// handle IDLE response and more
status = ProcessCommand("NOOP");
if (status != B_OK)
break;
else
continue;
}
if (status != B_OK)
break;
}
atomic_set(&fWatching, 0);
return status;
}
void RpcHandler::HandleData(const QSharedPointer<ISender> &from,
const QVariantList &container)
{
if(container.size() < 2) {
return;
}
QString type = container.at(0).toString();
if(type == Request::RequestType ||
type == Request::NotificationType)
{
HandleRequest(Request(_responder, from, container));
} else if(type == Response::ResponseType) {
HandleResponse(Response(from, container));
} else {
qDebug() << "Received an unknown Rpc type:" << type;
}
}
NS_IMETHODIMP
nsUrlClassifierHashCompleterRequest::OnStopRequest(nsIRequest *request,
nsISupports *context,
nsresult status)
{
LOG(("nsUrlClassifierHashCompleter::OnStopRequest [%p, status=%d]",
this, status));
nsCOMPtr<nsIObserverService> observerService =
do_GetService("@mozilla.org/observer-service;1");
if (observerService)
observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
if (mShuttingDown)
return NS_ERROR_ABORT;
if (NS_SUCCEEDED(status)) {
nsCOMPtr<nsIHttpChannel> channel = do_QueryInterface(request);
if (channel) {
PRBool success;
status = channel->GetRequestSucceeded(&success);
if (NS_SUCCEEDED(status) && !success) {
status = NS_ERROR_ABORT;
}
}
}
mCompleter->NoteServerResponse(NS_SUCCEEDED(status));
if (NS_SUCCEEDED(status))
status = HandleResponse();
// If we were rescheduled, don't bother notifying success or failure.
if (!mRescheduled) {
if (NS_SUCCEEDED(status))
NotifySuccess();
else
NotifyFailure(status);
}
mChannel = nsnull;
return NS_OK;
}
bool PushManagerTask::HandleMessage(Message *msg) {
Stanza *stanza = static_cast<Stanza *>(msg->pdata.get());
if(msg->message_id == 0
&& stanza->stanza_type() == RES_STANZA_EVENT){
return HandleResponse(msg);
} else if ((stanza->stanza_type() == RES_DISCONNECTED_EVENT_FAILURE
|| stanza->stanza_type() == RES_CONNECTED_EVENT)) {
HandleChangeConn(msg);
}
else if (stanza->stanza_type() == RES_RESUME_TASK_EVENT)
{
if (task_thread_ == NULL)
{
return false;
}
task_thread_->Post(this, task_id_, msg->pdata);
//task_thread_->PostDelayed(5000, this, stanza->session_id(), msg->pdata);
return true;
}
return false;
}
void DoChangeDisplayPeriod (struct lg_master *pLgMaster, struct parse_chngdisp_parms *pInp)
{
struct parse_chngdisp_resp *pResp;
uint32_t newPeriod;
pResp = (struct parse_chngdisp_resp *)pLgMaster->theResponseBuffer;
memset(pResp, 0, sizeof(struct parse_chngdisp_resp));
newPeriod = pInp->displayPeriod;
pResp->hdr.status = RESPGOOD;
syslog(LOG_NOTICE,"change display %d\n", newPeriod );
if ((newPeriod == -1) || ((newPeriod >= 50) && (newPeriod <= 150)))
pLgMaster->gPeriod = newPeriod;
else if (newPeriod == 0)
pLgMaster->gPeriod = KETIMER_75U;
else
pResp->hdr.status =RESPFAIL;
pResp->displayPeriod = pLgMaster->gPeriod;
HandleResponse(pLgMaster, (sizeof(struct parse_chngdisp_resp)-kCRCSize),
kRespondExtern);
return;
}
status_t
Protocol::ProcessCommand(Command& command, bigtime_t timeout)
{
BString commandString = command.CommandString();
if (commandString.IsEmpty())
return B_BAD_VALUE;
Handler* handler = dynamic_cast<Handler*>(&command);
if (handler != NULL && !AddHandler(*handler))
return B_NO_MEMORY;
int32 commandID = NextCommandID();
status_t status = SendCommand(commandID, commandString.String());
if (status == B_OK) {
fOngoingCommands[commandID] = &command;
status = HandleResponse(&command, timeout);
}
if (handler != NULL)
RemoveHandler(*handler);
return status;
}
void AnalyzeQuickChecks (struct lg_master *pLgMaster, uint32_t respondToWhom )
{
struct parse_qcmgr_resp *pResp;
uint32_t QCPlyCount = 0;
uint16_t numBadSensors = 0;
uint16_t numMissOnASensor;
int16_t i, j;
pResp = (struct parse_qcmgr_resp *)pLgMaster->theResponseBuffer;
memset(pResp, 0, sizeof(struct parse_qcmgr_resp));
for (i = kNumberOfFlexPoints-1; i >= 0; i--)
{
numMissOnASensor = 0;
for (j = kQCHistoryLength-1; j >= 0; j--)
{
if (gFailureArray[gCurrentQCSet][i][j])
numMissOnASensor++;
}
if (numMissOnASensor >= 1)
{
QCPlyCount += (1 << i);
numBadSensors++;
}
}
QCPlyCount &= QCPLYCOUNTMASK;
if (numBadSensors >= gQuickFailNumber)
{
pResp->hdr.status2 = RESPQCPLYFAIL;
pResp->hdr.qcply_byte1 = QCPlyCount >> 16;
pResp->currQCSet = htons(++gCurrentQCSet);
pResp->QCPlybyte23 = htons(QCPlyCount & QCPLYCOUNT23MASK);
HandleResponse(pLgMaster, (sizeof(struct parse_qcmgr_resp) - kCRCSize), respondToWhom);
}
void PerformAndSendQuickCheck(struct lg_master *pLgMaster, unsigned char *pAngles, uint32_t nTargets )
{
char localdata[ 1024 ];
uint32_t *ptrX, *ptrY;
struct parse_basic_resp *pResp;
uint16_t lostSensors;
int theResult;
uint16_t lostSum, i;
// Zero out area for response
pResp = (struct parse_basic_resp *)pLgMaster->theResponseBuffer;
memset(pResp, 0, sizeof(struct parse_basic_resp));
// initialize array to invalid angles
memset(localdata, 0xFF, sizeof(localdata));
memcpy(localdata, pAngles, (sizeof(int32_t) * 2 * nTargets));
lostSensors = 0;
lostSum = 0;
ptrX = (uint32_t *)localdata; ptrY = ptrX; ptrY++;
if (pLgMaster->gQCcount == -2)
theResult = 0;
else {
for (i = 0; i < nTargets; i++)
{
gCurrentQCSensor = i;
theResult = QuickCheckASensor(pLgMaster, *ptrX, *ptrY );
if ( theResult )
{
if ( theResult == kSuperFineNotFound )
{
lostSensors += (1U << i);
lostSum++;
theResult = 0;
}
else break;
}
ptrX++; ptrX++; ptrY++, ptrY++;
}
}
SlowDownAndStop(pLgMaster);
if (theResult)
pResp->hdr.status = RESPFAIL;
else
{
if (lostSum >= gQuickFailNumber)
{
pResp->hdr.status = RESPFAIL;
pResp->hdr.errtype = lostSensors;
}
else
{
pResp->hdr.status = RESPGOOD;
pResp->hdr.errtype = lostSensors;
}
}
HandleResponse(pLgMaster, (sizeof(struct parse_basic_resp)-kCRCSize), kRespondExtern);
return;
}
void
cIpmiConSmi::IfReadResponse()
{
unsigned char data[dIpmiMaxMsgLength];
ipmi_addr addr;
ipmi_recv recv;
recv.msg.data = data;
recv.msg.data_len = dIpmiMaxMsgLength;
recv.addr = (unsigned char *)&addr;
recv.addr_len = sizeof( ipmi_addr );
int rv = ioctl( m_fd, IPMICTL_RECEIVE_MSG_TRUNC, &recv );
if ( rv == -1 )
{
if ( errno == EMSGSIZE )
// The message was truncated, handle it as such.
data[0] = eIpmiCcRequestedDataLengthExceeded;
else
return;
}
// convert addr
cIpmiAddr rsp_addr;
rsp_addr.m_type = (tIpmiAddrType)addr.addr_type;
switch( rsp_addr.m_type )
{
case eIpmiAddrTypeSystemInterface:
{
ipmi_system_interface_addr *si = (ipmi_system_interface_addr *)&addr;
rsp_addr.m_channel = si->channel;
rsp_addr.m_lun = si->lun;
}
break;
case eIpmiAddrTypeIpmb:
case eIpmiAddrTypeIpmbBroadcast:
{
ipmi_ipmb_addr *ipmb = (ipmi_ipmb_addr *)&addr;
rsp_addr.m_channel = ipmb->channel;
rsp_addr.m_slave_addr = ipmb->slave_addr;
rsp_addr.m_lun = ipmb->lun;
}
break;
default:
assert( 0 );
return;
}
// convert msg
cIpmiMsg rsp;
rsp.m_netfn = (tIpmiNetfn)recv.msg.netfn;
rsp.m_cmd = (tIpmiCmd)recv.msg.cmd;
rsp.m_data_len = recv.msg.data_len;
if ( rsp.m_data_len )
memcpy( rsp.m_data, recv.msg.data, rsp.m_data_len );
int seq = (int)recv.msgid;
switch( recv.recv_type )
{
case IPMI_RESPONSE_RECV_TYPE:
HandleResponse( seq, rsp_addr, rsp );
break;
case IPMI_ASYNC_EVENT_RECV_TYPE:
HandleEvent( rsp_addr, rsp );
break;
case IPMI_CMD_RECV_TYPE:
// incomming command
stdlog << "SMI: incomming ipmi command "
<< IpmiCmdToString( rsp.m_netfn, rsp.m_cmd ) << ".\n";
break;
default:
break;
}
}
void RightOnFullReg(struct lg_master *pLgMaster,
struct parse_rightondofullreg_parms *param,
uint32_t respondToWhom)
{
struct parse_rightondofullreg_resp *pRespBuf;
struct lg_xydata theAngleBuffer[MAX_TARGETSOLD];
transform foundTransform;
double foundAngles[MAX_TARGETSOLD * 2];
double theCoordinateBuffer[MAX_TARGETSOLD * 3];
double theTransformTolerance;
double XExternalAngles[MAX_TARGETSOLD];
double YExternalAngles[MAX_TARGETSOLD];
double XfoundAngles[MAX_TARGETSOLD];
double YfoundAngles[MAX_TARGETSOLD];
int32_t RawGeomFlag;
int32_t tmpAngle;
int numberOfFoundTargets = 0;
int searchResult;
int useTarget[MAX_TARGETSOLD];
uint32_t respLen = (sizeof(struct parse_rightondofullreg_resp)-kCRCSize);
uint32_t rc = 0;
uint32_t lostSensors;
int16_t Xarr[MAX_TARGETSOLD];
int16_t Yarr[MAX_TARGETSOLD];
int16_t ptX, ptY, fndX, fndY;
unsigned short i, j;
unsigned char theResult;
SlowDownAndStop(pLgMaster);
pRespBuf = (struct parse_rightondofullreg_resp *)pLgMaster->theResponseBuffer;
memset(pRespBuf, 0, respLen);
theTransformTolerance = pLgMaster->gArgTol;
for (i = 0; i < MAX_TARGETSOLD; i++)
{
pLgMaster->foundTarget[i] = 0;
useTarget[i] = 1;
}
gWorstTolReg = 1.0;
RawGeomFlag = param->angleflag; // 1: raw binary angles, 2: geometric angles
if (RawGeomFlag == 1)
{
for (i = 0; i < MAX_TARGETSOLD; i++ )
{
theAngleBuffer[i].xdata = (int16_t)param->target_raw_angle[i].xangle & kMaxUnsigned;
theAngleBuffer[i].ydata = (int16_t)param->target_raw_angle[i].yangle & kMaxUnsigned;
}
} else if (RawGeomFlag == 2)
{
for ( i = 0; i < MAX_TARGETSOLD; i++ )
{
rc = ConvertExternalAnglesToBinary (pLgMaster,
param->target_geo_angle[i].Xangle,
param->target_geo_angle[i].Yangle,
&theAngleBuffer[i].xdata,
&theAngleBuffer[i].ydata);
}
}
// save target coordinates
for (i = 0; i < MAX_TARGETSOLD; i++)
{
theCoordinateBuffer[(3*i)+0] = param->target[i].Xtgt;
theCoordinateBuffer[(3*i)+1] = param->target[i].Ytgt;
theCoordinateBuffer[(3*i)+2] = param->target[i].Ztgt;
}
SaveFullRegCoordinates(MAX_TARGETSOLD, theCoordinateBuffer);
// check for duplicates
for (i = 0; i < MAX_TARGETSOLD; i++)
{
for (j = i; j < MAX_TARGETSOLD; j++)
{
if (i != j)
{
if ((gX[i]==gX[j]) && (gY[i]==gY[j]) && (gZ[i]==gZ[j]))
useTarget[j] = 0;
}
}
}
lostSensors = 0;
if (rc == 0)
{
for (i = 0; i < MAX_TARGETSOLD; i++)
{
j = gNumberOfSensorSearchAttempts;
gSearchCurrentSensor = i;
/*
* allow for a variable speed search, in needed
*/
pLgMaster->gCoarse2SearchStep = kCoarseSrchStpDef;
while (j--)
{
ptX = theAngleBuffer[i].xdata;
ptY = theAngleBuffer[i].ydata;
if (useTarget[i] == 1)
searchResult = SearchForASensor(pLgMaster, ptX, ptY, &fndX, &fndY);
else
{
searchResult = 99;
fndX = 0;
fndY = 0;
}
Xarr[i] = fndX;
Yarr[i] = fndY;
if (searchResult == kStopWasDone)
{
SearchBeamOff(pLgMaster);
return;
}
if (!searchResult)
break;
pLgMaster->gCoarse2SearchStep /= 2;
pLgMaster->gCoarse2Factor /= 2;
if (pLgMaster->gCoarse2SearchStep <= 1)
{
pLgMaster->gCoarse2SearchStep = 1;
pLgMaster->gCoarse2Factor = 1;
}
}
if (searchResult)
lostSensors += 1U << i;
else
{
pLgMaster->foundTarget[i] = 1;
ConvertBinaryToGeometricAngles(pLgMaster, fndX, fndY, &(XfoundAngles[i]), &(YfoundAngles[i]));
ConvertBinaryToExternalAngles(pLgMaster, fndX, fndY, &(XExternalAngles[i]), &(YExternalAngles[i]));
}
}
for (i = 0; i < MAX_TARGETSOLD; i++)
{
foundAngles[2*i+0] = XfoundAngles[i];
foundAngles[2*i+1] = YfoundAngles[i];
if (pLgMaster->foundTarget[i] == 1)
numberOfFoundTargets ++;
}
if (numberOfFoundTargets >= 4)
{
theResult = FindTransformMatrix(pLgMaster, MAX_TARGETSOLD,
gDeltaMirror, theTransformTolerance, foundAngles,
(double *)&foundTransform );
}
}
else
theResult = 0;
if (theResult)
{
pRespBuf->hdr.status3 = RESPGOOD;
pRespBuf->hdr.numTransforms = (unsigned char)(0xFF & GnOfTrans);
if (gTargetDrift)
InitDrift(Xarr, Yarr);
memset(pRespBuf->transform, 0, OLDTRANSFORMLEN);
TransformIntoArray(&foundTransform, (double *)&pRespBuf->transform);
for (i = 0; i < MAX_TARGETSOLD; i++)
{
tmpAngle = Xarr[i];
memcpy(&pRespBuf->anglepairs[8*i+0], &tmpAngle, sizeof(int32_t));
tmpAngle = Yarr[i];
memcpy(&pRespBuf->anglepairs[8*i+4], &tmpAngle, sizeof(int32_t));
}
for (i = 0; i < MAX_TARGETSOLD; i++)
{
pRespBuf->target_geo_angle[i].Xangle = XExternalAngles[i];
pRespBuf->target_geo_angle[i].Yangle = YExternalAngles[i];
}
HandleResponse (pLgMaster, respLen, respondToWhom );
}
else
{
pRespBuf->hdr.status3 = RESPFAIL;
pRespBuf->hdr.hdr |= htonl(lostSensors);
HandleResponse (pLgMaster, sizeof(pRespBuf->hdr.hdr), respondToWhom );
return;
}
return;
}
void PerformThresholdQuickCheck(struct lg_master *pLgMaster, char *data, uint32_t nTargets, uint32_t nThresh)
{
struct parse_basic_resp *pResp=(struct parse_basic_resp *)pLgMaster->theResponseBuffer;
uint32_t *ptrX, *ptrY;
uint32_t lostSensors;
int theResult;
unsigned short lostSum, i;
char localdata[1024];
// Initialize response buffer area
memset(pResp, 0, sizeof(struct parse_basic_resp));
// initialize array to invalid angles
memset(localdata, 0xFF, sizeof(localdata));
// Get data from caller
memcpy(localdata, data, sizeof(int32_t) * 2 * nTargets);
lostSensors = 0;
lostSum = 0;
ptrX = (uint32_t *)localdata;
ptrY = ptrX;
ptrY++;
if (pLgMaster->gQCcount == -2)
theResult = 0;
else
{
for (i=0; i < nTargets; i++)
{
gCurrentQCSensor = i;
theResult = QuickCheckASensor (pLgMaster, *ptrX, *ptrY );
if (theResult)
{
if ( theResult == kSuperFineNotFound )
{
lostSensors += (1U << i);
lostSum++;
theResult = 0;
*ptrX = 0xFFFFFFFF;
*ptrY = 0xFFFFFFFF;
if ( lostSum >= nThresh ) {
break;
}
}
else break;
}
ptrX++;
ptrX++;
ptrY++,
ptrY++;
}
}
SlowDownAndStop(pLgMaster);
if (theResult)
pResp->hdr.status = RESPFAIL;
else
{
if ( lostSum >= gQuickFailNumber )
{
pResp->hdr.status = RESPFAIL;
pResp->hdr.hdr |= htonl(lostSensors);
}
else
{
pResp->hdr.status = RESPGOOD;
pResp->hdr.hdr |= htonl(lostSensors);
}
}
HandleResponse ( pLgMaster, (sizeof(struct parse_basic_resp)-kCRCSize), kRespondExtern );
return;
}
void FlexCalculateTransform(struct lg_master *pLgMaster, struct parse_flexcalxfrm_parms *pInp, uint32_t respondToWhom)
{
struct k_xyz_double theCoordinateBuffer[MAX_TARGETSFLEX];
struct k_xy_double foundAngles[MAX_TARGETSFLEX];
struct k_xy_anglepair XYarr[MAX_TARGETSFLEX];
transform foundTransform;
struct parse_flexcalxfrm_resp *pResp;
double Xgeo, Ygeo;
double theTransformTolerance;
double angX, angY;
uint32_t nTargets;
int32_t intColinear;
int32_t intPlanar;
int16_t Xbin, Ybin;
uint16_t i, j;
uint8_t theResult;
pResp = (struct parse_flexcalxfrm_resp *)pLgMaster->theResponseBuffer;
memset(pLgMaster->theResponseBuffer, 0, sizeof(struct parse_flexcalxfrm_resp));
// Get and validate num_targets from sender, no sense in continuing if not correct!
nTargets = pInp->num_targets;
if ((nTargets < 4) || (nTargets > kNumberOfFlexPoints))
{
pResp->hdr.status = RESPFAIL;
HandleResponse(pLgMaster, (sizeof(struct parse_basic_resp)-kCRCSize), respondToWhom);
return;
}
// Initialize variables & buffers to be used for command
memset((char *)&theCoordinateBuffer, 0, sizeof(theCoordinateBuffer));
memset((char *)&foundAngles, 0, sizeof(foundAngles));
memset((char *)&XYarr, 0, sizeof(XYarr));
memset((char *)&foundTransform, 0, sizeof(foundTransform));
intColinear = 0;
intPlanar = 0;
theTransformTolerance = pLgMaster->gArgTol;
// Get the target-angle pairs
for (i=0; i < nTargets; i++)
{
pLgMaster->gColinear[i] = 0;
pLgMaster->foundTarget[i] = 1;
angX = pInp->tgtAngle[i].Xangle;
angY = pInp->tgtAngle[i].Yangle;
ConvertExternalAnglesToMirror(angX, angY, &Xgeo, &Ygeo);
ConvertMirrorToGeometricAngles(&Xgeo, &Ygeo);
foundAngles[i].Xangle = Xgeo;
foundAngles[i].Yangle = Ygeo;
ConvertExternalAnglesToBinary(pLgMaster, angX, angY, &Xbin, &Ybin);
XYarr[i].xangle = Xbin;
XYarr[i].yangle = Ybin;
}
for (i=0; i < nTargets; i++)
{
theCoordinateBuffer[i].Xtgt = pInp->target[i].Xtgt;
theCoordinateBuffer[i].Ytgt = pInp->target[i].Ytgt;
theCoordinateBuffer[i].Ztgt = pInp->target[i].Ztgt;
}
SaveFullRegCoordinates(nTargets, (double *)&theCoordinateBuffer);
//
// if gHeaderSpecialByte is NOT 0x40,
// then reject duplicate targets
//
if (!(pLgMaster->gHeaderSpecialByte & 0x40))
{
for (i = 0; i < nTargets; i++)
{
for (j = i; j < nTargets; j++)
{
if (i != j)
{
if ((gX[i]==gX[j]) && (gY[i]==gY[j]) && (gZ[i]==gZ[j]))
pLgMaster->foundTarget[j] = 0;
}
}
}
}
theResult = FindTransformMatrix(pLgMaster, nTargets, gDeltaMirror, theTransformTolerance,
(double *)&foundAngles, (double *)&foundTransform);
/* desperate attempt to get something */
if ((gSaved == 0) && gForceTransform)
{
theResult = FindTransformMatrix(pLgMaster, nTargets, gDeltaMirror,
0.00001, (double *)&foundAngles, (double *)&foundTransform);
GnOfTrans = 0;
}
for (i = 0; i < nTargets ; i++)
{
if (pLgMaster->gColinear[i] > 0)
intColinear = intColinear | (1 << i);
}
if (theResult)
pResp->hdr.status = RESPGOOD;
else
pResp->hdr.status = RESPFLEXFAIL;
TransformIntoArray(&foundTransform, (double *)&pResp->transform[0]);
memset((char *)&pResp->anglepairs[0], 0xFF, ANGLEPAIRSLENFLEX);
memcpy((char *)&pResp->anglepairs[0], (char *)&XYarr[0], sizeof(XYarr));
pResp->num_xfrms = GnOfTrans;
pResp->num_tgts = nTargets;
pResp->colineartgt = intColinear;
pResp->coplanartgts = intPlanar;
HandleResponse(pLgMaster, (sizeof(struct parse_flexcalxfrm_resp)-kCRCSize), respondToWhom);
return;
}
void ConnectionManager::slotReadyRead(void)
{
HandleResponse();
}
