Hi Jiarui, pardon me for my delayed answering. I missed the notification somehow. I can upload the application part of the project. This might help to get an understanding of the communication. Here you can find the sim2real transfer of the neural network gait controller: https://github.com/ger01d/opencat-gym-sim2real Since I switched of performance reasons to BiBoard, this won't work with NyBoard or needs adaptions. Gero

Hi @MW Mercury I answered you on GitHub https://github.com/ger01d/opencat-gym/issues/2 Short answer: The x-position of the can be read out in simulation. The difference of the x-position in the previous and current steps provides the information, how far the robot moved forward. Gero

Yes that's true! Training a proper gait is a quite empirical process. You can only adjust training behavior by balancing reward and penalty. You need to check how the this effects the outcome and adjust accordingly. And believe me, this gait is one of the less weird ones. But playing around with the reward/penalty gives you the possibility e.g. to reduce unwanted behavior like slipping on the ground, shaking of the joints and the base body stability. And that makes experimenting interesting. I'm certain that this gait can be further improved.

I finally found some time to push further on this project. I updated the simulation model to better fit the actual mechanics of Bittle and trained a walking gait controller via Reinforcement Learning. It has been very beneficial to use the BiBoard, thanks for that RZ, because it significantly reduced the latencies in the communication of the serial port and the execution of the commands. First you can see a video of the walking gait of the simulation model. It is important to say, that Bittle is fully controlled by a neural network, with two hidden layers of 256 nodes each. The training was performed with the PPO algorithm. Next this controller was applied to Bittle equipped with the BiBoard. The data is transmitted via USB and the serial port from a notebook. Bittle sends the current motor angles and the gyro data and this data is processed by the neural network to generate the next motor angles - let's say the next step. In the next days, I'm planning to update my repository on Github and will share the link.

Hi and thank you for the advice and the example. I'm going to take a closer look at the implementation. The current bottleneck is the nature of the serial port, that sending and receiving cannot be done simultaneously - so this transfer just needs to be sufficiently fast. The primary goal is to reduce latency to that point, that the time for data transmission and execution of the movement is much smaller than the time for Bittle's physical movement due to gravity. At first I think I'll give it a shot with your newest version of OpenCat and look how far I get with the NyBoard and if latency is better than in my modified OpenCat version. I also had the ESP-based BiBoard in mind to further speed up the processing and minimizing latency. So thank you very much for the offer. I'll come back to you on this via mail.

At the moment I'm still using a modified version of OpenCat from @Alex Young. Data transfers take up to 8 ms. At the moment one step (reading sensor data and moving all legs at once) looks like this: 1. Requesting Gyro data (~4 ms) 2. Receiving Gyro data (~4 ms) 3. Calculation of next leg positions (< 1 ms) 4. Sending new leg angles to Bittle (~4 ms). I don't know ,if the 'K' token provides a significant lower latency? It would be also helpful to read the gyro data in parallel to get rid of the 8 ms delay each cycle.

Hi there, I was able to continue working on this project a little and created a walking gait controller via reinforcement learning, that I was able to successfully run on Bittle. The controller uses the gyro acceleration, the gyro angles and his leg angles for making steps forward. In this setup, Bittle receives the leg angles from the trained neural network, which uses the gyro information that are sent from Bittle. I think that this latency limits the walking gait smoothness and speed somehow. In the next days I will upload the new code on my repository: https://github.com/ger01d/opencat-gym Here you can see the simulation model, that is controlled by the trained neural network: This is the neural network running on an office notebook and controlling Bittle via the serial port; (I know, it feels kind of painful, how Bittle hits the ground with his elbow ...)

@Harry Xu Basically you can divide the movement into two parts: the horizontal movement (blue) and the vertical movement (orange) of the paw. This is mostly what you see, when you start the script. The vertical movement is a cosine and 0 and the horizontal movement is a piecewise defined sine. The x-axis is the number of the frame. This pattern is the same for all four legs, the only difference is, that each leg starts at a different frame. This is what is called the phase shift and it's [0, pi/2, pi, 3*pi/2] for the legs [Right Arm, Right Leg, Left Arm, Left Leg]. buildGait() generates the plot and functions below which will then be handed over to the kinematic model. As you can see the forward movement (lifted paw) happens in 25 % of the time for one period (leg -1 to leg -1). I hope this makes a few things a little bit clearer.

@westring Did you find a solution to this or is this still an issue?

I updated the code on github. Now it should work again.

@Jason I think there has been an update for ikpy. I have to check this. Thanks for the notification.

@westring You can take a look at my testing code in OpenCat.ino line 264. I implemented the checkBodyMotion as a protothread, so recovery from falling over should still work fine.

@westring The problem is, that you use the delay() function. This stops your microcontroller, so there is no further processing possible. Use PT_SLEEP(pt, 500) instead, this pauses only the ultrasonic thread and the rest like reading the serial port will continue.

@westring could you share your code, please?

@westring Does the remote control work?

@westring I think you're flooding the serial port by sending the distance information to frequently. If you're using protothreads, you can simply increase the process sleeping time to e.g. 500 ms via PT_SLEEP(pt, 500).

@westring You have to define the TRIGGER and ECHO pin according to your wiring. If you connect directly to +5V on the Nyboard, there is no need to define VCC. #define ULTRA_SOUND #define TRIGGER 9 #define ECHO 8 #defineLONGEST_DISTANCE 200 // 200 cm = 2 meters You cannot define ULTRA_VCC as +5V,. If you want to use e.g. pin 10 as VCC, just type: #define ULTRA_VCC 10 Later in the code you will have to set it to HIGH and define the pinMode as Output or Input: void ultraSetup(){ pinMode(ULTRA_VCC, OUTPUT); digitalWrite(ULTRA_VCC, HIGH); pinMode(TRIGGER, OUTPUT); pinMode(ECHO, INPUT); } Then call the function ultraSetup(); under void setup, to set the pins. @Alex Young implemented this quite nicely: https://github.com/regularfry/OpenCat/blob/acy-data-loop/OpenCat.ino or you check my testing-version: https://github.com/ger01d/OpenCat/tree/ger01d-testing (I splitted the defines into the OpenCat.h and the rest in the OpenCat.ino)

@Harry Xu For a gait you can only change the speed by changing the number of frames. So to increase the movement speed, lower the number of frames and vice versa. You will notice the same approach in the OpenCat Instincs.h file. The Bittle run has less frames than the walk gait. For Behaviors like the push up this is different, because you can change the motor speed in the Instincts.h.

@Harry Xu You just need to run this python script: https://github.com/ger01d/kinematic-model-opencat/blob/main/kinematics_bittle.py There is a section with variable parameters that you can play with. When you run the script, the gait pattern will be shown as a function graph. Directly after closing it, you will find a gait_sequence.csv in the folder where you ran the script (and also an image for every frame of the gait).

There are currently two ways: The first one is to use the kinematic model. It will create a walking pattern with a fixed phase shift between the legs. What you can vary is the vertical amplitude (lift of the leg from ground) and the longitudinal amplitude (step length). You can also vary the torso position in height and shift the body forward and backward. The result of the script is a sequence of motor angles that can be applied to Bittle/Nybble. This is a process of try and error, where you will have to check the performance. The second possibility is to work on the machine learning approach, which is still under development and highly experimental. It‘s the OpenCat-Gym. There are still high differences between the simulation model and the real hardware model, that makes it problematic to apply the trained neural network (e.g. different masses, inertia, friction, latencies). But any help and development regarding this topic is welcome! If your stuck on something, just let me know.