IEnumerator <ITask> UpdateImage(DateTime dateTime)
{
byte[] rgbData = null;
Size size = new Size(0, 0);
yield return(Arbiter.Choice(_simulatedWebcamServicePort.QueryFrame(),
success =>
{
rgbData = success.Frame;
size = success.Size;
},
failure =>
{
LogError(failure.ToException());
}));
if (rgbData != null)
{
ComputeGradient(ref rgbData, size);
UpdateBitmap(rgbData, size);
}
Activate(Arbiter.ReceiveWithIterator(false, _dateTimePort, UpdateImage));
TaskQueue.EnqueueTimer(TimeSpan.FromMilliseconds(60), _dateTimePort);
}
IEnumerator <ITask> OnConnectSickLRFHandler(OnConnectSickLRF onConnectSickLRF)
{
if (onConnectSickLRF.DriveControl != _driveControl)
{
yield break;
}
_laserPort = ServiceForwarder <sicklrf.SickLRFOperations>(onConnectSickLRF.Service);
_laserShutdown = new Port <Shutdown>();
sicklrf.ReliableSubscribe subscribe = new sicklrf.ReliableSubscribe(
new ReliableSubscribeRequestType(5)
);
subscribe.NotificationPort = _laserNotify;
subscribe.NotificationShutdownPort = _laserShutdown;
_laserPort.Post(subscribe);
yield return(Arbiter.Choice(
subscribe.ResponsePort,
delegate(SubscribeResponseType response)
{
LogInfo("Subscribed to " + onConnectSickLRF.Service);
},
delegate(Fault fault)
{
_laserShutdown = null;
LogError(fault);
}
));
}
/// <summary>
/// This method searches for a primary or alternate contract of the
/// service that is present in the contracts list. Requires a
/// taskQueue to activate tasks on. Throws NoContractFoundException
/// in a Fault if one cannot be found.
/// </summary>
/// <param name="taskQueue"></param>
/// <param name="service"></param>
/// <param name="contracts"></param>
/// <returns></returns>
public static PortSet <ServiceInfoType, Fault> FindCompatibleContract(DispatcherQueue taskQueue, Uri service, List <string> contracts)
{
PortSet <ServiceInfoType, Fault> returnPort = new PortSet <ServiceInfoType, Fault>();
PortSet <LookupResponse, Fault> responsePort = new PortSet <LookupResponse, Fault>();
//Console.WriteLine("RSUtils: Querying " + service);
DssEnvironment.ServiceForwarderUnknownType(service).PostUnknownType(
new DsspDefaultLookup()
{
Body = new LookupRequestType(), ResponsePort = responsePort
});
Arbiter.Activate(taskQueue, Arbiter.Choice <LookupResponse, Fault>(
responsePort,
delegate(LookupResponse resp)
{
try
{
//Console.WriteLine("RSUtils: Got response");
returnPort.Post(FindCompatibleContract(resp, contracts));
}
catch (NoContractFoundException e)
{
returnPort.Post(FaultOfException(e));
}
},
delegate(Fault failure)
{
returnPort.Post(failure);
}));
return(returnPort);
}
public virtual void Speak(string message, bool async)
{
tts.SayTextRequest streq = new tts.SayTextRequest();
streq.SpeechText = message;
if (async)
{
ttsPort.SayText(streq);
}
else
{
AutoResetEvent aevent = new AutoResetEvent(false);
Arbiter.Activate(DssEnvironment.TaskQueue,
Arbiter.Choice(ttsPort.SayText(streq),
delegate(DefaultUpdateResponseType state)
{
aevent.Set();
},
delegate(Fault f)
{
aevent.Set();
}
));
aevent.WaitOne(1000, false);
}
}
IEnumerator <ITask> OnConnectHandler(OnConnect onConnect)
{
if (onConnect.DriveControl == _driveControl)
{
UriBuilder builder = new UriBuilder(onConnect.Service);
builder.Scheme = new Uri(ServiceInfo.Service).Scheme;
ds.DirectoryPort port = ServiceForwarder <ds.DirectoryPort>(builder.Uri);
ds.Get get = new ds.Get();
port.Post(get);
ServiceInfoType[] list = null;
yield return(Arbiter.Choice(get.ResponsePort,
delegate(ds.GetResponseType response)
{
list = response.RecordList;
},
delegate(Fault fault)
{
list = new ServiceInfoType[0];
LogError(fault);
}
));
WinFormsServicePort.FormInvoke(
delegate()
{
_driveControl.ReplaceDirectoryList(list);
}
);
}
}
void TimerHandler(DateTime signal)
{
legoNXT.LegoGetBatteryLevel getBatt = new legoNXT.LegoGetBatteryLevel();
getBatt.RequireResponse = true;
Activate(Arbiter.Choice(_legoPort.SendLegoCommand(getBatt),
delegate(legoNXT.LegoResponse status)
{
legoNXT.LegoResponseGetBatteryLevel legoResponseGetBatteryLevel = status as legoNXT.LegoResponseGetBatteryLevel;
if (legoResponseGetBatteryLevel != null && legoResponseGetBatteryLevel.ErrorCode == legoNXT.LegoErrorCode.Success)
{
double voltage = legoResponseGetBatteryLevel.Voltage;
_state.PercentBatteryPower = voltage / 1000.0 / _state.MaxBatteryPower;
}
},
delegate(Fault failure)
{
LogError(failure);
}
));
//re-call ourselves
Activate(
Arbiter.Receive(false, TimeoutPort(_state.PollDelayTime),
delegate(DateTime time)
{
_timerPort.Post(time);
}
)
);
}
private IEnumerator <ITask> StartIterator(Port <bool> successPort)
{
bool success = false;
InitController init = new InitController();
_controllerPort.Post(init);
yield return(Arbiter.Choice(
init.ResponsePort,
delegate(DefaultSubmitResponseType response)
{
// The controller initialized successfully.
_srv1 = srv1srv.Srv1Service.Srv1Controller;
success = true;
},
delegate(Fault fault) { }
));
if (!success)
{
successPort.Post(false);
yield break;
}
// Activate service handlers.
StartBehavior();
successPort.Post(true);
yield break;
}
public virtual IEnumerator <ITask> ReceiveBluetoothMessageHandler(ReceiveBluetoothMessage query)
{
BluetoothMessage response = new BluetoothMessage();
int inbox = Math.Max(1, Math.Min(10, query.Body.Mailbox)) - 1;
nxtcmd.LegoMessageRead cmd = new nxtcmd.LegoMessageRead(inbox + 10, inbox, true);
yield return(Arbiter.Choice(_legoBrickPort.SendNxtCommand(cmd),
delegate(nxtcmd.LegoResponse ok)
{
nxtcmd.LegoResponseMessageRead queryResponse = nxtcmd.LegoResponse.Upcast <nxtcmd.LegoResponseMessageRead>(ok);
if (queryResponse.Success)
{
response.Mailbox = query.Body.Mailbox;
response.Message = queryResponse.Message;
query.ResponsePort.Post(response);
}
else
{
query.ResponsePort.Post(Fault.FromException(new System.IO.IOException(queryResponse.ErrorCode.ToString())));
}
},
delegate(Fault fault)
{
query.ResponsePort.Post(fault);
}));
yield break;
}
IEnumerator <ITask> DoStart()
{
try
{
_utilities = DsspHttpUtilitiesService.Create(Environment);
RunForm runForm = new RunForm(CreateForm);
WinFormsServicePort.Post(runForm);
yield return(Arbiter.Choice(
runForm.pResult,
EmptyHandler,
EmptyHandler
));
FormInvoke invoke = new FormInvoke(
delegate
{
_form.Initialize(_state);
}
);
WinFormsServicePort.Post(invoke);
yield return(Arbiter.Choice(
invoke.ResultPort,
EmptyHandler,
EmptyHandler
));
}
finally
{
FinishStarting();
}
}
public virtual IEnumerator <ITask> QueryRunningLegoProgramHandler(QueryRunningProgram query)
{
RunningProgramResponse response = new RunningProgramResponse();
nxtcmd.LegoGetCurrentProgramName cmd = new nxtcmd.LegoGetCurrentProgramName();
yield return(Arbiter.Choice(_legoBrickPort.SendNxtCommand(cmd),
delegate(nxtcmd.LegoResponse ok)
{
nxtcmd.LegoResponseGetCurrentProgramName queryResponse = nxtcmd.LegoResponse.Upcast <nxtcmd.LegoResponseGetCurrentProgramName>(ok);
if (queryResponse.Success)
{
response.Program = queryResponse.FileName;
query.ResponsePort.Post(response);
}
else
{
query.ResponsePort.Post(Fault.FromException(new System.IO.FileNotFoundException(queryResponse.ErrorCode.ToString())));
}
},
delegate(Fault fault)
{
query.ResponsePort.Post(fault);
}));
yield break;
}
public virtual IEnumerator <ITask> QueryBrickNameHandler(QueryBrickName query)
{
BrickNameResponse response = new BrickNameResponse();
nxtcmd.LegoGetDeviceInfo cmd = new nxtcmd.LegoGetDeviceInfo();
yield return(Arbiter.Choice(_legoBrickPort.SendNxtCommand(cmd),
delegate(nxtcmd.LegoResponse ok)
{
nxtcmd.LegoResponseGetDeviceInfo queryResponse = nxtcmd.LegoResponse.Upcast <nxtcmd.LegoResponseGetDeviceInfo>(ok);
if (queryResponse.Success)
{
response.BrickName = queryResponse.BrickName;
query.ResponsePort.Post(response);
}
else
{
query.ResponsePort.Post(Fault.FromException(new System.IO.FileNotFoundException(queryResponse.ErrorCode.ToString())));
}
},
delegate(Fault fault)
{
query.ResponsePort.Post(fault);
}));
yield break;
}
public IEnumerator <ITask> IncrementTickHandler(IncrementTick incrementTick)
{
_state.Ticks++;
LogInfo("Tick: " + _state.Ticks);
// Save the state every 10 ticks
if (_state.Ticks % 10 == 0)
{
LogInfo("Store State");
#region CODECLIP 03-1
// SaveState() sends a message so the process is not complete
// until a response is received. It is good practise to check
// for a Fault whenever you send a message.
yield return(Arbiter.Choice(
base.SaveState(_state),
delegate(DefaultReplaceResponseType success) { },
delegate(W3C.Soap.Fault fault)
{
LogError(null, "Unable to store state", fault);
}
));
#endregion
}
incrementTick.ResponsePort.Post(DefaultUpdateResponseType.Instance);
yield break;
}
public IEnumerator <ITask> IncrementTickHandler(IncrementTick incrementTick)
{
_state.Ticks++;
LogInfo("Tick: " + _state.Ticks);
#region CODECLIP 04-2
// Notify all subscribers.
// The incrementTick message does not contain the tick count.
base.SendNotification(_submgrPort, incrementTick);
#endregion
if (_state.Ticks % 10 == 0)
{
LogInfo("Store State");
yield return(Arbiter.Choice(
base.SaveState(_state),
delegate(DefaultReplaceResponseType success) { },
delegate(W3C.Soap.Fault fault)
{
LogError(null, "Unable to store state", fault);
}
));
}
incrementTick.ResponsePort.Post(DefaultUpdateResponseType.Instance);
yield break;
}
IEnumerator <ITask> UsbDeviceDetached(ProximityBoardUsbDeviceDetached linkDetached)
{
Tracer.Trace("TrackRoamerBrickProximityBoardService::UsbDeviceDetached(): " + linkDetached.Description);
_submgrPort.Post(new submgr.Submit(new ResetType(), DsspActions.SubmitRequest));
_state.Description = linkDetached.Description;
_state.LinkState = "USB Device Detached - closing link to Proximity Board";
_state.IsConnected = false;
LogInfo("Closing link to Proximity Board");
yield return
(Arbiter.Choice(
_pbCommander.Close(),
delegate(SuccessResult success)
{
_state.LinkState = "USB Device Detached - link to Proximity Board closed";
},
delegate(Exception except)
{
_state.LinkState = "USB Device Detached - Error closing link to Proximity Board";
LogError(except);
}
));
_state.LinkState = "USB Device Detached - Proximity Board link closed, waiting 5 seconds";
LogInfo(_state.LinkState);
_pbCommander = null;
SpawnIterator(openDelayMs, StartProximityBoard);
yield break;
}
IEnumerator <ITask> UpdateImage(webcam.WebCamOperations webcamPort, ImageProcessingResultForm webcamForm)
{
long timestamp = _stopWatch.ElapsedMilliseconds;
byte[] rgbData = null;
Size size = new Size(0, 0);
yield return(Arbiter.Choice(webcamPort.QueryFrame(),
success =>
{
rgbData = success.Frame;
size = success.Size;
},
failure =>
{
LogError(failure.ToException());
}));
TaskQueue.Enqueue(new Task(() =>
{
if (rgbData != null)
{
ComputeGradient(ref rgbData, size);
UpdateBitmap(rgbData, size, webcamForm, timestamp);
}
}));
}
/// <summary>
/// Handler called when a particular action on the window is performed
/// </summary>
/// <param name="onAction">The action to be performed</param>
void OnWindowSimulationActionHandler(WindowSimulationSettings.OnAction onAction)
{
if (onAction.action == WindowSimulationSettings.OnActionActions.ACTION_BUTTONCLICKED_APPLY)
{
// Prepare a request to delete the new multicopter
var delRequest = new DeleteSimulationEntity(_multicopterEntity);
// Activate success / failure handlers
Activate(
Arbiter.Choice <DefaultDeleteResponseType, W3C.Soap.Fault>(
delRequest.ResponsePort,
// Remove was a success
delegate(DefaultDeleteResponseType t)
{
// Create new multicopter based on selection
SimulatorAddMulticopterEntity(onAction.multicopterType, onAction.propellerInclination);
},
// Remove failed
delegate(W3C.Soap.Fault f)
{
throw new NotImplementedException();
}
)
);
// Remove the old multicopter
SimulationEngine.GlobalInstancePort.Post(delRequest);
}
}
public virtual IEnumerator <ITask> SpotlightHandler(Spotlight spotlight)
{
_state.SpotlightOn = spotlight.Body.SpotlightOn;
LegoSetInputMode cmd = new LegoSetInputMode(_state.SensorPort, _state.SpotlightOn ? LegoSensorType.LightActive : LegoSensorType.LightInactive, LegoSensorMode.PercentFullScaleMode);
_legoBrickPort.SendNxtCommand(cmd);
yield return(Arbiter.Choice(_legoBrickPort.SendNxtCommand(cmd),
delegate(LegoResponse response)
{
if (response.Success)
{
spotlight.ResponsePort.Post(DefaultUpdateResponseType.Instance);
// Spotlight notifications are only sent to subscribers to the native service
SendNotification <Spotlight>(_subMgrPort, spotlight);
}
else
{
spotlight.ResponsePort.Post(
Fault.FromException(
new InvalidOperationException(response.ErrorCode.ToString())));
}
},
delegate(Fault fault)
{
spotlight.ResponsePort.Post(fault);
}));
yield break;
}
public IEnumerator <ITask> OnFilteredSubscribe(FilteredSubscribe subscribe)
{
FilteredSubscribeRequest request = subscribe.Body;
submgr.InsertSubscriptionMessage message = new submgr.InsertSubscriptionMessage(request);
if (request.Filter != Filter.None && request.Filter != Filter.All)
{
List <submgr.QueryType> queries = new List <submgr.QueryType>();
for (int i = 1; i < (int)Filter.All; i <<= 1)
{
Filter filter = (Filter)i;
if ((request.Filter & filter) == filter)
{
queries.Add(new submgr.QueryType(filter.ToString()));
}
}
message.QueryList = queries.ToArray();
}
submgr.InsertSubscription insert = new submgr.InsertSubscription(message);
yield return(Arbiter.Choice(
insert.ResponsePort,
subscribe.ResponsePort.Post,
subscribe.ResponsePort.Post
));
}
private void SetActuator_Value(int actuatorID, float?actuatorValue)
{
if (actuatorValue == null)
{
return;
}
InternalSetActuatorValue update = new InternalSetActuatorValue();
update.actuatorID = actuatorID;
update.value = (float)actuatorValue;
update.ResponsePort = new DsspResponsePort <DefaultUpdateResponseType>();
_updatePort.Post(update);
Activate(
Arbiter.Choice(update.ResponsePort,
delegate(DefaultUpdateResponseType response)
{
},
delegate(Fault fault)
{
LogError("Failed to send notification");
}
));
}
private IEnumerator <ITask> StreamImage(HttpListenerContext context, Bitmap bitmap)
{
HttpListenerResponse response = context.Response;
using (MemoryStream stream = new MemoryStream())
{
bitmap.Save(stream, ImageFormat.Png);
stream.Position = 0;
response.AddHeader("Cache-Control", "No-cache");
WriteResponseFromStream write = new WriteResponseFromStream(
context, stream, "image/png"
);
_utilitiesPort.Post(write);
yield return(Arbiter.Choice(
write.ResultPort,
delegate(Stream res)
{
stream.Close();
},
delegate(Exception e)
{
stream.Close();
LogError(e);
}
));
}
}
/// <summary>
/// Overrides RobotBrain Bind function to implement addition LEDAdapter functions.
/// </summary>
protected override void Bind()
{
base.Bind();
//Bind to scribbler specific sensors
//Specialized LED array
directory.Query dquery = new directory.Query(new directory.QueryRequestType(
new Microsoft.Dss.ServiceModel.Dssp.ServiceInfoType("http://www.roboteducation.org/scribblerledarray.html")));
//Uri direcURI = DssEnvironment.FindService(directory.Contract.Identifier);
//TODO: remove the line below once the above line works
Uri direcURI = new Uri("http://localhost:" + httpPort + "/directory");
directory.DirectoryPort dport = DssEnvironment.ServiceForwarder <directory.DirectoryPort>(direcURI);
dport.Post(dquery);
Arbiter.Activate(DssEnvironment.TaskQueue,
Arbiter.Choice(dquery.ResponsePort,
delegate(directory.QueryResponseType success)
{
sledadapter = new ScribblerLEDArrayAdapter(success.RecordList[0].Service);
},
delegate(Fault fault) { }
)
);
}
/// <summary>
/// Handles Replace notifications from the Laser partner
/// </summary>
/// <remarks>Posts a <typeparamref name="LaserRangeFinderUpdate"/> to itself.</remarks>
/// <param name="replace">notification</param>
/// <returns>task enumerator</returns>
IEnumerator <ITask> LaserReplaceNotificationHandler(sicklrf.Replace replace)
{
//Tracer.Trace("LaserReplaceNotificationHandler() - Replace");
// When this handler is called a couple of notifications may
// have piled up. We only want the most recent one.
sicklrf.State laserData = GetMostRecentLaserNotification(replace.Body);
LaserRangeFinderUpdate laserUpdate = new LaserRangeFinderUpdate(laserData);
_mainPort.Post(laserUpdate); // calls LaserRangeFinderUpdateHandler() with laserUpdate
yield return(Arbiter.Choice(
laserUpdate.ResponsePort,
delegate(DefaultUpdateResponseType response) { },
delegate(Fault fault) { }
));
// Skip messages that have been queued up in the meantime.
// The notification that are lingering are out of date by now.
GetMostRecentLaserNotification(laserData);
// Reactivate the handler.
Activate(
Arbiter.ReceiveWithIterator <sicklrf.Replace>(false, _laserNotify, LaserReplaceNotificationHandler)
);
yield break;
}
/// <summary>
/// Subscribe to motors on Scribbler base
/// </summary>
private void SubscribeToScribblerBase()
{
// Create a notification port
brick.ScribblerOperations _notificationPort = new brick.ScribblerOperations();
//create a custom subscription request
brick.MySubscribeRequestType request = new brick.MySubscribeRequestType();
request.Sensors = new List <string>();
request.Sensors.Add("MOTORS");
//Subscribe to the ScribblerBase and wait for a response
Activate(
Arbiter.Choice(_scribblerPort.SelectiveSubscribe(request, _notificationPort),
delegate(SubscribeResponseType Rsp)
{
//update our state with subscription status
_subscribed = true;
LogInfo("Backup Monitor subscription success");
//Subscription was successful, start listening for sensor change notifications
Activate(
Arbiter.Receive <brick.Replace>(true, _notificationPort, MotorNotificationHandler)
);
},
delegate(soap.Fault F)
{
LogError("Backup Monitor subscription failed");
}
)
);
}
void TimerHandler(DateTime signal)
{
brick.SetLedBody heartBeat = new brick.SetLedBody();
heartBeat.LED = _state.whichLED;
_state.LEDState = !_state.LEDState; //flip LED
heartBeat.State = _state.LEDState;
Activate(Arbiter.Choice(_scribblerPort.SetLED(heartBeat),
delegate(DefaultUpdateResponseType status)
{
_state.Connected = true;
},
delegate(Fault failure)
{
_state.Connected = false;
LogError("ScribblerHeartBeat failed to connect to base service");
}
));
//re-call ourselves
Activate(
Arbiter.Receive(false, TimeoutPort(_state.PauseTime),
delegate(DateTime time)
{
_timerPort.Post(time);
}
)
);
}
IEnumerator <ITask> OnConnectArticulatedArmHandler(OnConnectArticulatedArm onConnect)
{
arm.ArticulatedArmState armState = null;
if (onConnect.DriveControl != _driveControl)
{
yield break;
}
_articulatedArmPort = ServiceForwarder <arm.ArticulatedArmOperations>(onConnect.Service);
yield return(Arbiter.Choice(
_articulatedArmPort.Get(new GetRequestType()),
delegate(arm.ArticulatedArmState state) { armState = state; },
delegate(Fault f) { LogError(f); }
));
if (armState == null)
{
yield break;
}
WinFormsServicePort.FormInvoke(delegate()
{
_driveControl.ReplaceArticulatedArmJointList(armState);
});
yield break;
}
public IEnumerator <ITask> SubscribeHandler(webcam.Subscribe subscribe)
{
#if !URT_MINCLR
yield return(Arbiter.Choice(
SubscribeHelper(_submgrPort, subscribe.Body, subscribe.ResponsePort),
delegate(SuccessResult success)
{
LogInfo("Subscription from: " + subscribe.Body.Subscriber);
},
delegate(Exception e)
{
LogError(null, "Subscription failed", e);
}
));
#else
string key = subscribe.Body.Subscriber.ToLower();
if (!_subscribers.ContainsKey(key))
{
Port <DsspOperation> notificationPort = ServiceForwarderUnknownType(new Uri(subscribe.Body.Subscriber));
_subscribers.Add(key, notificationPort);
}
subscribe.ResponsePort.Post(new SubscribeResponseType());
yield break;
#endif
}
IEnumerator <ITask> RandomTurn(Port <bool> done)
{
// we turn by issuing motor commands, using reverse polarity for left and right
// We could just issue a Rotate command but since its a higher level function
// we cant assume (yet) all our implementations of differential drives support it
double randomPower = _randomGen.NextDouble();
drive.SetDrivePowerRequest setPower = new drive.SetDrivePowerRequest(randomPower, -randomPower);
bool success = false;
yield return
(Arbiter.Choice(
_drivePort.SetDrivePower(setPower),
delegate(DefaultUpdateResponseType rsp) { success = true; },
delegate(W3C.Soap.Fault failure)
{
// report error but report done anyway. we will attempt
// to do the next step in wander behavior even if turn failed
LogError("Failed setting drive power");
}));
done.Post(success);
yield break;
}
IEnumerator <ITask> OnDemandFrameHandler(Frame frame)
{
InternalFrameRequest request;
using (Bitmap bmp = frame.Image)
{
using (var stream = new MemoryStream())
{
while (_frameRequestPort.Test(out request))
{
if (request.IsHttpRequest)
{
if (stream.Length == 0)
{
frame.Image.Save(stream, request.Format);
}
stream.Position = 0;
yield return(Arbiter.Choice(
WriteImageToHttpResponse(request.Context, request.Type, stream),
success => stream.Close(),
exception => { stream.Close(); LogWarning("Writing image to HTTP: " + exception.Message); }
));
}
else
{
ReplyToQueryFrame(request.DsspQuery, bmp);
}
request.ResponsePort.Post(EmptyValue.SharedInstance);
}
}
}
}
public virtual IEnumerator <ITask> PlayToneHandler(tone.PlayTone request)
{
if (request.Body.Frequency < 0 || request.Body.Duration < 0)
{
LogError("Improper PlayTone Frequency or Duration");
request.ResponsePort.Post(new Fault());
yield break;
}
brick.PlayToneBody play = new brick.PlayToneBody();
play.Frequency1 = request.Body.Frequency;
play.Frequency2 = 0;
play.Duration = request.Body.Duration;
Activate(Arbiter.Choice(_scribblerPort.PlayTone(play),
delegate(DefaultUpdateResponseType response)
{
request.ResponsePort.Post(DefaultUpdateResponseType.Instance);
},
delegate(Fault fault)
{
request.ResponsePort.Post(new Fault());
}
));
yield break;
}
/// <summary>
/// Find sensors on the brick which can be added to
/// our contact sensor array.
/// </summary>
/// <returns></returns>
private IEnumerator <ITask> FindSensors()
{
#region Attach to the NXT Brick
LegoNxtConnection aggregate = new LegoNxtConnection(LegoNxtPort.Aggregation);
aggregate.PortOverride = "Contact Sensor Array";
brick.AttachRequest attachRequest = new brick.AttachRequest(
new brick.Registration(
aggregate,
LegoDeviceType.Aggregation,
"ContactSensorArray",
Contract.Identifier,
ServiceInfo.Service,
"ContactSensorArray"));
yield return(Arbiter.Choice(_legoBrickPort.AttachAndSubscribe(attachRequest, _legoBrickNotificationPort),
delegate(brick.AttachResponse rsp)
{
},
delegate(Fault fault)
{
LogError("Error in LEGO NXT Contact Sensor Array while attaching to brick", fault);
}));
#endregion
PortSet <brick.NxtBrickState, Fault> brickResponse = _legoBrickPort.Get();
yield return(Arbiter.Choice(
Arbiter.ReceiveWithIterator <brick.NxtBrickState>(false, brickResponse, ProcessBrickState),
Arbiter.Receive <Fault>(false, brickResponse, EmptyHandler <Fault>)));
yield break;
}
