Well, aside from the fact the servo is always in “holding” state and trying to reach the position assigned to it… I think that’s about it.
By default, IPE=0 so you have to keep feeding the same position to the servo until it does reach it. If you switch to IPE=1 sending the target position once is enough to make it do the work itself (i.e.: saturating the filter) and you will reach the position.
IPE=0 is useful is you want to control the rate of commands; maybe you want to updated the filter / target position at a slower rate, lets say every 50 ms or something.
Yes I did where do you think I got the fpc, and angluar/holding stiffness’s from. Think it was you or was it cmackenzie you talked about sending it 3 times. But that all got me confused.
Also, this thread is really really long, and got longer once I joined.
@cyberpalin
What are you trying to smooth out (which part of the movement) ?
As i said a couple of time that my example had math issues where the two final positions sent are not calculated right. There is a big step in between and the longer the movement, the worst it is.
Maybe that’s not your problem but just wanted to clear this out first. (HERE)
@cyberpalin
You should probably send a QIPE and see what value yours is set at. If it is set to 1 then a D command sent in EM=0 with FPC=2+ (optimally 3+) when the QDT should update every ~20 ms towards your desired location (from the D command) until it arrives there.
Thanks - don’t think that the my problem- used what you posted as a guide and I think I fixed it so last position ends up where its suppose to go - did confirm that with the LA.
Here’s my current sketch - only uses one servo.
// LSS Setup & Variables
#include <Wire.h>
#include "SparkFun_Qwiic_Keypad_Arduino_Library.h" //Click here to get the library: http://librarymanager/All#SparkFun_keypad
KEYPAD keypad1; //Create instance of this object
#include <LSS.h>
#define LSS_BAUD (921600)
LSS LSS_1 = LSS(0);
int Timing = 250; // Time in ms for the motion (T Parameter)
int delais_frame = 1000; // Time between each Frame
int em0_rate = 25; // Rate at wich the positions are sent (20ms)
void setup() {
Serial.begin(115200);
if (keypad1.begin() == false) // Note, using begin() like this will use default I2C address, 0x4B.
// You can pass begin() a different address like so: keypad1.begin(Wire, 0x4A).
{
Serial.println("Keypad does not appear to be connected. Please check wiring. Freezing...");
while (1);
}
Serial.print("Initialized. Firmware Version: ");
Serial.println(keypad1.getVersion());
// Initialize the LSS bus
LSS::initBus(Serial1, LSS_BAUD);
Serial.println("Initial Reset: ");
LSS_1.reset();
delay(2000);
LSS_1.setServoID(6);
// LSS Settings
Serial.println("Set AngularStiffness to -4: ");
LSS_1.setAngularStiffness(-4);
Serial.println("");
delay(250);
Serial.print("Set Holding Stiffness to 4: ");
LSS_1.setAngularHoldingStiffness(4);
Serial.println("");
delay(250);
Serial.println("Set Motion Control: ");
LSS_1.setMotionControlEnabled(0);
delay(250);
LSS_1.setMaxSpeed(1800, LSS_SetSession);
Serial.println("Do not Set FPC: ");
//Serial1.println("#6FPC5\r");
delay(250);
#ifdef LSS_SupportsSettingTimeouts
LSS::setReadTimeouts(20, 5); // define we will wait for 20ms for response to start and 5ms for in message characters
#endif
}
void sequence(){
// Frame 1:
Serial.printf("\nFRAME 1\n--------------\n");
Spoofing(-450,Timing);
delay(delais_frame*3);
Serial.printf("\nFRAME 2\n--------------\n");
// Frame 2:
Spoofing(450,Timing);
delay(delais_frame);
}
void Spoofing(int32_t LSS_S_1,int32_t p2_timing){
int pos_num = p2_timing/em0_rate;
int32_t temp[pos_num];
uint32_t stime;
int32_t LSS_1_qd = query_LSS_1();
int32_t LSS_1_delta = LSS_S_1 - LSS_1_qd;
int32_t LSS_1_min_pos = LSS_1_delta/pos_num;
Serial.printf("goal: %d, time: %d, pos_num: %d\n", LSS_S_1, p2_timing, pos_num);
Serial.printf("Current pos: (qd: %d), dPos(%d), tStep(%d)\n", LSS_1_qd, LSS_1_delta, LSS_1_min_pos);
temp[0] = LSS_1.getPosition();
stime = millis();
for (int32_t i = 1; i < pos_num+1; i++){
Serial.printf("i: %d, move: %d\n", i, (LSS_1_min_pos * i) + LSS_1_qd);
LSS_1.move((LSS_1_min_pos * i) + LSS_1_qd);
delay(em0_rate);
checkStatus();
temp[i] = query_LSS_1();
}
LSS_1.move(LSS_S_1);
delay(2);
Serial.printf("Final Move: %d\n", LSS_S_1);
uint32_t dt = millis() - stime;
Serial.println("Time(ms)/ Pos(deg)");
Serial.printf("%d / ", dt);
for(int i = 0; i < pos_num; i++) {
Serial.printf("%d, ", temp[i]);
}
Serial.print(LSS_1.getPosition());
Serial.println();
}
int32_t query_LSS_1()
{
int32_t posLSS = 0;
int32_t lastPosLSS = -1;
char readBuffer[100];
lastPosLSS = posLSS;
Serial1.write("#6QD\r");
while(Serial1.available() == 0)
{
}
size_t readLength = 0;
readLength = Serial1.readBytesUntil('D', readBuffer, 100); // Read until after the command (QD), indicating the start of the returned value (position in 1/10 deg)
readLength = Serial1.readBytesUntil('\r', readBuffer, 100); // Read until the carriage return (\r), indicating the end of the reply
readBuffer[readLength]=0;
if(readLength > 0)
{
if(LSS_1.charToInt(readBuffer, &posLSS))
{
Serial.printf("Returned Postition: %d\n", posLSS);
return posLSS;
}
}
}
void loop() {
keypad1.updateFIFO(); // necessary for keypad to pull button from stack to readable register
char button = keypad1.getButton();
// only toggle the LED if the new button state is HIGH
if (button == '#') {
//Start the sequence
Serial.println("Sequence Start");
sequence();
}
}
void checkStatus()
{
int8_t status1 = -1;
uint32_t statusTime = 0;
while (status1 != 6) {
if (status1 != 6) status1 = LSS_1.getStatus();
//delay(2);
statusTime += 1;
}
Serial.printf("Status Loop CNT: %d: %d\n", statusTime, status1);
}
Thanks for the info has help - have to play now and see what happens. One of things was to kind of sort of doing a work around for a timed move since that doesn’t seem to be operational yet.
My delay in responding was because I was copy an pasting all this info into a word document for further reading
Some reason, some of this feels a bit screwy to me… That is, I don’t know of other servos, where I have to tell them N times to go to same position to get there. Just feels wrong, especially for defaults…
It should not be hard for people for people to get the results they expect…
Sorry if this sounds simplistic:
But when the impression is that you choose to use the SSC-32 like command set, you expect that you should be able to port your program using an SSC-32 with RC servos to the LSS servos, and in theory you should be able to do so by just switching the Serial port… And maybe switch from PWM position to D positions…
That is what I want to do is something like, sort of our cycle stance code, similar to my ‘k’ command.
For example suppose I have code like this for SSC-32
Yes these strings are not valid for SSC-32. need to change P to as I need to convert the degrees here to their PWM values… Also some of these values may need to be negated depending on leg…
In fact maybe later today or tomorrow I will hook up one of my old Hexapods like Phoenix with SSC-32 to processor and run this. But what I expect I will see is that the three servos will all move smoothly to their positions and there should be no pausing at all between each of the 7 moves in the cycle…
What I would like to see is how do I convert this to LSS and get the same results? What I may try once I have an SSC-32 working with this, is I would like to output to both legs at the same time with the same logical command string, and be able to observe the two legs to see if they are following the exact same motion…
Sorry simple question, why are all the code bases going to EM=0?
But for first step
OK, I added the ‘S’ command to my test sketch which does like the i command where it moves through 7 moves… I defined them in a more confined space as I will also maybe tomorrow convert them to RC and output to SSC-32…
I pushed the code up…
int16_t rf_stance_smooth [RF_STANCE_COUNT][3] =
{
{0, -600, -600}, //Low
// 0, -900, 510 degrees
{100, -300, -300}, //mid Low
{200, 0, 0}, //Med
{0, 300, 300}, //High
{ -100, 0, 0}, //Med
{ -200, -300, -300}, //mid Low
{0, -600, -600} //Low
};
int LSSGetServoPosition(uint8_t servo_id) {
myLSS.setServoID(servo_id);
return myLSS.getPosition();
}
void cycleSmoothTimed() {
Serial.println("Cycle Smooth - speed changes each loop");
for (uint8_t leg = 0; leg < COUNT_LEGS; leg++) {
if (legs[leg].leg_found) {
myLSS.setServoID(legs[leg].coxa.id);
myLSS.moveT(rf_stance_smooth[0][0], 500);
myLSS.setServoID(legs[leg].femur.id);
myLSS.moveT(rf_stance_smooth[0][1], 500);
myLSS.setServoID(legs[leg].tibia.id);
myLSS.moveT(rf_stance_smooth[0][2], 500);
}
}
delay(1000); // extra long time...
int move_time = 500; // start off time
int move_time_change = 250; // how much to change per loop
static const int MOVE_TIME_MAX = 1000;
static const int MOVE_TIME_MIN = 250;
Serial.println("Press any key to exit");
while (Serial.read() != -1); // clear it out
while (!Serial.available()) {
Serial.printf("Cycle Move Times %d\n", move_time);
for (uint8_t position = 0; (position < RF_STANCE_COUNT) && !Serial.available(); position++) {
elapsedMillis em = 0;
for (uint8_t leg = 0; leg < COUNT_LEGS; leg++) {
if (legs[leg].leg_found) {
myLSS.setServoID(legs[leg].coxa.id);
myLSS.moveT(rf_stance_smooth[position][0], move_time);
myLSS.setServoID(legs[leg].femur.id);
myLSS.moveT(rf_stance_smooth[position][1], move_time);
myLSS.setServoID(legs[leg].tibia.id);
myLSS.moveT(rf_stance_smooth[position][2], move_time);
}
}
for (uint8_t leg = 0; leg < COUNT_LEGS; leg++) {
if (legs[leg].leg_found) {
Serial.printf("\t%u C:%d->%d F:%d->%d T:%d->%d", leg,
LSSGetServoPosition(legs[leg].coxa.id), rf_stance_smooth[position][0],
LSSGetServoPosition(legs[leg].femur.id), rf_stance_smooth[position][1],
LSSGetServoPosition(legs[leg].tibia.id), rf_stance_smooth[position][2] );
}
}
Serial.println();
// normalize move time...
delay(move_time - em);
}
// Ok we finished one cycle, lets update the timing for next
if ((move_time == MOVE_TIME_MAX) || (move_time == MOVE_TIME_MIN)) move_time_change = -move_time_change;
move_time += move_time_change;
}
}
So it loops through each leg tells them to go to some new position in time T in range 250-1000 and then asks all of the servos for their current position. You would expect that the positions should be very near the previous targets… At times close other times off…
Have not been able to follow all of the discussion in its entirety, so there’s more than likely something I’ve missed (my apologies in advance), but fundamentally, what is the best way to program the motion of each joint of a “smart” legged robot (real-time ROS vs pre-programmed Arduino)?
Only the P command was reused from the SSC-32U, but not the group move (as well as other features), as the LSS were programmed from scratch. Set aside the SSC-32 / 32U protocol / functionality for this exercise.
Approach 1: Rely on the onboard motion controller (EM1) for timed moves (T modifier).
Approach 2: Create an external controller and send many commands to the servo regarding position (EM0)
The motion controller under EM1 is made for a move without any additional / intermediate position commands (which therefore allows T and S to be calculated knowing start and end positions, and can therefore make use of modifiers. Group moves would indeed be the next logical step, but not implemented (as of yet).
The EM0 motion controller mode is made for receiving many small position commands where the servo holds at each position (and hence max torque can be provided), but does not include any modifiers: since it receives a new command each time where the positions are so close, not knowing the next position, timing cannot be anticipated.
For a bit of clarity, if IPE=1 (default), you do not need intermediate positions either (kinda the point of the Intermediate Position Engine, after all). That being said, EM=0 & IPE=0 would basically work like an RC servomotor in the sense that you continuously send positions to it (therefore saturating the internal buffer, configured by FPC).
But EM=0 (IPE=0 or 1) is definitely better suited for managing the motions using intermediate positions than EM=1 is (where the control tries to accel/travel/decel and that may not be appropriate for all types of motions).
