High Level Logic (HLL) Open Source over leJOS

[rogerfgay]

High Level Logic (HLL) Open Source Project

Blog entry: Lego Mindstorms NXT Robots (leJOS)

(Although I still get a USB related error.)

[rogerfgay]

The prototype for HLL was finally built in 2007 as part of a larger robotics project. It didn't get so much attention, because Microsoft released its Robotics Studio just as the project started and the main technical team decided to focus attention on that. Nonetheless, a small experimental prototype was built in Java SE with a browser-based GUI and simple robotics demo; flushing out design details. That code was cleaned up and used to begin the open-source project.

High Level Logic (HLL) is kind-of what its title sounds like it should be about - high level logic. The open-source project is still in a relatively early stage, but HLL has a long history. Its first version (as a concept, and idea) came in the mid to late 1980s back when "rule-based expert systems" were being commercialized as artificial intelligence. Rule-based expert systems technology ran into serious limitations. One of the particular problems was that applications were limited to very narrowly focused domains ... like you couldn't run a farm with one, but you could design one to tell you if your pigs have hoof and mouth disease. First concept HLL could provide a higher level logical framework for using multiple expert systems, exchanging information between them, etc.

There are three layers to the standard HLL machine, an executive, manager, and expert layer.

The executive is in charge of communication with the outside world including other HLL installations, anywhere in the world - and like, for example; one for your robot command center and another above the robot's control system - giving both your command center and the robot their own high level logical intelligence. They decide whether to process command input and if so, pass the task on to the management layer.

Manager(s) follow plans to implement tasks (like a project manager), so a command assigned to a manager can be something much more complex than turn left, etc. A manager uses a plan constructed for implementing a task, finds the resources needed, and sends individual tasks to the expert layer.

The expert layer invokes "experts" - i.e. any specialized code needed to implement the individual tasks. These can include both direct "low level" tasks (relative to High Level Logic) like "turn left" or they can themselves be something like a rule-based expert system or any other program you've written of whatever complexity and purpose. An "expert" is a program with "specialized" functionality ( --- "expertise" in HLL parlance).

Back then, this was all in the world of advanced research. Fast forward to the 21st century, and there's just a huge amount of existing technology that makes it easier to build a much more powerful version. The first being built is ready for application development, but there's more work needed to make it nicer. For example, "plans" are currently implemented as (socket) server protocols, just like any protocol would be written. Good progress is being made on XML processing however, that will allow plans to be constructed in XML files. Then I'll even get a simple-rule processor constructed for HLL (I hope) or something like JBoss Rules can be used (very powerful, written in Java, easy to integrate into Java programs).

The current version is written entirely in Java SE, intentionally. It's not that big yet, and has an API document, but so far only a little bit of tutorial (sufficient if you're a serious Java programmer - I think - and also get the concept ...)

There's also a description of Java EE version that will, among other things, have a different way of communicating between layers and other HLL installations. Now it's simple sockets. It's the way socket communication is used that makes the system "loosely coupled", flexible (reusable for a wide range of applications), and capable of using distributed components easily (it's built in - just use the sendCommand() method). It's the loosely coupled approach plus the fact that messages are received by a system capable of dealing with specialized "high level" tasks that makes this an agent system.

[rogerfgay]

Thought on an interesting application.

Let's say you set up an environment for one or more LEGO robots. It could be for robots that can move things from one place to another - for example - let's say that. (And this might correspond to some robot competitions as well.)

Provide a map of the environment with all its objects and important characteristics (like, this is where the balls are stored, etc.) It doesn't need to be a three dimensional bit-map or anything like that; just a set of objects, locations, characteristics.

Provide specialized programs for moving from place to place and performing tasks - like pick up a ball, drop ball, etc.

Use HLL plans to describe the sequence needed to accomplish high level tasks like go to place1 and get a ball, then go to place2 and drop the ball, etc.

You could also couple this with a strategic plan for getting as many balls as possible or whatever .... then let it go autonomous.

[rogerfgay]

The concept of High Level Logic software has not been easy for me to describe in a few short sentences, nor even in a technical brief. I'm trying a story telling approach. There are now two short first draft "chapters" on the history of the idea that also introduce the software design - in their own way.

This is a different approach to explaining software. Please feel free to comment.

Chapter 1 starts here: http://highlevellogic.blogspot.com/2010 ... ter-1.html

[rogerfgay]

Getting closer and closer to version 1.0 every day. Scenarios like this won't be difficult at all. Easy stuff.

http://www.physorg.com/news/2010-11-eth ... video.html

[rogerfgay]

When Will We Have Artificial Intelligence?

http://highlevellogic.blogspot.com/2010 ... icial.html

[rogerfgay]

I've been thinking about how easy it will be to set up complex robotics scenarios with HLL. My focus currently is on bringing HLL to version 1.0. Those of you who've read the blog know that - you can build applications with HLL now - but you'd find yourself writing enough Java that - except for the ability to easily communicate with other HLL units anywhere - and a great start on a browser-based GUI for robots (pushes to SVG dynamic graphics that can show your robots position) .... you might wonder why you're doing it. OK - if you want to control your robot from anywhere through a browser - but maybe you don't need that right now.

Anyway - just wanted to be sure I'm not giving a false impression before I go on - actually have some good thoughts in mind. Version 1.0 isn't that far away - but it's not there yet.

I was thinking about how easy it's going to be - in combination with LeJos, to set up complex scenarios. With HLL, you can do the building from the other direction - i.e. top-down - which should be implied by the title of the software "high level logic."

So, what I have for a demo, is a robot with a High Level Logic (HLL) controller on a computer, and the browser-based GUI Command Center (loosely) connected to its own HLL. A command is issued from the GUI, which is processed by the Command Center HLL and then sent to the robot's HLL. The robot's HLL sends messages via a simple "expert" to the robot itself.

I built this demo while working on the HLL prototype. video: http://highlevellogic.blogspot.com/2010 ... video.html

It uses a simple robot simulation that sends new position information back. But now that I have a Lego robot built, I want to change the demo so that the robot's HLL uses an "expert" that makes the connection to the LEGO robot using LeJos.

Overly complicated? No, not if you consider what can be done with this set up.

On the robot side, there would be sufficient software to take care of some basic commands like move forward by x meters or continue x operation until. The HLL part would contain the higher level plans. I'm thinking along the lines of setting up a scaled logistics operation of some complexity. The HLL will carry the plan for the robot operating in this environment - carrying out a complex set of tasks.

But wait - there's more.

Let's say that we need to issue a command to the robot that the robot does not know how to carry out. In the real world, this can happen when you have a new robot out of the box, that hasn't been programmed for the activities of the site, or you have a new activity and haven't told all your robots how to do it yet.

You'd issue the command through the Command Center, as usual, and the Command Center's HLL would pass the message to the robot's HLL as usual. But the robot's HLL would check to see if it can carry out the command and respond with a refusal on the grounds that it doesn't know how to do what it's being asked to do.

The Command Center's HLL responds by delivering the needed resources to the robot's HLL.

For a new robot out of the box, so to speak (i.e. only primitive commands supported by its HLL - we assume all robots have HLL right out of the box) the robot will first need Java and HLL components needed to execute whatever will be within its domain (verses a sequence of commands issued by the Command Center HLL), and then it may also need a map (for example) of its new working environment.

There's the sketch - and I'll want to have all of this well supported with version 1.0 of HLL. This is in fact, a primary reference application for HLL.

Since I'm new to LeJos and must spend the bulk of my time working on HLL, I'm wondering if there's anybody out there who might find this interesting enough to consider helping out with LeJos expertise (and perhaps even some coding).

[rogerfgay]

Websocket Server Demonstration