Zakhar the Robot

The Zakhar project is a unique and innovative approach to robotics and human-robot interaction that utilizes our (or just my 😅) understanding of animal behavior and the human and animal brain to create a robot companion for dogs and cats. The ultimate goal of the project is to create a working product that can be a basis to eventually create a human companion.

The robot's operating system (ROS-based) is designed to mimic the way the human and animal brain functions, with three main programs:

consciousness
instincts
reflexes

The consciousness program is responsible for higher cognitive functions such as decision-making and problem-solving and is similar to the prefrontal cortex in the human brain.

The instincts program consists of sophisticated behavior patterns that can suppress the consciousness and take control of the robot's body in certain situations, much like the amygdala in the human brain which is responsible for emotional responses and the "fight or flight" instinct.

The reflexes program consists of simple body responses to external stimuli, similar to the spinal cord in the human body which is responsible for reflexive responses to stimuli.

The instincts program interacts with the consciousness program through the Emotion Core, a piece of software that simulates the endocrine system and represents a table of hormones that can be affected by sensor data and by the consciousness and instincts programs. The endocrine system in the human and animal body is responsible for producing and secreting hormones that regulate various bodily functions and can affect behavior and emotion. By simulating this system, the robot is able to experience a range of “emotions” and behaviors that are familiar to its human and animal users.

This familiarity with emotion-controlled behavior in theory should provide a simple and understandable user experience for all time of animal users (pets and human beings). The project aims to utilize this animal-like user experience to create a final product: a robot companion for cats and dogs, with two sets of instincts and main programs tailored for interaction with each species. The physical shape of the product is currently being considered and will be developed in future development stages.

The project is open-source and well-documented and published under the GPL3 license.

Project Logs

Collapse

Bad Architecture, Good Architecture
Andrei Gramakov • 10/12/2023 at 20:02 • 0 comments
After a couple of months trying to make something meaningful of my project, we with my small team have made a soft reboot. Why do we need it? The architecture is BAD. Before starting learning software architecture, I was just trying to mimic what I've seen working in Espressif and Rockwell, I was trying to follow best practices of Python, ROS and C++. I sounded like a good idea, and when I tried to add people to the project - it got stuck.

What problems did we face?

So here a list:
1. We had a nice idea, but the closest milestone was miles away.
2. The idea was nice, but not precise. What the pet companion should do exactly?
3. We had my documentation that does describe the project architecture well enough. And even myself was not able to explain everything, because I just forgot a lot of things.
4. We had a lot of dependencies by default, so everyone why wanted to develop something had to understand everything before start to develop.
Why did we have all this problem?

Because I started from the middle. I wanted to build something using particular technologies implementing a new technology, and did not have the clear vision of the result.

It was a research project and as it turned out it's very difficult to convert it to something more substantial.

The Solution

We've decided to split the work into intermediate prototypes that should do something particular. I will rebuild the architecture from scratch, taking only useful pieces of my monstrous legacy. We've started from the Use Case scenario. The use case of our first iteration is the following:
1. The user turns on the robot
2. The robot starts to explore the space using a camera and microphones
3. If it recognizes a pet (cat or dog) it moves closer to the pet
4. When it is close to the pet, it makes a sound.
That is it. The diagram looks like this:

Here is our current phase documentation:

https://zakhar-the-robot.github.io/doc/docs/architecture/phase-1/

Meanwhile, I continue working on my more mini project LeOn which is the source of our current discoveries about the project architecture: https://hackaday.io/project/192732-leon
Moving a Mountain... with a Lion?
Andrei Gramakov • 09/14/2023 at 21:47 • 0 comments

This project is really heavy. It grew organically and need a revamp to be manageable and fun.
I started a new project to entertain myself and to kick this one, It is called LeOn. LeOn is a simple robotic toy for cats, but it supposes to contribute to Zakhar. Main features of the LeOn project:
🔷 Architecture-oriented
🔷 Result-oriented and minimalistic
🔷 Integration-oriented
🔷 Reusable in my other projects
All features are supposed to accumulate best practices and solutions, so they can be integrated to Zakhar back. Consider it a mini prototype 🙂
https://hackaday.io/project/192732-leon
Zakhar is a Pet Companion
Andrei Gramakov • 12/29/2022 at 15:27 • 0 comments

Last year was tough but also productive. Several of my friends had joined the Zakhar team and we will try to build a real product.
We've come up with the idea of creating a pet companion! Dogs and cats only for now 🐶😺. (Check the updated project description). We will be moving towards this idea and the project will remain open-source, so even when we finish you will be able to build your own companion from sources!
There are a lot of things that should be done here and we going to entertain you with our test videos. For now, check out the ears that I 3D printed for the robot!
Zakhar Brain Service
Andrei Gramakov • 09/18/2022 at 21:16 • 0 comments
Yesterday I merged a big software update to the Zakhar’s Raspberry Pi Unit - brain_service.

The update brings a service providing the robot’s status (network, OS status) and access to the CAN bus for many simultaneously connected clients. Also, the service tracks the presence of other robot Units on the CAN bus.

There is another service shipping with the same repository brain_service_display. This service connects to brain_service and shows some important information on a small OLED display:
- f - Face Unit
- S - Sensor Unit
- m - Wheeled moving platform (“Motors”)
- t - Service Unit (“Tool”)
Read more »
Brain Software Architecture
Andrei Gramakov • 08/31/2022 at 19:28 • 0 comments

Before updating Alive OS to support qCAN (my CANbus based protocol) I have the last thing to do. To simplify my live in future I need a CAN publisher that can publish messages to many subscribers. My main subscribe of course is AliveOS but also to display information about connected devices I need a second subscriber - a service listening only qCAN Present messages.

To do it I will use a ZeroMQ protocol - an extremely supported and documented for many programming languages standard. I’m going to update my brain_service to support the protocol and it will be responsible for all interaction with Raspberry Pi.

Repositories:

- https://github.com/Zakhar-the-Robot/brain_pycore
- https://github.com/Zakhar-the-Robot/brain_service
(original: https://blog.agramakov.me/posts/2022/08-31-brain-software-architecture/)
Sensor Unit with qCAN Support is Merged!
Andrei Gramakov • 08/17/2022 at 19:06 • 0 comments
Updated code for the Sensor Unit with qCAN support is merged and documented!
- Source code: https://github.com/Zakhar-the-Robot/io_sensors
- Documentation: https://zakhar-the-robot.github.io/doc/docs/systems/io_sensors/
Read more »
New Zakhar Face Module
Andrei Gramakov • 08/07/2022 at 21:05 • 0 comments

The new Unit is based on the ESP-Wrover-Kit and uses a TJA1050 module for CANbus communication.

It is compatible with the qCAN protocol (described on the Zakhar main page) and can show 5 facial expressions: Anger (0x32), Sadness (0x34), Pleasure (0x33), a Blink (0x31), and Calm (0x30).

To control it you should send a CAN message with an expression code using a 125Kbit standard CAN frame and with the message id ending with byte 0x4. E.g. send a message with ID: 0x004, data: 0x33 to make Zakhar happy 😍.

Read more on the Zakhar main page.
CAN Bus and a New Simple Protocol
Andrei Gramakov • 07/21/2022 at 19:50 • 0 comments
Not Only Two Wires

It’s been more than two years already since I started working on my robot Zakhar. The Zakhar 1 was built out of Lego and relied on I2C communication between modules. It was a nightmare because as it turned out each MCU developer has its own understanding of how a developer should interact with the I2C unit. What I wanted from the interface:
- Main/secondary nodes interaction
- Understand what devices are in the network
- Send commands
- Receive sensor data
Read more »
New Site! Repositories Reorganization!
Andrei Gramakov • 03/07/2022 at 21:25 • 0 comments

Behold a new project site!

https://zakhar-the-robot.github.io/doc/

It is not fully ready yet, but I hope it will help to organize the project and develop it faster and more efficiently.

Also, I've created an organization for the project on GitHub. All repositories will be transferred there: https://github.com/Zakhar-the-Robot
Zakhar CAN tool
Andrei Gramakov • 02/06/2022 at 13:16 • 0 comments
Finished yesterday a Bluetooth device for CAN bus monitoring. Need it to continue the integration of CAN into the Zakhar communication (closer Issues is https://github.com/an-dr/zakhar_platform/issues/12).

It serves two purposes:
1. Remote access to Zakhar's data flows
2. It is a node on the CAN bus, so all devices will get ACK response and won't fall into the error state
The data is printed in the CSV format, so it is easy to analyze.

The code is dependent mainly on:
- https://github.com/an-dr/zklib_arduino_canbus - it follows the Zakhar CAN network convention (https://github.com/an-dr/zakhar/blob/master/docs/canbus.md) but without requests implementation for now.
- https://github.com/an-dr/arduino-mcp2515 - a slightly modified version of popular CAN library for Arduino (https://github.com/autowp/arduino-mcp2515)
Sources: https://github.com/an-dr/zakhar_tools
Schematic: will be added later (https://github.com/an-dr/zakhar_tools/issues/4)

[https://www.facebook.com/groups/zakhar]