Видео

It should be! The latest Blender version I tested is 4.1.1 (latest stable release as of June 10, 2024). The Arduino version shouldn't affect functionality as long as you use Arduino IDE 2.0 or later.

@@knee-koh ok great ! Thank you btw I have been learning how to use it little by little every day currently I’m trying to use it to find a walking gait with RL for a bipedal robot. I have RL saved to a saved animation using IK following a path and some reason when I play the animation the servos don’t move, but in the servo set up I can have them manually move by adjusting Min and Max values. Can an animation control servos ?

@@charles26842 Animations should definitely be able to move servos (as long as the MarIOnette panel is open and active when the animation runs). I've seen this issue crop up a few times on knockoff Arduino boards when the USB/Serial port would randomly disconnect and then reconnect. A couple things to try: - Disconnect from the controller in the panel, reseat the cable, then reconnect - See if you're getting any warnings or errors in the bottom of the Blender window If you still have issues, please make a thread in the MarIOnette github with pictures + details (a .blend file would also be ideal so I can test on my setup): github.com/knee-koh/MarIOnette/issues

@@knee-koh Hello again Long time, hope all is well. I have been working with it for quite a while and have resolved several issues, connection, servo lag. I was wondering if you have an idea on how to use a PWM driver for servos. I'm thinking it would possibly be as simple as redeclaring the servo pin to PWM channel.

@@knee-koh Main code: /* MarIOnette template file for Arduino-compatible boards Tested on Arduino Nano (ATMega 328P), Arduino Uno, Teensy 3.2, Teensy 4.1 */ #define DEBUG_SETUP 1 #define DEBUG_SERIAL 1 #define DEBUG_SD_PLAYBACK_TEST 0 #include "config.h" // Create the PWM servo driver object Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(); unsigned int counter = 0; unsigned int howManyBytes = 0; unsigned int busServoSpeed; unsigned int readingPositions = 0; unsigned int playingAnimation = 0; unsigned long previousMillis = 0; const long interval = 200; // Increased interval for non-blocking delay void readSerialBytes() { int debugOut = 0; // Minimized debug output char inByte; while (Serial.available() > 0) { char mode = Serial.read(); if (debugOut) { Serial.print("Mode: "); Serial.println(mode); } // Blender sending data... if (mode == 'A' || mode == 'B') { counter = 0; if (IS_AVR) { delay(SERIAL_DELAY); } else { delayMicroseconds(SERIAL_DELAY); } // Read in first bytes to get message length char one = Serial.read(); if (IS_AVR) { delay(SERIAL_DELAY); } else { delayMicroseconds(SERIAL_DELAY); } char two = Serial.read(); if (mode == 'A') { howManyBytes = word(one, two) + expectedSpeedBytes; } else { howManyBytes = word(one, two); } if (debugOut) { Serial.print("Expecting bytes: "); Serial.println(howManyBytes); } if (howManyBytes > 64) { // Check for potential buffer overflow if (debugOut) { Serial.println("Error: howManyBytes exceeds buffer size"); } return; } char tempBuffer[howManyBytes]; unsigned long timeout = millis() + 100; // Timeout to prevent infinite loops while (Serial.available() < howManyBytes && millis() < timeout) { // wait until we have enough data } if (Serial.available() >= howManyBytes) { for (int i = 0; i < howManyBytes; i++) { tempBuffer[i] = Serial.read(); } // Right amount of bytes received, set motors and LEDs if (debugOut) { Serial.println("Success! Data received: "); for (int i = 0; i < howManyBytes; i++) { char buffer[4]; sprintf(buffer, "%02X ", tempBuffer[i]); Serial.print(buffer); } Serial.println(); } if (mode == 'A') { updateMotorsAndLEDs(tempBuffer, 0); busServoSpeed = word(tempBuffer[0], tempBuffer[1]); } else { updateMotorsAndLEDs(tempBuffer, 1); busServoSpeed = 0; } } else { if (debugOut) { Serial.println("Timeout waiting for data"); } while (Serial.available()) { Serial.read(); // Clear the buffer } } } else if (mode == 'P' && !playingAnimation && SD_ENABLE) { // Play back file from SD card SDHelper(1); } else if (mode == 'S' && playingAnimation && SD_ENABLE) { // Stop file playback SDHelper(0); if (debugOut) { Serial.println("Animation stopped by serial"); } } else if (mode == 'R' && !readingPositions && SD_ENABLE) { // IN PROGRESS!!! // Read values from dynamixels or bus servos if (TOTAL_BUS_SERVOS > 0 || TOTAL_DYNAMIXELS > 0) { if (debugOut) { Serial.println("Reading values from dynamixels or bus servos"); } // Read how long the animation is and at what FPS it runs //readingPositions = 1; //Serial.parseInt(); //totalFrames = Serial.parseInt(); //FPS = Serial.parseInt(); //frameInterval = 1000*1000/FPS; // In microseconds //animationTimer = 0; } else { if (debugOut) { Serial.println("No bus servos or dynamixels configured!"); } } } else if (mode == 'Z' && readingPositions) { // Cancel position reads readingPositions = 0; } } } void setup() { // Start Serial monitor Serial.begin(BAUD_RATE_SERIAL); if (DEBUG_SETUP) { Serial.println("Starting MarIOnette initialization..."); } // Initialize PWM driver pwm.begin(); pwm.setPWMFreq(60); // Analog servos run at ~60 Hz updates // Perform setup, which gets dynamically generated by MarIOnette setupAll(); if (DEBUG_SETUP) { Serial.println("Setup finished!"); } } void loop() { // Check for serial data and update motors and LEDs readSerialBytes(); // Handle animations if (playingAnimation) { playAnimationFile(); } // Update steppers updateSteppers(); // Non-blocking delay for smooth servo movement unsigned long currentMillis = millis(); if (currentMillis - previousMillis >= interval) { previousMillis = currentMillis; // Call any functions that require timing here } } void setupAll() { for (int i = 0; i < TOTAL_MOTORS; i++) { // Servos if (motor_values[i][0] == 1) { // Use PWM driver for servos if (DEBUG_SETUP) { Serial.print("Servo "); Serial.print(i); Serial.print(" on PWM channel "); Serial.println(i); } } // PWM Pin if (motor_values[i][0] == 2) { pinMode(motor_values[i][1], OUTPUT); } // ON/OFF Pin if (motor_values[i][0] == 3) { pinMode(motor_values[i][1], OUTPUT); } // PWM Bi-Directional if (motor_values[i][0] == 4) { pinMode(motor_values[i][1], OUTPUT); pinMode(motor_values[i][2], OUTPUT); } } } void updateMotorsAndLEDs(char frame_buffer[], int mode) { int servo_index = 0; int stepper_index = 0; for (int i = 0; i < TOTAL_MOTORS; i++) { int offset = i * 2; // Speed bytes are sent in case we have bus servos... if (mode == 0) { offset = i * 2 + expectedSpeedBytes; } unsigned int motor_value = word(frame_buffer[offset], frame_buffer[offset + 1]); // Min and Max values if (motor_value > motor_values[i][9] && motor_values[i][8] != 0 && motor_values[i][9] != 0) { motor_value = motor_values[i][9]; } else if (motor_value < motor_values[i][8] && motor_values[i][8] != 0 && motor_values[i][9] != 0) { motor_value = motor_values[i][8]; } // Set servo position using PWM driver if (motor_values[i][0] == 1) { int pwm_value = map(motor_value, 691, 1667, 150, 600); // Adjust the range as needed pwm.setPWM(i, 0, pwm_value); Serial.print("Setting PWM for Servo "); Serial.print(i); Serial.print(" on channel "); Serial.print(i); Serial.print(" to value "); Serial.println(pwm_value); servo_index++; } // Set PWM value if (motor_values[i][0] == 2) { analogWrite(motor_values[i][1], map(motor_value, 0, 4000, 0, ANALOG_MAX)); } // Set ON/OFF value if (motor_values[i][0] == 3) { if (motor_value > 0) { digitalWrite(motor_values[i][1], HIGH); } else { digitalWrite(motor_values[i][1], LOW); } } // Set Bi-directional PWM if (motor_values[i][0] == 4) { if (motor_values[i][3] == 1) { if (motor_value > ANALOG_MAX / 2) { analogWrite(motor_values[i][1], map(motor_value, ANALOG_MAX / 2, ANALOG_MAX, 0, ANALOG_MAX)); digitalWrite(motor_values[i][2], HIGH); } else { analogWrite(motor_values[i][1], map(motor_value, ANALOG_MAX / 2, 0, 0, ANALOG_MAX)); digitalWrite(motor_values[i][2], LOW); } } else { if (motor_value > ANALOG_MAX / 2) { analogWrite(motor_values[i][2], map(motor_value, ANALOG_MAX / 2, ANALOG_MAX, 0, ANALOG_MAX)); digitalWrite(motor_values[i][1], LOW); } else { analogWrite(motor_values[i][1], map(motor_value, ANALOG_MAX / 2, 0, 0, ANALOG_MAX)); digitalWrite(motor_values[i][2], LOW); } } } } } void playAnimationFile() {} void SDHelper(int mode) {} void readAnimationFile() {} void updateSteppers() {}

Same

That is covered in the video

Hi, I have a tutorial mostly edited covering lots of new features including close to what you're asking. Until it's posted (lots of things keeping me busy at my day job, sorry!) you can follow these steps: the 1.0.3 and 1.0.4 builds of MarIOnette supports saving an animation to a file and playing it back from an SD card. - Cache the file in the in the Cache menu (make sure to check "Write cache header file") - Transfer to an SD card - Trigger it in the Arduino code. The latest .ino Arduino file in the github has some commented code on lines 167-177 that shows an example of how to load in an animation. You can trigger that code with a button press/other input. Unfortunately it will be some time before animations can be uploaded directly to the microcontroller, since there are so many boards with varying memory sizes floating around. Once my other work calms down a bit I'll look into tackling that and other requested features.

@@knee-koh thank you. I will check the latest build. In terms of boards, I think a good one to add support for would be the PCA9685. It supports 16 servos and you can chain up to 62 of them together. Thanks for making this! It’s awesome.

Exciting to hear you cooking more tutorials

Hi, could you log the issue to the github so I can track it better - github.com/knee-koh/MarIOnette/issues? If you are trying to install MarIOnette on windows, please launch Blender in Administrator Mode (right click the Blender icon on your desktop and select the corresponding option). From there install the add on as usual.

@@knee-koh Ok was able to install MarIOnette on two of my other PC's successfully. The 1st computer I tried it on didn't work, cause I previously, accidentally, deleted some critical files I may have needed to run my PC properly, gotta get that looked at. Looking forward using the addon now, in Blender, Thanks.

Hi, config.h gets generated automatically when you hit the "Sync" button in the MarIOnette panel. That button will generate an Arduino .ino file and a config.h file into a folder you specify. When you open the .ino file, Arduino should open with the config file automatically.

@@knee-koh thanks, because I thought you forgot to add this file. thanks for the help

Hi, this is normal behavior! I'm working on a tutorial to go over more features, but here's a short overview until then: - First, make sure the "Enable SD Card" box is ticked, so the Arduino knows what to read from. If you're using a standalone SD reader module, uncheck "use internal SD card" and select the CS pin number - I would definitely recommend checking the "write cache header line" box, because the Arduino uses that line to figure out the fps and number of frames in an animation - Cache the animation and save it to your computer, then transfer it to the SD card and insert it into your microcontroller - Sync the configuration (in MarIOnette sync panel) and update the code to the microcontroller so it loads in the SD library - To play back a file, you can uncomment lines 167-177 in the MarIonette_Template_V1.ino code to see how to begin playback. The animation will run (assuming it's found on the SD card) and end automatically. You can track progress by monitoring the microcontroller over Serial As for the encryption you mentioned, this is also normal. In order to save processing time and space, each value is stored as two bytes that get combined into a 16-bit integer. The bytes look like gibberish in plaintext because they are being stored as ASCII values. The only thing that is readable is the aforementioned header line, since it only gets read in at the beginning of playback. As for the extension, that's also normal to not have an extension. Since there are certain bytes that signal end of file for .txt filetypes, I chose to make the animation files extension-less, since all of the operating systems and microcontrollers I tested this on are able to open and read from them without the end of file byte problem.

Thanks so much for the detailed reply and talking me through the procedure! I'm eagerly looking forward to your next tutorial. As for my other comment on the other video, thanks for following up on that as well. I ended up going another direction that got me to a place I needed to be. However, I am starting to work with Dynamixels and definitely want to shift back to Marionette for that. I updated from 1.0.2 to 1.0.3 yesterday after I sent this message and was glad to see the new SD card options. this is going to come in very handy. I did however have some trouble when I attempted to Cache the animation in the SpidahBahtV1 sample file. When I would press "Cache File" it would read that it's "Writing file" show the "Percentage done" hang on 0% with no file created. Could there be some conflict with that particular file? I also noticed that in the code for the add-on that Dynamixel was commented out for the dropdown selection. it seemed to default to LewanSoul for the actuator selection. was that intentional?

@@benploughman4145 great catch on the SpidahBaht example! It looks like the mapping on that bone is a little off, causing it to output negative values. For that specific example, you can set Servo 2 in the Actuator Setup panel to have a Min bone angle of -180 and Max bone angle of 180, just to get the caching to work. I'll work on fixing this bug to make sure negative values get clamped to 0 to prevent this from happening in the future. A quick tip on debugging errors: if you go to the scripting tab in Blender, you should see a red error in the bottom left showing what MarIOnette is angry about. When I'm in a rush I just tweak values until the error go away XD Dynamixels are the last thing on my list of things to implement, since there's more options that can be implemented. If you need it to work right away, and have a board that converts 2pin serial/Uart from the Arduino to the 1 data pin of the Dynamixel, you can use the DynamixelSerial library on the github (Arduino Code > Libraries) and include it in the Arduino .h file. From there you'll need to setup the Dynamixels in the .h file (use the examples found in that library) and then replace any Servo.write() or Servo.writeMicroseconds() commands with the corresponding Dynamixel calls. Version 1.0.4 will include basic Dynamixel support, I just need a few days/weeks to test functionality.

Brilliant. Thanks for the debugging tip and really all of the info you've shared. Super helpful. Looking forward to seeing all this evolves. You've made a really cool thing here.

Im working on setting up Dynamixels and there's a section in the Marionette panel under the Dynamixel ID number for 'Select Serial Port for Dynamixel link' and the drop down lists 'Serial1, Serial2, Serial3, etc..' . I'm curious as to what differentiates this from the Serial Setup section at the top.

I haven't noticed anything like this in my tests. Blender does start to slow down a little (depending on your machine) once you add in lots of motors and LEDs, but still within reasonable limits (I've tested ~60 unique values at 45fps on an M1 macbook pro). Things like USB bus speed can affect jerkiness if the receiving microcontroller doesn't have a large enough buffer to read in all the motor values quickly enough (so some might get dropped). Power requirements are also really important: making sure all your grounds are connected, and the motors are receiving enough power so they don't draw too much load that might brown-out your main controller. Finally, motor resolution can affect smoothness; I've used really cheap rc servos in the past that had a small range, so moving between two values (say 101 and 102) visually looked like the motor moved a few degrees. It's hard to say what's causing the anomalies without seeing how things are set up IRL, but hopefully some of the above can help!

Tutorial coming soon! The 1.0.3 build of MarIOnette supports this feature. You save the animation to your hard drive, transfer to an SD card, and then trigger it in the Arduino code. The latest .ino Arduino file in the github has some commented code on lines 167-177 that shows an example of how to load in an animation.

@@knee-koh Thanks! I will look at arduino code. If I knew before I could understand how to do it without a tutorial lol :) One of the best features imo! Its good we will have an tutorial too! Good luck!

Hi, there's a new version of MarIOnette that supports local SD card playback! Check the github for the latest release, and be on the lookout in the coming weeks for another tutorial video that will cover this feature in more detail.

@@knee-koh I am looking forward next tutorials! :) You made awesome thing

Okay, quick update: specifing the driver's enable pins and putting them low made the axis lock while not connected which seems intended behavior (except for one, which keeps moving very very slowly an jittery in one direction). Connecting to MarIOnette while an animation plays makes all the axis release. Stopping the animation makes the axis locks after a few seconds and resuming the animation doesen't release, and all axys stay locked. Same happens if connect whithout an animation playing. P.s. Tried to change the first element of each motor array back to 5 (in config.h) but nothing (changing them to 0, 1, 2, 3, 4 changed the stepper which slowly turns while not connected, so it is indeed the motorIndex. Obviously you know already, just a thought of mine ahaha)

Okay, sorry. Quick and last update: IT WORKS. So: implementing and setting enablePins to low is needed for steppers to work (at least using a RAMPS 1.4 board), but the last piece of the puzzle was, of course, my stupidity. Nothing in the config.h needed to be changed (sorry for doubting your skills, master), but during troubleshooting, before adding enablePins, i restarted blender, 'cause: why not? Maybe fixes something, but i forgot to restart it in administrator mode... Big facepalm. And nothing. That's all. Sorry for bothering you. I hope that at least someone find this helpful. Now trying to implement a homing sequence. Wish me luck!

I saw that my questions are answered in another video. 🤦🏻‍♂ I've been able to get this to work with an Adafruit Feather M0, but now I'm attempting to use an 8-Channel Featherwing PWM and I'm running into a wall getting it to interact with blender/marionette. Any recommendations or resources that could help me through this?

@@benploughman4145 , sorry for the late reply! I saw your comment on another video about SD card/localized animation playback; hopefully my answer explained that process a little better (though I am working on another tutorial that will walk through the process more thoroughly). Happy to hear it works on an M0! In terms of getting it to run on the 8-channel Featherwing board, you'd need to write some code to handle communication with that specific chip. Fortunately Adafruit has taken most of the hard work with their libraries, so you'd need to do the following: - Create servos and attach motors inside MarIOnette as if they were attached directly to the board - Sync the files to create the .ino and .h files for your project - Uncheck "Overwrite Arduino File" so you can edit the files freely in case you need to re-generate more code - In the generated .h file (the one MarIOnette uses), you'll have to include the Featherwing libraries and connect with the board (use Adafruit's examples to see how to do this and copy over the code) - From there, you just need to replace any Servo.write() or Servo.writeMicroseconds() lines of code in the .h file with the corresponding Featherwing commands. That way, your microcontroller will tell the Featherwing to actuate the servos over the i2c bus instead of the native PWM pins

Did you also post an issue to the github? I can track it from there. You say you have no serial monitor in Arduino IDE, are you sure the Arduino is being detected when you plug it into your computer (if not there might be a hardware issue with the board or with your cable)? If Arduino IDE cannot detect the board, then MarIOnette will also not be able to detect.

Hi, that might be challenging to do inside Blender since the simulation tools in the program are intended for more artistic purposes than real-world scenarios. I would suggest you look at something like ROS, Gazebo or ROS MoveIt, which are more appropriate for real-world robotic applications that rely on accurate physics and can manipulate data from the real world.

I think MarIOnette could animate it, assuming you are running stepper motors on the printer. If you want your machine to print real objects, a slicer that will output g-code will likely be more efficient and useful.

This runs inside Blender, so CG artists or people familiar with the software can leverage its many animation and other tools to drive animatronics. I have never used Ros Moveit, so I cannot speak to the exact differences, but it looks like it's more specifically oriented towards factory and industrial robotics.

Yes, saving to the microcontroller means saving a file to the SD card. That file can be read by any filesystem, and I've run the files from a Raspberry Pi in python on past projects. I will try and post example code to the github for the next release.

@@knee-koh oh I see, thank you!

ps. this is such a cool tool for creators and engineers, thank you for all the great work that was put into this entire addon

That looks like a weird quirk with Github... You can download the entire repo (go to the main MarIOnette github page and then click Code > Download ZIP). Then unzip the file on your computer and you should be able to open the file. An alternative to avoid having to download the entire repo: here's the raw file path (raw.githubusercontent.com/knee-koh/MarIOnette/main/Examples/Drawing%20Robot/OBJ%20File/Post%20It%20Drawer%20V3.obj). Just use your browser to save this file (save or save as, and specify a .obj extension). I'll update the next release to have the .obj file be in a .zip so it's easier to download

@@knee-koh Thanks very much for the reply. In the end I copied and pasted the text into a text editor and saved it as a .obj. I have managed to work my way through the entire tutorial (with a few stumbling blocks). Adding the PWM library (that you mention in the github doc but possibly not in the video?) and changing the baud rate to 115200 got it working for me. I really can't thank you enough for developing this plug in and I'm anxiously awaiting your next tutorial. You have made a wonderful tool. Well done!

Hi, I added a slider that controls whether the IK bone follows a path or is free to move. The fully rigged .blend file is in the github and has this change. I did not include this in the Blender tutorial because it was already getting very long, but I mention it at 36:09. It's not necessary to get the model working; it's just a bonus to showcase another form of controlling the rig.