Zakhar the Robot

A companion for your cats and dogs.

Public Chat
Similar projects worth following
The Zakhar project combines our understanding of biology, psychology, and animal behavior with robotics to create a unique and intuitive approach to creating a robot companion for pets and, ultimately, for humans.

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.

  • Bad Architecture, Good Architecture

    Andrei Gramakov10/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:

    Meanwhile, I continue working on my more mini project LeOn which is the source of our current discoveries about the project architecture:

  • Moving a Mountain... with a Lion?

    Andrei Gramakov09/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 🙂

  • Zakhar is a Pet Companion

    Andrei Gramakov12/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 Gramakov09/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 Gramakov08/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.




  • Sensor Unit with qCAN Support is Merged!

    Andrei Gramakov08/17/2022 at 19:06 0 comments

    Updated code for the Sensor Unit with qCAN support is merged and documented!

    Read more »

  • New Zakhar Face Module

    Andrei Gramakov08/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 Gramakov07/21/2022 at 19:50 0 comments

    Not Only Two Wires

    I2C makes robots sad

    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 Gramakov03/07/2022 at 21:25 0 comments

    Behold a new project site!

    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:

  • Zakhar CAN tool

    Andrei Gramakov02/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

    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:

    Schematic: will be added later (


View all 54 project logs

Enjoy this project?



Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates