This repo is both a library and the code for a robot I'm building. Made by Jaiden.

This project is supposed to be sort of a capstone project for my senior year of high school... but on a personal level (rather than for school). It's a fun project that I'm having a great time exploring all sorts of areas from robotics to neural networks.

For everything, the following prerequisites are needed:

• Python 3.12
• npm >= v9.6.7
• Java >= 19

For individual components, look at each of the component sections in this readme for their own prerequisites.

To clone the repository, run

git clone https://github.com/JaidenAGrimminck/bot.git

the bot in the beginning phases of self-driving/object-avoidance

an example of the simulator using cross-platform control (network in Python, simulator in Java). video sped up 4x

a quick video of the bot being cadded

a video of the lidar working in the web dashboard

Since this repo is made up of several different components, this section details the different parts of the repo individually.

Need Java >19 installed to run.

If you haven't already, clone the repo via

git clone https://github.com/JaidenAGrimminck/bot.git

In the controlling folder, run ./gradlew clean then ./gradlew build.

Then to run, run ./gradlew run.

See the Java Docs here!

You should create your robot classes in the me.autobot.code.me package. From here, your initial code should look like:

@PlayableRobot(name = "My Robot")
public class MyRobot extends Robot {
  @Override
  protected void setup() {
    // called at the beginning, when the playable robot is started

    // -- setup your devices --
    registerAllDevices();

    // -- connect to serial/i2c/etc --
  }

  @Override
  protected void loop() {
    if (!clock().elapsed(2000)) return; // sometimes preferred to allow i2c/serial connections to fully establish before continuing

    // called every tick when the playable robot is running
  }

  @Override
  protected void stop() {
    // called when an error is thrown or you click "stop" on the dashboard
  }
}

From here, you're able to get started!

Topica is a fast custom communication protocol with Topic-like architecture over WebSocket. It's fast and efficient, and requires minimal download to use.

The Topica server is automatically started when the robot is started. By default, the server is hosted at port 5443.

There's a few settings/default topics that are set as a part of the server:

• verbose - default value: true - for messages in the console when a new topic is made.
• strict - default value: false - new topics cannot be created through the web interface (JS/Python libraries), and must be created through the code.
• last_topic_created - A timestamp of when the last topic created was.
• rest_port - default value: 8081 - The port of the Topica REST API.

A list of Topica topics are accessible at the REST API located at the rest_port (default: 8081). This server has two endpoints:

• /api/v1/robots - A list of PlayableRobots avaliable.
• /api/v2/topics - A list of Topics avaliable.

Additionally, for each Topica client (inaccessible for the Topica host) are read-only Topics for identification:

• /me/id - An UUID to identify the client.
• /me/nickname - A randomly generated friendly nickname to easily identify the client. Do NOT use for client identification or manipulation, as nicknames have the potential to be not unique, rather use /me/id.

The library also adds on the following endpoints:

• /robot/selected - name of the PlayableRobot that's selected
• /robot/status - 11-byte list for robot status.

The following data types are valid:

• BYTE: 0x01,
• INT16/SHORT: 0x02,
• INT32: 0x03,
• INT64: 0x04,
• LONG: 0x04,
• FLOAT32: 0x05,
• DOUBLE/LOAT64: 0x06,
• STRING: 0x07,
• BOOLEAN: 0x08,
• BYTE[]/CUSTOM: 0x09

There's a few ways that we can create Topics within the Java library.

First, we can create a Topic with just instantiating the class.

Topica.Database.Topic topic = new Topica.Database.Topic("/tmp/timestamp", 0L)

This is inheritly risky if we don't have strict mode on. What if the Topic is already created by a client? What if we already created the topic within the code. We can thus check if the topic is created already as such:

Topica.Database.Topic topic = null;

if (Topica.getDatabase().hasTopic("/tmp/timestamp")) {
  topic = Topica.getDatabase().getTopic("/tmp/timestamp");
} else {
  topic = new Topica.Database.Topic("/tmp/timestamp", 0L);
}

But this is inefficient (and annoying to code)! Thus, if we know the type, we can thus do the following:

topic = Topica.topic("/tmp/timestamp", Topica.LONG);

Topics can be used in a variety of ways. For example, if we have robot data that we want to share with the clients, we can bind it to a supplier as so:

// an example of binding a long topic to the current time.
topic.bind(() -> {
  return System.currentTimeMillis();
});

These update every 0.1s and can be adjusted with bindLoopTime(long interval) (loop times are topic specific, and not global).

We can also subscribe to a topic to get data every time the topic data is updated, as so:

topic.subscribe((o) -> { // o is typeof object
  long l = (long) o;
  System.out.println("Current time: " + l);
});

If we have another method, we can also pass it through:

void test(long l) {
  System.out.println("Time one second ago: " + (l - 1000L));
}
//...
topic.subscribe(this::test);

We can also create a callback as so (when the value updates):

topic.addCallback((topic) -> {
  // ...
});

If we want to update the topic data, we can do it as so:

topic.update(10L); // multiple valid type inputs

If we want to get the value, there's a few methods to do so depending on the type:

long c = topic.getAsLong();
// or, for example
topic.getAsDouble();
topic.getAsInt(); // etc.

The Python library is located at topica/topica.py and depends off of the websocket package, struct package, and numpy.

We can import the library as so:

import sys
sys.path.append('path/to/folder/topica')

from topica import TopicaServer

Then, we can create a connection to the TopicaServer:

server = TopicaServer("the.robot.ip", 5443, verbose=True)

Verbose allows to know if we're connected to the server via console.

We can update values as so:

server.set("/value/random", 10)

There's no need to specify type, but if the type is invalid (not supported), then an error may be thrown.

We can also subscribe to values as so:

server.subscribe("/value/random", interval_ms=100, callback=lambda x: print(x))

Or, we can do a single value request:

server.get("/value/random", onResponse=lambda x: print(x))

We can listen to when the server is open/closed/etc, such as:

def onOpen():
  print("Connection is open!")

server.onEvent("open", onOpen)

The valid events are open, close, error, and reconnect.

The JavaScript library is located at site/topica.js and depends off of the ws package (and the internal struct.js file).

We can create a connection as so:

const { TopicaServer } = require("./topica.js");

const topica = new TopicaServer("the.robot.ip", 5443);

This works similarly to the Python library.

We can get all the valid topics as so:

const topics = await topica.getTopics();

We can subscribe to a path:

topica.subscribe("/get/the/topic", 100, (value) => {
  console.log(value);
})

We can set a topic (note: we need to specify the type due to JS's behavior as a typeless language):

topica.set("/random/topic", 5, Topica.Type.INT);

We can get a topic:

const value = topica.get("/random/topic");

We can also await for an event:

// valid events: [open, close, error, reconnect, newtopic]
topica.onEvent("open", () => {
  console.log("Server open!")
})

The (legacy) WS server is hosted on the robot at port ::8080.

The WS server is hosted on the robot at port ::8080.

The convention for the WS server is as follows (for sending TO the server):

Additionally, for the server to send TO the client, the following convention is used:

// When a speaker sends the message: [0x02, 0xD5, 0x01/0x00]
WSClient.registerCallable(0xD5, new RunnableWithArgs() {
    @Override
    public void run(Object... args) {
        // Do something with the args
        int[] data = Mathf.allPos((int[]) args[0]); // Convert the byte data from -128 to 127 to 0 to 255
        WSClient client = (WSClient) args[1]; // Get the client

        if (data[0] == 0x00) {
            System.out.println("Hello world!");
            client.send(new byte[] { 0x03, 0x01 }); // Send a custom response back to the client
        } else if (data[0] == 0x01) {
            System.out.println("Goodbye world!");
            client.send(new byte[] { 0x03, 0x00 }); // Send a custom response back to the client
        }
    }
});

import struct
doubleList = next8Bytes() # The 8 bytes that represent the double
double = struct.unpack('>d', bytes(value))[0]

let doubleList = next8Bytes(); // The 8 bytes that represent the double
doubleList = doubleList.reverse(); // Convert from big-endian to little-endian
const double = new Float64Array(new Uint8Array(doubleList).buffer)[0];

example video of a trained bot navigating a course with 3 distance sensors

Need python3.12 to run this program, alongside the numpy and pygame libraries.

If you haven't already, clone the repo via

git clone https://github.com/JaidenAGrimminck/bot.git

In the training/local-train folder for the repo, run:

python3 -m pip install requirements.txt

To run, run via:

python3 run.py

The default behavior of this is to run the presaved models in the folder. If you want to train a new model, set do_evolution to True. Set the total_num_robots to how many robots you want per generation.

The site/frontend is what can be used to diagnose the robot's current status, condition, and remotely control/edit the robot via the page. The site is built on top of express and socket.io, allowing for fast and live communication with backend components that communicate with the robot via ROS/sockets.

The site is fully modular as well, similar to React but very lightweight in comparison, taking <4MB for the node-modules, allowing for easier deployment onto something like a Raspberry Pi.

The site also utilizes socket.io's websockets to be very fast and efficient, an upgrade from a REST API to using websockets saw nearly 6ms improvement per request, allowing for fast and efficient data transfer.

Need npm and node.js installed, from here.

If you haven't already, clone the repo via

git clone https://github.com/JaidenAGrimminck/bot.git

In the site folder for the repo, run npm install

To run, run via node server.js in the site folder.

The site automatically can populate and import components via the <req-use> component.

<req-use elements="panel,dropdown" id="n"> </req-use>

example importing panel and dropdown components

Due to the modularity of the site, via a few scripts it automatically looks at the /frontend folder and searches for the corresponding components.

If it finds it, and it finds the .js file corresponding with the name, it's automatically imported.

Then, in each of the files, the function RawElement can be called to import the raw .html files of each component into the page, which can be manipulated.

Additionally, corresponding .css files are also automatically imported if they exist.

If the file depends on an element, for example panel depends on the component graph, a need.txt file can be included in the panel folder in the frontend, containing a comma-separated list of the components that need to be imported.

This is pretty much a lightweight version of React, check out the site/public folder for examples of how this can be used.

Here's some examples of the frontend:

This project is licensed under the MIT License. See the full license in LICENSE