Задани на лабораторные работы. ПРК / Professional Microsoft Robotics Developer Studio

www.it-ebooks.info

};

///<summary>

///CalculateTimeToMove

///</summary>

///<param name=”distance”>Distance to travel</param>

///<param name=”power”>Drive power to use</param>

///<returns>Number of milliseconds</returns>

public int CalculateTimeToMove(double distance, double power)

{

//Drive distance is in meters, but we have to convert it to a

//time delay in milliseconds. The “magic” numbers here were found

//by trial and error using a 30cm drive distance. It will change

//as the batteries run down and due to a variety of other factors. int pwr = (int)(Math.Abs(power) * 10 + 0.5);

double delay = Math.Abs(distance) * TimeFactors[pwr]; return (int)(delay);

}

The results of timed motions will never be exactly correct, nor reproducible, due to variations in the timing on the TimeoutPort. Because it uses Windows timers, the TimeoutPort is only accurate to the nearest 15ms. In addition, the service is running on a multi-tasking operating system that was not designed for real-time use.

Other programs running on your PC might have control of the CPU when a timer fires, forcing your service to wait its turn. Therefore, it is advisable to close down all non-essential programs before you run an MRDS application.

Even if the timer were perfectly accurate, there is still a chance that a sensor poll might be in progress when it is time to stop the motors. As explained earlier, there must be a short pause between commands, so in general there can be a variation of up to 100ms in the total elapsed time due to serial port contention. At top speed, 100ms equates to several centimeters of travel.

The errors tend to average out, so over a series of motions the result will be close to correct. For example, if you make four 90-degree rotations, the robot will turn close to 360 degrees even though the individual rotations might not be 90 degrees.

Note that the Hemisson does not drive straight. The motor speeds are neither regulated nor matched, so your Hemisson might drift to the left or the right. The problem is worst at lower speeds.

Lastly, the Hemisson also implements the HttpPost operation for the Drive service. If you use a web browser, you can see that there are additional buttons at the top of the web page that are not present on the Integrator Drive page. The values of the left and right motor power are also in textboxes so that you can change them (see Figure 17-10).

793

www.it-ebooks.info

Part IV: Robotics Hardware

Figure 17-10

In Figure 17-10, the robot is executing a RotateDegrees operation. This is not implemented in the main Hemisson (Brick) service, but in the Drive service. You can move the code from the Drive service to the main service if you want. In that case, the Drive service would be almost trivial because the main service already implements the SetDrivePower operation. In effect, the Drive service would just be a shell that offered an operations port that complies with the generic Differential Drive contract. All the real work would be done in the main service.

If you view the code in the HttpPostHandler, you can see how it handles the different buttons at the top of the web form:

if (parameters[“Stop”] != null)

{

drive.AllStop req = new drive.AllStop(); _mainPort.Post(req); success.Body.WaitPort = req.ResponsePort;

}

else if (parameters[“EnableDrive”] != null)

{

drive.EnableDrive req = new drive.EnableDrive(); req.Body.Enable = true;

_mainPort.Post(req); success.Body.WaitPort = req.ResponsePort;

}

else if (parameters[“DisableDrive”] != null)

794

www.it-ebooks.info

Chapter 17: Writing New Hardware Services

{

drive.EnableDrive req = new drive.EnableDrive(); req.Body.Enable = false;

_mainPort.Post(req); success.Body.WaitPort = req.ResponsePort;

}

else if (parameters[“SetPower”] != null)

{

if (_state.IsEnabled)

{

if (!string.IsNullOrEmpty(parameters[“LeftPower”]))

{

Each of the submit buttons has a name. When you click one of them, a value is sent along with the other fields on the page. The other buttons are ignored, so you only need to check for the existence of a parameter with the name of a button to determine which button was pressed.

There is another important “trick” here — a deferred response. Notice that in the preceding code, the response port from the original message is placed into a success message as the WaitPort property. As the form is processed, error messages are appended to the ErrorMessage string. The last step in the handler is to check this string:

if (ErrorMessage == string.Empty)

{

//Post a message to finally issue the HTTP response

//IMPORTANT NOTE:

//If we simply redisplay the state now, it will be WRONG!

//It is quite likely that we have issued a request to an

//Exclusive handler in the code above. If we wait for a

//response, then we create a Deadlock!

//The solution is to post a message, which gives the other

//handler a chance to run, then wait for the response, and

//finally send the HTTP page back to the user. Got that? success.Body.Submit = submit;

//This is the ONLY place where these messages are sent

//Do NOT wait for a response!

_httpPostPort.Post(success);

}

else

HttpPostFailure(submit, ErrorMessage);

If there is an error, then a response can be posted back to the caller immediately. This is not a problem. However, if you want the refreshed page to contain the correct information, you must wait until another operation has completed. To avoid deadlocks, the current operation must finish and the other operation has to be given a chance to execute. This is done by posting a message to an internal port called _httpPostPort.

In the body of the HttpPost handler, a request has already been posted to one of the other drive operations: AllStop, EnableDrive, or SetDrivePower. This other request is already waiting in the

795

www.it-ebooks.info

Part IV: Robotics Hardware

queue when the HttpPostSuccess message is posted, so as soon as the HttpPost handler completes, the other operation will execute first. Then the HttpPostSuccessHandler is called:

///<summary>

///Send Http Post Success Handler

///</summary>

///Processes successful HttpPost messages by first waiting for the

///requested task to be performed, then sending back the web page

///NOTE: This is a complicated process, but it is necessary to avoid

///creating a Deadlock!

private IEnumerator<ITask> HttpPostSuccessHandler(HttpPostSuccess success)

{

Fault fail = null;

//Wait for the request to be processed

//Otherwise, the settings displayed on the web page are the

//OLD state settings, not the new ones!

if (success.Body.WaitPort != null)

{

yield return Arbiter.Choice( success.Body.WaitPort, delegate(DefaultUpdateResponseType resp) { }, delegate(Fault f) { fail = f; }

);

}

// Make sure that the requested task completed successfully if (fail == null)

{

// Post a HTTP response (finally!) HttpResponseType rsp =

new HttpResponseType(HttpStatusCode.OK, _state, _transform); success.Body.Submit.ResponsePort.Post(rsp);

}

else

{

// There is still a chance for this to fail! HttpPostFailure(success.Body.Submit, fail);

}

}

The success handler does the waiting, not the HttpPost handler, which has already completed execution. It does this using the WaitPort. Note that there is still a chance that the other operation might fail, in which case the “success” handler actually sends back a “fail” message (as a Fault). However, if all goes well, the web page is redisplayed using the XSLT file, just as it is for a HttpGet — but now it has the most up-to-date state information.

Note that in order for this approach to work, the success messages must participate in the main interleave. Therefore, the receiver is added to the main interleave in the Start method:

//Set up the Stop Motion handler which must be in the Exclusive group

//along with the other drive requests MainPortInterleave.CombineWith(

796

www.it-ebooks.info

Chapter 17: Writing New Hardware Services

new Interleave(

new ExclusiveReceiverGroup( Arbiter.ReceiveWithIterator<StopMotion>(true,

_internalStopPort, StopMotionHandler) ),

new ConcurrentReceiverGroup( Arbiter.ReceiveWithIterator<HttpPostSuccess>(true,

_httpPostPort, HttpPostSuccessHandler)

)

)

);

It doesn’t matter that the HttpPostSuccessHandler is Concurrent because it will never execute at the same time as an Exclusive handler.

Overall, the implementation of the Hemisson services demonstrates more functionality than the Integrator. The Hemisson can be driven around using the TeleOperation program while you watch the live video. The range of the Sena Bluetooth dongle is quite good. The only known problem is that sometimes the Hemisson does not connect when the service starts, but you can fix this by powering it off and on again and restarting the service.

Where to Go from Here

That’s the end of the book, but the fun does not stop here. New applications will continue to be posted on the book’s website. You can develop your own robotics applications and, it is hoped, share them with the MRDS community.

If we can believe the pundits, robotics is at a similar stage to the early development of the PC. Over the next few years we can expect dramatic improvements in the capabilities of robots in terms of physical agility, manual dexterity, object recognition, intelligence, and so on. The hobby robots and robotic toys of today will pale in comparison to the commercially available robots on the market in ten years.

One rapidly developing area is telepresence — similar to the TeleOperation service in Chapter 4. In late 2007, a whole raft of robots was announced that can be remotely controlled over the Internet with full video and audio capability — Spykee from Meccano, ConnectR from iRobot, and Rovio from WowWee Robotics. These should become available in 2008. This approach overcomes the artificial intelligence “roadblock” that researchers hit some 20 years ago, and it extends the concept of robotic toys to something useful in the home. Grandma will be able to “tele” in on the family robot and check whether you are keeping your room tidy.

With an aging population in many countries, such as Spain and Japan, placing “companion robots” into the homes of the elderly is one way to care for them. Research has shown that elderly people living in nursing homes become more active and responsive when they are given small, furry robotics pets, such as seals, pandas, and so on, to play with. Meanwhile, children’s toys are getting more intelligent and lifelike, such as Pleo the dinosaur. These robots, however, are just as much about human interaction as they are about robotics. More effort is required on the user interface than on the robotics.

797

www.it-ebooks.info

Part IV: Robotics Hardware

It’s a great time to be on the ground floor of a new industry, but don’t expect to be writing services to control differential drives in 2020. Will we see domestic robots powered by MRDS roaming around homes? Microsoft would like to think so. Only time will tell.

Summary

This chapter has shown you how to build a set of services for a completely new robot, albeit a simple one. From hardware and design to timed operations and polling, you have seen what is required to build and test a new robot.

Of course, despite the fact that it is over 800 pages long, this book still does not cover some areas of MRDS. You need to read the online documentation to fill in the gaps, and when V2.0 comes out you will probably have to start all over again. Welcome to the constantly evolving world of robotics.

Now go out and program your robots!

798

www.it-ebooks.info

Arm Mover project (VPL)

800

www.it-ebooks.info

801

www.it-ebooks.info

cliff sensors

802