There are a few Microcontroller boards out there.  The most interesting one to me is the Arduino board.  This is an open-source platform for physical control computing.  Recently the Netduino board was released.  This little beauty is an .net version of the Arduino board.  Most of the available shields are compatible with this platform.  I just recently ordered the Netduino-Plus.

Here is a list of some of the Netduino-Plus features.  There is a lot of flexibility built into this microcontroller.

• Atmel 32-bit microcontroller
• Speed: 48MHz, ARM7
• Code Storage: 64 KB without networking: 128 KB
• RAM: 28 KB without networking: 60 KB
• Ethernet: 100 mbps
• network stack: lwIP
• Micro SD (up to 2 GB)
• Auto card detect
• Input: 7.5 – 12.0 VDC or USB powered
• Output: 5 VDC and 3.3 VDC regulated

I have also been looking into a much more flexible and probably more suitable set of boards for me.  Because of the complex code requirements I have, the PICO-ITX set of Microcontroller boards seems to be a good fit.  They have a very small footprint.  Reasonable power requirements and can run in most cases the latest windows 7 operating systems without any problem.  Additionally most of the newer boards have full IO support that any modern computer would have.

I have been looking at these models.  They are powerful and cost effective enough to be part of my robotics build projects.  The PICO-ITX form factor is just a little larger than a playing card, coming in at 10cm x 7.2cm.  The VIA EPIA-P830 Pico-ITX board takes advantage of a 1.2GHz 64-bit processor.  These boards usually price in at about 270$.  You can purchase them at e-itx.com.

These boards are a little higher on the power consumption.  If this is critical to your build then you are going to want to keep an eye this.  You will also want to get a PSU that supports wide input.  This board is powerful enough to run Windows 7 x64 if that’s what you build requires.

Here are a few of the boards highlights.

• Compact 10cm x 7.2cm Pico-ITX form factor
• High performance 64-bit VIA Nano processor
• Latest VIA VX900 media system processor
• HD video performance 1080p
• Native HDMI, VGA and LVDS support
• Support for DDR3 system memory
• Support for two 1x PCIe expansion connector
• HD audio support
• Legacy I/O support GPIO, SMBus

If this is a bit too much board for your robotics requirements, you can find some less powerful boards in a slightly cheaper price range.  I was pointed to this little eBox-2300/2310DXA, Ultra-Mini Fanless Compact PC Computer w/ TDX600 1GHz CPU.  Its very reasonably prices in at $158.  It can run most of the major windows and Linux operating systems and has enough power to drive a complex code project. 

As you can see there are plenty of options out there and I am only scratching the surface.  You are going to want to pay close attention to the requirements of your project to help you decide which direction to go info for your microcontroller.  You can go with much cheaper options that can cost as little a few dollars to control your unit.  A good place to locate robotics parts is the SparkFun website. 

The next step for me is take make my choice.  My next entry of “Robot Adventures” will include the integration of an advanced Microcontroller.  Once that piece is in place, my robot will no longer need to be tethered to my laptop and it will be able to move around on its own and make logical decisions based on what it senses in the environment around it.

About 3 weeks into January of 2011, a robot showed up at my front door.  Sure it was late, because they were backordered.  I almost forgot about it, but when it showed up, I had a new adventure to start and I was excited about it.  I opened the box an inside was the Traxster II from Robot Connections.

I started assessing what I had.  All the parts that I asked for were there.  I knew it would fall short, because I had no real idea all the pieces that I needed.  This was a lot more advanced than the simple X10 components I had worked with in the past.  Over the following weeks, I would find out how deep a space this was and how simple or complex I could go if I wanted.  My nature led me to the complex very quickly, but I will get to that a little later.  The robot is tracked platform.  This gives me a little more flexibility in driving.  The system has two motors, one for the left track and one for the right track.  Plus I think it looks a lot tougher than a wheeled robot.  This will be the start of a multi-part blog on my robotic adventures.  Let the adventures begin.

Now that I have my Traxster, I needed to have a plan.  Something that would give me some targeted goals to build to.  Something to challenge my robotics skills and my programming skills.  There where a few options but I opted to program my robot to defend my bedroom entrance from our new cats.  We have a pretty big house and there is no need for them to be in there.  A friend of mine mentioned the Bedroom Defense System (BDS) and it stuck.  This gives me a pretty well defined and achievable goal to reach for.  Here are a few of the requirements. 

• Run as an autonomous unit with no human control
• Recognize the targets using optical recognition
• Guard entry to the doorway using active defense techniques
• Allow remote telemetry and interaction from anywhere (RaaS)
• Have fun and learn some new techniques

I started with the base Traxster II platform and the Serializer 3.0 Robot Controller.  This is a solid serializer to start with and it provides a lot of flexibility out of the box.  I was able to assemble the robot fairly quickly.  The most tedious part was putting the tracks together.  There were a lot of small parts and each piece of the track needed to added individually.  If you notice the photo, one of the cats has stopped by to see what is going on.  A couple of the tracks broke on me while I was inserting the pins, but the track kit supplied a few extras, so I had enough when I was done.  I also integrated the motors and the serializer board.  The belt gears went on fairly easy, there was a little sticking with the powder coating but tightening the screws evenly pressed them in cleanly.  The next big step was identifying the additional parts I needed to order.  There are a lot of choices, I would so limitless.  I opted to go with a few specific parts, to stay in alignment with my goals.  The one that I am most excited about is the optics.  I purchased a Microsoft LifeCam and parts to build a turret configuration to start down the road optical recognition road.  There are also a few open source options for object recognition and navigation that I will cover in a later blog entry.  I also picked up a smaller laser attachment that I can use as a distraction.  In addition to this, I invested in XBee wireless and some RFID technology from RedBee.  All of these will be staged into the design over time.

While putting together my creation, I dug deep into how far I could extend the the robot.  This is where things started to get complex.  To really create a robot properly, I need to be creative on all fronts.  I also need to have at least a basic and optimally an intermediate knowledge of electronics.  I think I am OK in that area, but there is definitely a lot of relearning I am going to need to do.  In addition there are a lot of new parts and tools to play with.  I purchased a new digital multi-meter.  I also have my eye on a portable Oscilloscope from seedstudio, but its currently in beta so I am going to wait until its ready for prime time. 

I started with the platform layout and the initial build of the components.  I pulled apart an old DVD player and extracted a few parts to enhance my installation points.  Here are a few screen shoots of my progress, which include the optics turret, the XBee wireless and some additional platform parts pulled from the DVD player.

I still don’t have all the components I need to program against the robot.  To get all the components running they are going to each voltage.  I ordered a pair of 9.6V NiHM battery packs.  The serializer board has a 12V regulated input and 4-6V un-regulated input.  At this point, I am going to build the proper voltage regulator myself.  I bought a bunch of resistors, capacitors and regulators at the local radio shack.  I will follow up with the solution in a later entry as well.  I know I don’t have the right power yet and I want to make sure I cover the voltage requirements properly.

More to come…

Cheers,
g

Purpose
The goals of RaaS are to enable an agent to control robotic entities in remote or distant locations, safely and securely using a common interface model.  Today most robots are disconnected from the digital world.  The need for to control remote robots is going to become more important over the next few decades.  Currently there are various techniques to doing this, but RaaS creates a unified approach to robotic service delivery.

History
RaaS is a fairly new technique, but there are a few recent examples that within the last decade that demonstrate its value to individuals and society as a whole.  The best example that expands our understanding of how RaaS can impact our lives is the Robotic missions to the moon.  We are most familiar with the explorations of Spirit and Opportunity.  While this technique is still evolving the future has almost unlimited potential.

Characteristics
Robot as a Service (RaaS) has a few important characteristics that, even though the term may be interpreted by people in different ways.  There are specific characteristics that can be found in common.

• It enables intra-network and inter-network based robotic services to any user.  Typically the interaction is available for a single user per robotic instance to command at any time. 
• Upgrades changes or enhancements to the robot are simply discovered and the user benefits from those changes.
• The client simply discovers the services and issues commands.  The clients hardware or software are transparent and not important to the robot.
• Security and performance are generally weighted higher during implementation because of the potential uses for a robot and the volume/nature of telemetry data that is transmitted.

Benefits
The benefits of RaaS are far and wide reaching.  What makes the application of RaaS unique to other software techniques in use today is the control of a physical entity located somewhere other than the controller.  The practical applications are significant.  Here is a short list of some of the uses.

• Control of remote mining equipment.
• Medical assist robots.
• Autonomous military units.
• Home automation.
• Industrial manufacturing lines.
• Space exploration.

Enabling a user to control an physical entity in a remote location provides great value in leveraging both skills and impact.  It allows the user to project into the location and perform actions or observe.

Implementation
When implementing a RaaS architecture it is important to understand the what is being enabled and the human risk factors involved.  A robot exists in the physical world with people.  Since the controller is physically in another location, the environment that the robot is operating in should be well understood if the robot is mobile or performs actions that can be harmful to a life form.

Information about the robot needs to be discoverable.  Using a common discovery method like a Robot Service Discovery Language or RSDL.  This would be similar to Web Service Discovery Language or WSDL, which is commonly used in SaaS web based implementations.  This allows the consumer to discover the following aspects of a robot.

• Name
• Location
• Status
• Sensors
• Connection Instructions
• Telemetry requirements

Performance is a critical factor in a RaaS implementation.  Because of response times telemetry data volumes this can be a challenge.  It is important that the experience feels and responds real time or near-real time.

Because RaaS is a direct interaction with a user and a robot, a limited amount of controlling user connections can be made.  Most services will only support one user and observation connections.  Or for more complex robots multiple controllers can be connected to aspects of the robot.  For example a robot controlled tank may allow a driver, navigator and a gunner to be connected to run aspects of the system. Connections are typically negotiated and secured to allow the controller to have exclusive connectivity to manipulate the robots sensors, servos and motors.

Limitation
The main limiting factor is network performance.  One of the limiting factors encountered today are available network bandwidth.  This can impact the usability and value of a RaaS implementation.  As new network technologies like are discovered or existing technologies are improved RaaS implementations will have dramatic improvements and new implementations will be possible.  Other factors that impact performance are encryption and compression for transmitting high volumes of data.

I have been doing architecture at many companies over the years. The most significant observation is that most companies really don’t know what architects do. I find this a bit shocking in one sense. Trying to understand why you would hire a highly skilled resource and have them function in roles not suited is hard to grasp, and a significant waste of resources. I sometimes relate this to the movie “Troy”. I see Achilles as the one of the most prolific combat architects of all time. He was one of the most skilled warriors on the battlefield. He was also a top notch tactician. There is a fine balance that is kept here.   The balance between knowing and understanding the art and then being capable of executing that art is what truly defines the architect.

When this fundamental balance is broken the architect becomes pulled into one of two directions that diminish the effectiveness of the role itself. I have seen many articles on the premise of whether an architect should code or not. The answer is quite simple, the architect must code. Fundamentally this is the skill that keeps the architect grounded in his/her ability to execute.

The ability to execute is what firmly plants the architect’s assertions in reality. It also provides a solid platform to earn the respect of peers, as well as, the development staff.   Respect in the ability to execute becomes essential to provide the other functions required to be an architect. It becomes difficult to push directions and practices if the grounding cannot be communicated and demonstrated in a fashion that is acceptable to a skilled developer. Imagine if Achilles could only talk about swordsmanship and not actually wield that weapon in a skilled manner. He may also be a tactician, yet the warrior skills do not exist. In its purist sense he could not be taken seriously when wielding that weapon in the presence of his skilled soldiers. He would lose.

But earning the respect of your peers and subordinates is only half of the responsibility. The other half is to earn the respect of those that rely on you to understand their visions. To design/architect the outcome in a positive, almost perfect manner. This encompasses the other significant function of the architect. To understand the customers goals and derive the true meaning of the overarching concerns. This in itself can be a very complex and daunting role. The need to be an ambassador and a respected advisor is crucial. This is the area where the trap of management comes into play.

Engaging in high level planning meetings and being involved in customer facing discussions to understand what needs to be expressed into software. These are essential roles of the architect. In many cases an architect can function as a skilled manager or business representative if required. But this is not a chosen path, but more a required skill to make the correct translations into the design. Remember that software is a very precise expression of business flow and execution. Done correctly it can provide great efficiencies that scale across a business. Done incorrectly, it can reduce or negate the efforts to create profitability. Drawing an architect into management practices and away from their core functions is a disservice to the company and its goals.  Achilles would report to the generals and the visionaries his impressions and interpretations of their plans. How they might create success or failure on the battlefield.  Had Achilles been drawn into the political ebb and flow of those he consults for, his advice might be skewed.  Spending to much time away from sparring would cause him to lose his edge in execution.

If the transitions are welcome to all parties then a good architect will recognize the risks and prepare them. We cannot forget that a primary function of an architect is risk mitigation in the design and implementation. Creating a disruption in the skill balance is a risk in itself. Having a skilled architect on your team creates a greater chance of both short and long term success with your IT initiatives. Understanding the meaning of that value of the position and preserving its intent is the responsibility of everyone that engages that position and when that balance becomes lost, it is the responsibility of the architect to communicate it.

Modern software projects tend to be very complex and require fast and efficient delivery cycles, that leave simple VCS systems lacking.  Even in small teams, ALM has many advantages.  I find very few cases where simply having a source control system is sufficient.

In the world of ALM, there are two approaches.  You can cobble together an ALM system from many tools or you can get an integrated solution.  I always prefer the later, because the cost of doing the tools integration is high.  In addition, it tends to create pockets of knowledge of the process workings and in some cases a single point of failure among the skill sets.  You can get integrated solutions from vendors like Borland, Microsoft or Serena.

There are cost differentials to consider.  Many of the ALM products or commercial and come with a price.  While you can probably get VCS, Defect, Project tracking tools to create an ALM process, you still pay for that in time and complexity.  A home built solution takes time to get off the ground and usually has that one guy that knows how it all works.  To everyone else it tends to be a mystery.

If your producing software, the quality can be directly impacted by the process that is applied to the production of the software.  Using an ALM tool can greatly amplify a software engineering teams ability to create a quality product.

Some of the benefits of ALM:

• Better collaboration and communication among teams
• Increased productivity and faster development through tool integration
• Improved quality and defect tracking
• Adaptability to business changes and market demand
• Improved project governance through visibility and transparency

Managing the life cycles around code are fundamental to leveraging your teams most effectively.  Everything that interacts with that code, from new requirements to maintenance support and defect corrections, can cause the code base to experience entropy.  There are already very complex process and problems and chaining effects of change that need to be mitigated.  Using tools that allow developers, testers and project managers to have visibility into the process and make adjustments quickly help to keep the product in a stable and manageable state.

As projects grow, the importance branching, merging and conflict resolution become extremely important.  And the ability to map artifacts to code and trace it through the process becomes vital to releasing features while maintaining existing features.  Planning and scheduling work against branches and communication with quality teams can be cumbersome when your process and tools are not integrated.

How you organize your teams and the tools they use can make or break the product you are trying to produce.  Simply using a VCS will limit your ability to be competitive in the marketplace.  He who has the best people and the best process wins.

For those heroic academics out that that just need simple little solutions to basic problems, here is just some playing around.  What’s crazy is that I have written so many lines of code over my career, that I just felt like writing these little silly blocks of code, to prove to myself that I my brain still functions.

Here is how one might sort an array without using the built in sort method:

Here is something simple that would break down cents into the least amount of coins, based on dimes and nickels and pennies.  I recently updated this using Lambda expressions.  If someone needed to do that:

And if you were in the mood to do some simple recursion, something we all have done in those scenarios where it makes sense.  This one sets a recursive limit and adds up the values as it goes along:

Enjoy!!!

Recursion can be a very useful operation if you need to dig deep into an object Hierarchy. If recursion is used in conjunction with Linq, it can be a very powerful way to extract collections or very specific items that you are looking for but don’t know the exact location to. There are a few simple things that I implemented to achieve this effect in my Theorem framework. I will break them down and explain why the particular technique was used.

One thing that I needed to do was establish a way to get at children on my base classes. BusinessBase is an abstract class that I derive all my business objects from, but it can be anything in your case. I added an interact to my BusinessBase class called IBusinessBase. Notice the ChildCollections being enforced here. That class will become one of the cornerstones required to make this all work.

Now, lets take a look at the ChildCollections class and see what it does. Its very simply really. It creates a collection of all the BusinessCollectionBase<> objects that I have defined as properties on my object. In this case you can substitute ListBase<> for List<>, which is a custom list implementation I use in Theorem.  This class simple acts as a container for the collections and exposes and object[] to contain all the items in the collection.  This important for the recursion to work properly.

The interface IChildCollections looks like this.  It cab be used to create your own custom collection containers in any way you like.

Once you have this all established we can move on to the extension method that will allow us to extend Linq in a way that will allow recursion on out the object models.  Simple create a namespace and add the following code.  The extension method takes advantage of a few very cool features of .net.  For example the yield statement and Func Delegate.

We are simply going to iterate over the IEnumerable objects of Type T, which I will demonstrate later.  The enumeration item discovered happens to be another IEnumerable collection then we will yield each item and re-curse if necessary.

I have a BusinessBase object in my framework that implements the IBusinessBase interface.  This forces me to create an implementation that looks like this.  In my case I wanted to constrain my ChildCollection to typeof(IBusinessCollectionBase<>).  By doing this, I am only extracting out framework collections, which is what I want in my case.  But you could very easily open this up to IEnumerable<> and or more for recursion.

Ok, so on to a use case for this code and a demonstration of the output.  Lets take an example from Theorem where we have a Group object that contains a collection of Groups as a property.  We will then re-curse the structure with very little code.  Here is a test method from Theorem.  The lines to note are highlighted that demonstrate the recursion call.

And here are the results.  You can see that I am specifically casting into group objects, because I know that is what I am working with in this case.  But I could very easily cast into BusinessBase if I wanted to and get items of all types.

test1
test2
test3
test4
test5
test6
test7
test8

As you can see, one simple line of code is all that you need to extract out all the items of a specific type to a collection that you can work with.  This has been tremendously valuable in many cases.  I hope you see the value as well.

In the very short time I have used PowerShell; I have found it very valuable.  I created an example that will demonstrate how  you can create a profile and have it run some custom script on start up.  It was quick and simple for me to put together.

The main demonstration will be a function that calls out to a web based XML service, hosted by the National Oceanic and Atmospheric Administration (NOAA).  If you have ever gone into the great outdoors in North America, you are probably familiar with NOAA radios and the value their service provides.  I wanted to make a quick integration to pull weather based on a NOAA station ID.

Here is the completed PowerShell Profile – Profile.ps1 file I created for this demonstration.  Just download and place this file in your %SystemDrive%\Users\{AccountName}\Documents\WindowsPowerShell folder.  Next time you start PowerShell it will be active.

You may need to run this command to allow PowerShell to execute the scripts.
Set-ExecutionPolicy RemoteSigned

The main script we care about here is this:

There are a couple lines of interest in here.  The one that actually makes the call out to NOAA.  This is the call return the XML that we will parse through for display.  you can directly hit this service for your location at http://www.nws.noaa.gov/alerts/.  This is where this example gets its feed from.

If you look at the about lines, that is where the magic happens.  $a represents a new object created by powershell.  You can find more information on this here.  PowerShell has the ability to create objects and use them,  unlike batch files.  The next line calls the service and gets the response as a string.  It then places it into am XML type for use.

The above lines are also very interesting to note.  Since we specified the return string as type XML literal, the data that was loaded is addressable directly though the System.XML.XmlDocument object.  The syntax is very simple to write and it makes it easy to drill down into the XML document.  In my case I am simply fully qualifying the path the the element that I wish to pull data from.  You can get as fancy as you want here, even iterate through collections if needed.

Take a look at the out this produces when you install it.  Simply running the command; w at the prompt will produce the current weather for the default site provided in the script.  Running the command; w KDEN, will produce output for the Denver area.  Visit the link provided to NOAA in this blog to find details on a weather site your interested in.

I hope you found this little experiment with Microsoft PowerShell useful.  It helped me better understand the capabilities and usefulness of the tool.  I don’t think you will catch me without PowerShell open in the future.  If you really want to get some juice out of your PowerShell you can also install PowerGUI, which is a powerful scripting management IDE for your PowerShell scripts.

Enjoy!

There are scenarios when you want to return raw XML from a service call.  If you have code from a legacy asmx service, WCF needs some minor adjustments to support returning an XmlDocument or an XmlNode as a result.  I’ll show you how to get that code running with little effort.

Here is a very simple example of a WCF service contract.  Please note that the return type and parameter are specified as XmlElement and the method is decorated with the XmlSerializerFormat.  The decoration is necessary for WCF to use the System.Xml.Serialization.XmlSerializer instead of the default System.Runtime.Serialization.XmlObjectSerializer to serialize the result.

Now you need to implement the code for the service.  For the sake of simplicity, I am going to load and XmlDocument and echo it back as the result. The key is to return the documents DocumentElement property as the result.  DocumentElement and XmlDocument both implement the IXPathNavigable interface through their inheritance hierarchy.

If you implement this code you will see that you can continue to use XmlDocument objects as input parameters and results with very little changes to your existing code.  If you use XML to transfer data you should ensure that you enforce integrity in the contract by some validation mechanism, such as xsd validation.

I found a simple article to get ADAM up and running on your Vista box, because I wanted to adapt my framework to LDAP.  You can find it here. Its a good article, but it only got me so far. I also modified the instructions slightly. Here is what I did, which is very similar to the blog reference.

• Install ADAM on a non-Vista machine. I installed this on a Window Server 2003 SP2 machine I already had running.
• Copy the %WINDIR%\ADAM folder from the installed box to the same location on your Vista machine.
• Create a new registry key called HKLM\Software\Microsoft\Windows\CurrentVersion\ADAM_Shared
• Under this key, create a new Multi-String value called "SharedFolders"
• Now, run adaminstall.exe from your %WINDIR%\ADAM directory and follow the wizard. Make sure you use an account that has Admin rights or the LDIF imports will fail.
• If the LDIF imports do fail, you can run a manual import using the ldifed.exe application in the ADAM directory for manual imports.
• Copy over and repaint the Menu items so you have the proper shortcuts
• In addition, you should also copy over the %WINDIR%\Help\adam.chm file to the same location on the Vista box.

This should cover the basics for getting the ADAM instance on the box. But it was running in the MMC could not create the snap-in error message when I tried to run the ADSI Edit mmc snap-in. This is caused by the ADAM-ADSIEdit.dll file not being registered with windows under the Admin account. Do the following to get this running.

• Click startmenu/All Programs/Accessories
• Right-click the "Command Prompt" and choose to "Run as Administrator"
• In the command window change to the %WINDIR%\ADAM folder
• run regsvr32 -s ADAM-ADSIEdit.dll

This will register the assembly as administrator and give it the proper rights to create the snap-in. If you follow these steps you will have a working ADAM environment on Vista.