void Drive::escape(){
RunR(-1000);
RunL(-1000);
delay(3000);
RunR(1000);
RunL(1000);
delay(10000);
RunR(-1000);
RunL(-1000);
delay(3000);
RunR(1000);
RunL(-1000);
delay(1000);
RunR(1000);
RunL(1000);
delay(2000);
RunR(-1000);
RunL(1000);
delay(1000);
RunR(1000);
RunL(1000);
delay(5000);
RunR(0);
RunL(0);
}
void CPropertyWatch::ConstructL(TUsbMsDriveState_Subkey aSubkey)
{
User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, aSubkey));
CActiveScheduler::Add(this);
// initial subscription and process current property value
RunL();
}
// ---------------------------------------------------------
// CUniSmilList::CreateSmilAttachmentL
//
// Create SMIL from DOM
// ---------------------------------------------------------
//
EXPORT_C void CUniSmilList::CreateSmilAttachmentL(
MUniSmilComposeObserver& aObserver,
CMsvStore& aEditStore,
CMDXMLDocument* aDom )
{
iDom = aDom;
iObserver = &aObserver;
//iSmilAttaId = KMsvNullIndexEntryId;
//iSmilAttaFullpath.Zero();
iManager = &( aEditStore.AttachmentManagerL() );
CMsvAttachment* attachment = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );
CleanupStack::PushL( attachment );
//TODO: Set size(?) & complete flag(?)
//attachment->SetSize()
//attachment->SetComplete( EFalse );
iEditFile = new ( ELeave ) RFile;
CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();
iManager->CreateAttachmentL( KPresentationFileName, *iEditFile, attachment, wait->iStatus );
wait->Start();
//manager.AddAttachmentL( aPath, attachment, iStatus );
CleanupStack::PopAndDestroy( wait );
CleanupStack::Pop( attachment );
iAttachment = attachment;
//Do self complete to trigger runL
RunL();
}
// -----------------------------------------------------------------------------
// ConstructL()
// -----------------------------------------------------------------------------
//
void CCCEPluginManager::ConstructL()
{
#if 0
// capabilities still todo here
static _LIT_SECURITY_POLICY_PASS( KAllowAllPolicy );
static _LIT_SECURITY_POLICY_C2( KICMPolicy,
ECapabilityNetworkControl,
ECapabilityWriteDeviceData);
// define first property to be integer type
TInt err = RProperty::Define( KPSUidICMIncomingCall,
KPropertyKeyICMPluginUID, RProperty::EInt, KAllowAllPolicy, KICMPolicy );
#else
// define first property to be integer type
TInt err = RProperty::Define( KPSUidICMIncomingCall,
KPropertyKeyICMPluginUID, RProperty::EInt );
#endif
if ( err != KErrAlreadyExists )
{
User::LeaveIfError( err );
}
User::LeaveIfError( iProperty.Attach( KPSUidICMIncomingCall,
KPropertyKeyICMPluginUID ) );
CActiveScheduler::Add(this);
RunL();
iIdle = CIdle::NewL( EPriorityIdle );
iIdle->Start( TCallBack(DoAfterBoot,this) );
iSPSettings = CCCESPSettingsHandler::NewL( *this );
}
/**
The 2nd phase constructor. Attaches to the property, completes the async
request to cause the RunL method to be called for the first time and check
if there has already been an update to the property.
@leave If a error happens, it leaves with one of the system error codes.
*/
void CLbsInternalPosStatusWatcher::ConstructL()
{
// Get the CategoryUid from the cenrep file owned by LbsRoot.
TInt category;
CRepository* rep = CRepository::NewLC(KLbsCenRepUid);
// attach to the property
if (iType == ELbsPositioningStatusMO)
{
// Mobile Originated Status P&S Property
User::LeaveIfError(rep->Get(KMoPositioningStatusAPIKey, category));
TSecureId propOwnerSecureId(category);
User::LeaveIfError(iProperty.Attach(propOwnerSecureId, KLbsMoPositioningStatusKey, EOwnerThread));
}
else if (iType == ELbsPositioningStatusNI)
{
// Network Initiated Status P&S Property
User::LeaveIfError(rep->Get(KNiPositioningStatusAPIKey, category));
TSecureId propOwnerSecureId(category);
User::LeaveIfError(iProperty.Attach(propOwnerSecureId, KLbsNiPositioningStatusKey, EOwnerThread));
}
else
{
// Any other value indicates a programming error
User::Leave(KErrArgument);
}
CleanupStack::PopAndDestroy(rep);
CActiveScheduler::Add(this);
// initial subscription and process current property value
RunL();
}
void TFail::Test(const THeapFail& aHeap,const TContext* aContext)
{
TInt ii;
TInt errCode;
for (ii=1;;++ii)
{
if (aContext)
{
TRAP(errCode, aContext->OpenDbL());
if(errCode != KErrNone)
return;
}
aHeap.Fail(ii);
aHeap.Mark();
TRAPD(r,RunL());
aHeap.Reset();
if (r==KErrNone)
break;
test(r==KErrNoMemory);
if (aContext)
TheDatabase.Close();
aHeap.Check();
}
End();
if (aContext)
TheDatabase.Close();
aHeap.Check();
}
void CTestCaseTimerWatch::ConstructL()
{
iTimer.After(iStatus, 61000000); // 61s timer
CActiveScheduler::Add(this);
// initial subscription and process current property value
RunL();
}
void CPropertyObserver::ConstructL()
{
RThread t;
RDebug::Print(_L("Property init, thread %d"),t.Id().Id());
User::LeaveIfError( iProperty.Attach( iUid, iKey ) );
CActiveScheduler::Add(this);
// initial subscription and process current property value
RunL();
}
// -----------------------------------------------------------------------------
// CSensorDataCompensatorInitializer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSensorDataCompensatorInitializer::ConstructL()
{
FUNC_LOG;
CActiveScheduler::Add( this );
User::LeaveIfError( iProperty.Attach( KPSUidStartup,
KPSIdlePhase1Ok ) );
RunL(); // Start listening
}
// ---------------------------------------------------------------------------
// CAknMemorySelectionDialogMultiDrive::RunDlgLD
// A wrapper for RunL.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CAknMemorySelectionDialogMultiDrive::RunDlgLD(
TDriveNumber& aSelectedDrive,
TInt aResourceId,
TDes* aRootPath,
TDes* aDefaultFolder )
{
return RunL(
aResourceId, aSelectedDrive, aRootPath, aDefaultFolder, KNullDesC );
}
void CRequestSessionWatcher::ConstructL()
{
__MSFNLOG
User::LeaveIfError(iProperty.Define(KUidUsbManCategory, KUsbRequestSessionProperty, RProperty::EInt));
User::LeaveIfError(iProperty.Attach(KUidUsbManCategory, KUsbRequestSessionProperty));
CActiveScheduler::Add(this);
// initial subscription and process current property value
RunL();
}
void CSender::StartPassive(TInt aPort, TRequestStatus* aStatus, RConnection& aConn, TAction aAction)
{
iAction = aAction;
iSavedStatus = aStatus;
if (!iSavedStatus) User::Invariant();
// Open a sock for listening on a connection
TInt nRet = iListener.Open(iSS, KAfInet, KSockStream, KProtocolInetTcp, aConn);
if (nRet != KErrNone)
{
iLogger.Log(_L("Failed to open socket on Iap %d on Network %d, : return value = %d"),
nRet, iPref.IapId(), iPref.NetId());
User::Leave(nRet);
}
// bind the socket
iLocal.SetPort(aPort);
nRet = iListener.Bind(iLocal);
if (nRet != KErrNone)
{
iLogger.Log(_L("Failed to bind socketon Iap %d on Network %d, : return value = %d"),
nRet, iPref.IapId(), iPref.NetId());
User::Leave(nRet);
}
// listen on the socket
nRet = iListener.Listen(1);
if (nRet != KErrNone)
{
iLogger.Log(_L("Failed to listen on socketon Iap %d on Network %d, : return value = %d"),
nRet, iPref.IapId(), iPref.NetId());
User::Leave(nRet);
}
// open a blank socket
nRet = iSock.Open(iSS);
if (nRet != KErrNone)
{
iLogger.Log(_L("Failed to open Receiver socketon Iap %d on Network %d, : return value = %d"),
nRet, iPref.IapId(), iPref.NetId());
User::Leave(nRet);
}
// Mark the saved state as pending
if (iSavedStatus)
*iSavedStatus = KRequestPending;
iLogger.Log(_L("Trying to Accept on Iap %d on Network %d"), iPref.IapId(), iPref.NetId());
iListener.Accept(iSock, iStatus);
// Wait for async incoming connction
iState = EConnecting;
//SetActive();
User::WaitForRequest(iStatus);
RunL();
}
void CTestCasePropertyWatch::ConstructL()
{
//User::LeaveIfError(iProperty.Attach(KMyHWRMTestPpoperty,EHWRMNextTestToRun));
User::LeaveIfError(iProperty.Attach(KMyHWRMTestPpoperty,EHWRMStepResult));
//iTimer.After(iStatus, 61000000); // 61s timer
CActiveScheduler::Add(this);
// initial subscription and process current property value
RunL();
}
void CCamcTestClient_9::MvruoPrepareComplete( TInt aError )
{
if (aError)
{
SomethingInActiveObjectIsLeaving(aError);
}
else
{
iPrepareReady = ETrue;
RunL();
}
}
void CCamcTestClient_3::MvruoRecordComplete( TInt aError )
{
if (aError)
{
SomethingInActiveObjectIsLeaving(aError);
}
else
{
iRecordingReady = ETrue;
RunL(); // RunL is trapped, cannot actually leave.
}
}
void CCamcTestClient_visualcheck::MvruoPrepareComplete( TInt aError )
{
if (aError)
{
SomethingInActiveObjectIsLeaving(aError);
}
else
{
iPrepareReady = ETrue;
RunL(); // RunL is trapped, cannot actually leave.
}
}
// -----------------------------------------------------------------------------
// CHWRMExtendedLightStatusObserver::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHWRMExtendedLightStatusObserver::ConstructL()
{
COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightStatusObserver::ConstructL()" ));
User::LeaveIfError( InitializeStatusArray( iLastStatusValue ) );
User::LeaveIfError( InitializeStatusArray( iStatusUnknownList ) );
User::LeaveIfError(iProperty.Attach(KPSUidHWResourceNotification, KHWRMLightStatus));
// Call RunL to order notification and do the initial notifying of the client
RunL();
COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightStatusObserver::ConstructL - return" ) );
}
void CUnifiedCertStore::DoCancel()
{
// If the current state is the last state involved in handling a request, we
// check to see if we have already been completed - in this case we can
// simply complete the client with iStatus (this may be KErrNone). If we
// have not we cancel the outstanding request and pass the resulting iStatus
// back to the client - this too may indicate a successful completion if the
// cancel arrived after the request was executed.
//
// For more complex cases, where there are more states to go through before
// we finish servicing the client request, we cancel any outstanding
// request, and return KErrCancel to the client.
switch (iState)
{
case EInitializeFinished:
case ERetrieve:
case EGetCert:
case EApplications:
case EIsApplicable:
case ETrusted:
case ERetrieveData:
case ERemove:
case ESetApplicability:
case ESetTrust:
if (iStatus == KRequestPending)
{
// Attempt to cancel outstanding request and pass status back to
// client
CancelOutstandingRequest();
Complete(iStatus.Int());
}
else
{
// We've already been completed - call RunL() to process results
// and complete client
TRAPD(err, RunL());
if (err != KErrNone)
{
RunError(err);
}
}
break;
default:
CancelOutstandingRequest();
Complete(KErrCancel);
break;
}
}
void CSymTtkImageDecoder::decode(const char* filename,
TtkBitmapInterface*& bitmap, TtkImage& image)
{
_LIT8(KGifMimeType, "image/gif");
CActiveScheduler::Add(this);
TPtrC8 ptr(reinterpret_cast<const unsigned char*>(filename));
HBufC* buffer = CnvUtfConverter::ConvertToUnicodeFromUtf8L(ptr);
CleanupStack::PushL(buffer);
iDecoder = CImageDecoder::FileNewL(CCoeEnv::Static()->FsSession(),
*buffer, KGifMimeType);
CleanupStack::PopAndDestroy(buffer);
iTimer.CreateLocal();
iImage = ℑ
RunL();
}
TInt E32Main()
{
__UHEAP_MARK;
CTrapCleanup* cleanup=CTrapCleanup::New();
TInt r=KErrNoMemory;
if (cleanup)
{
TRAP(r,RunL());
delete cleanup;
}
__UHEAP_MARKEND;
return r;
}
TInt E32Main()
{
__UHEAP_MARK;
CTrapCleanup* cleanup=CTrapCleanup::New();
TInt r=KErrNoMemory;
if (cleanup)
{
TRAP(r,RunL());
delete cleanup;
}
__UHEAP_MARKEND;
return r;
} //lint -e714 Suppress 'not referenced'
void CCamcTestClient_visualcheck::MvruoRecordComplete( TInt aError )
{
#ifdef _DEBUG
RDebug::Print(_L("CamCTestClient VisualCheck:Record Complete"));
#endif
if ((aError) && (aError != KErrCompletion))
{
SomethingInActiveObjectIsLeaving(aError);
}
else
{
iRecordingReady = ETrue;
RunL(); // RunL is trapped, cannot actually leave.
}
}
// -----------------------------------------------------------------------------
// CHttpFilterConnHandlerObserver::ConstructL
// ------------------------------------------------------------------------------
void CHttpFilterConnHandlerObserver::ConstructL()
{
// Note: the CHttpFilterConnHandlerObserver object s.b. created after connection is set for particular bearer
User::LeaveIfError(iGPRSStateProperty.Attach(KUidSystemCategory, KPSUidGprsStatusValue));
User::LeaveIfError(iWCDMAStateProperty.Attach(KUidSystemCategory, KPSUidWcdmaStatusValue));
CActiveScheduler::Add(this);
iSuspendTimer = CPeriodic::NewL(CActive::EPriorityLow );
if( !iTelServer.Handle() )
{
// this initialization needed for identifying 3G networks
//
User::LeaveIfError( iTelServer.Connect() );
User::LeaveIfError( iTelServer.LoadPhoneModule( KMmTsyModuleName ) );
TInt numPhones;
User::LeaveIfError( iTelServer.EnumeratePhones( numPhones ) );
if( numPhones <= 0 )
{
// Huh???
User::Leave( KErrCorrupt );
}
RTelServer::TPhoneInfo phoneInfo;
User::LeaveIfError( iTelServer.GetPhoneInfo( 0, phoneInfo ) );
User::LeaveIfError( iMobilePhone.Open( iTelServer, phoneInfo.iName ) );
User::LeaveIfError( iMobilePhone.Initialise() );
RMobilePhone::TMobilePhoneNetworkMode networkMode;
User::LeaveIfError( iMobilePhone.GetCurrentMode( networkMode ) );
if( networkMode == RMobilePhone::ENetworkModeWcdma ||
networkMode == RMobilePhone::ENetworkModeTdcdma )
{ // 3G/WCDMA mode
iUidValue = KPSUidWcdmaStatusValue;
}
else if ( networkMode == RMobilePhone::ENetworkModeGsm ||
networkMode == RMobilePhone::ENetworkModeUnknown ||
networkMode == RMobilePhone::ENetworkModeUnregistered )
{
iUidValue = KPSUidGprsStatusValue;
}
}
// initial subscription and process current property value
RunL();
}
void Drive::initiate(double Lat, double Lng){
//Serial.println("Motor Initiating");
escR.attach(RightMotor);
escL.attach(LeftMotor);
delay(4000);
RunR(RGain*200);
RunL(LGain*200);
delay(4000);
//Serial.println("Ready to Drive");
goalLat = Lat;
goalLng = Lng;
//Serial.print("Destination Lat = ");
//Serial.println(goalLat);
//Serial.print(" Lng = ");
//Serial.println(goalLng);
}
void CCamcTestClient_9::MvruoRecordComplete( TInt aError )
{
switch( iAction)
{
case K_Tc9_SetMaxClipSizeLWhenControllerReadySize0 :
case K_Tc9_SetMaxClipSizeLWhenControllerReadyKMMFNoMaxClipSize :
{
if ( (aError == KErrDiskFull) || (aError == KErrCompletion ) )
{
// KErrCompletion if there is more space than needed for 60 min recording.
// Otherwise KErrDiskFull
aError = KErrNone;
}
else
{
aError = KErrGeneral;
}
break;
}
case K_TC9_NewFileNameWhenInternalStop :
{
if (aError == KErrCompletion)
{
// That's expected case.
aError = KErrNone;
}
else
{
aError = KErrGeneral;
}
break;
}
}
if (aError)
{
SomethingInActiveObjectIsLeaving(aError);
}
else
{
iRecordingReady = ETrue;
RunL();
}
}
GLDEF_C TInt E32Main()
{
__UHEAP_MARK;
TInt err = KErrNoMemory;
CActiveScheduler* sheduler = new CActiveScheduler;
if (sheduler)
{
CActiveScheduler::Install(sheduler);
CTrapCleanup* cleanup = CTrapCleanup::New();
if (cleanup)
{
TRAP(err, RunL());
delete cleanup;
}
delete sheduler;
}
__UHEAP_MARKEND;
return err;
}
void Drive::gotoGoal(){
double vel;
double str;
vel = Velcoeff*sqrt((((myLat-goalLat)*1000000)*((myLat-goalLat)*1000000))+(((myLng-goalLng)*1000000)*((myLng-goalLng)*1000000)));
str = Strcoeff1*calSteer(myLat, myLng, goalLat, goalLng, yaw) + Strcoeff2*angV;
if(str > Maxstr){
str = Maxstr;
}
else if(str < -Maxstr){
str = -Maxstr;
}
if(vel > Maxvel){
vel = Maxvel;
}
else if(vel < -Maxvel){
vel = -Maxvel;
}
RunR(vel - str);
RunL(vel + str);
}
void CTcSerialConnection::ConnectL()
{
LOG( _L("CTcSerialConnection::ConnectL() start") );
if( iState != EIdle )
{
User::Leave( KErrNotReady );
}
iState = EConnecting;
// Open serial port
SetupPortL();
// Serial port can be used immediately after port opening, do some nasty
// RunL call to get in connected state
iStatus = KErrNone;
RunL();
LOG( _L("CTcSerialConnection::ConnectL() end") );
}
void CSender::StartActive(TRequestStatus* aStatus, TAction aAction)
{
iAction = aAction;
iSavedStatus = aStatus;
// Mark the saved state as pending
if (iSavedStatus)
*iSavedStatus = KRequestPending;
TBuf<39> AddrBuf;
iRemote.OutputWithScope(AddrBuf);
iLogger.Log(_L("Trying to connect socket to %S on Iap %d on Network %d"),
&AddrBuf, iPref.IapId(), iPref.NetId());
iSock.Connect(iRemote, iStatus);
iState = EConnecting;
// this is commented so that the first socket gets connected first
//SetActive();
User::WaitForRequest(iStatus);
RunL();
}
void Drive::gotoDes(){
double vel;
double str;
vel = Velcoeff*sqrt((((myLat-desLat)*1000000)*((myLat-desLat)*1000000))+(((myLng-desLng)*1000000)*((myLng-desLng)*1000000)));
str = Strcoeff1*calSteer(myLat, myLng, desLat, desLng, yaw) + Strcoeff2*angV;
if(str > Maxstr){
str = Maxstr;
}
else if(str < -Maxstr){
str = -Maxstr;
}
if(vel > Maxvel){
vel = Maxvel;
}
else if(vel < -Maxvel){
vel = -Maxvel;
}
RunR(vel - str);
RunL(vel + str);
/*double myLngdeg = transDeg(myLng);
double myLatdeg = transDeg(myLat);
double goalLngdeg = transDeg(goalLng);
double goalLatdeg = transDeg(goalLat);
double A = (PI/180)*abs(myLngdeg - goalLngdeg);
//Serial.println(A*180/PI);
double b = (PI/180)*abs(90 - myLatdeg);
//Serial.println(b*180/PI);
double c = (PI/180)*abs(90 - goalLatdeg);
//Serial.println(c*180/PI);
double Distance = 64000*acos(cos(b)*cos(c) + sin(b)*sin(c)*cos(A));
//Serial.print("Distance = ");
//Serial.print(Distance, 6);
//Serial.println("m");
vel = 50000*acos(cos(b)*cos(c) + sin(b)*sin(c)*cos(A));
*/
//drive = 0(Stop), drive = 1(go to goal point), drive = 2(go to a point)
}
