"MArmOS" Mechanical Arm Operating system

Significant quality of life changes like these are more important that some of the other stuff they leave out... but i guess you're not wrong. I am super excited for this though.

 

Ok, so i can understand movemetd keys output as vectors etc. But whats the interface for the rest of it!? Ive got some digging to do.

 

This guy seems to know what he's doing. I'm taking his script as reference to upgrade MArmOS.
https://steamcommunity.com/sharedfiles/filedetails/?id=833636660&searchtext=
--- Automerge ---
It's done!
MArmOS is now totally modfree!
Spread the news!

 

Here is the latest MArmOS video tutorial.

 

MArmOS is soon gonna grasp the infinite power of the almighty Clang!

Get hyped!

 

Clang will be back for revenge in next update He all times find way back.

 

The hydraulic update is out. Enjoy.

The new features are:
- Hydraulic support
- Multi Joints (Slave Joint)
- Multi Piston (Slave Piston)
- some argument keywords such as:
- PrintPosition PanelName
- ClearPanel PanelName
- TrackInputs On/Off/Toggle
- More acurate controls
- bugfixes

I will update the guide as soon as possible to show how to use the new features.

 

Hi timotei!
I was wondering is it possible to control multiple arms from single cockpit?

I am making a mech that is supposed to have 2 utility arms. If both hands have their own marmos pb can i alternate between them by shutting the other arm off while controlling other&vice versa.
And i would like to be able to control movement from the same cockpit too.
I would like to hear your take on this.

 

Hi hali
Yes, it is possible to control multiple arms using a single PB. You can set each ArmController with a specific name using the "Name" parameter. Then, you can add a command to your cockpit's hotbar to Toggle the input tracking of each arms.
The command would look like this "LeftArm TrackInput Toggle" or "RightArm TrackInput Toggle" or for both arms "LeftArm TrackInput Toggle;RightArm TrackInput Toggle"
Or if you want to use the shortcuts "LeftArm -TI -1;RightArm -TI -1"
I two am currently working on implementing MArmOS on someone's mech. The results so far are really impressive.

 

Thanks for the info!
This is what i am going to use marmos for.
I intend to have one grinder arm and one grabber arm.

--- Automerge ---
What kind of mech you are building?

 

I can't tell right now. I promised to the guy who made the mech I wouldn't tell anyone

 

I feel like leaking some stuff I've been working on recently.


Just don't get too much hyped for now. It may take a while to finish.

 

Very excited to see you making this script easier to configure. If you need a dumb test candidate let me know, I'm ashamed to admit I struggle with the current configuration so it takes a long time for me to build a functioning arm, if it's made easier hopefully I can build more - I love to build them as docking arms to fuel and load ships on planets and in space... on that note, as a wish, is it possible to transmit the GPS co-ordinates of a connector to an arm to have it manoeuvre itself to connect, I appreciate that it's beyond the scope of this project but just chucking it out there!

 

I'm happy to ear that. I was actually thinking about getting a Close Testing Group to do quality checks before updates. Previously I would have done it myself but These days I no longer have time for it. So any help is welcome. The script may not be ready for proper testing for a while but you can still send me a steam friend request now and I'll accept it later today when I get to my PC. Also, I'd appreciate if you to send me your Steam Name so I know it's really you when I see the friend request.
Thank again for your support.
--- Automerge ---
The connector thing could be a nice add-on to MArmOS. When everything will be working properly, I may try to do something for that.

 

Thanks, sorry for the delay, just sent you a steam friend request. Happy to help if/when you need it, just send me a message on steam, I have it on in the background at work so can respond during the day (GMT).

Thanks for the feedback on the connector, I figure it's more complex than it seems too as the arm would need to know from which direction to approach to connector, in case it tried to reach for it from the wrong side of the ship. Again, happy to help here in the future where I can for testing and suggestions with this if you decide to do something with it.

 

Things are coming together so well, I want to give people a little sneak peek of MArmOS's future look.
Little things are subject to change but the idea is here.

Code:

    ///////////////////////////////////////////////  Page: 0  //////////////////////////////////////////////////////
  /////////////////////////////////  W E L C O M E  T O  M A R M O S  V3.0
///
//
//    TITLE: MArmOS V3.0
//    AUTHOR: Timotei~
//    DESCRIPTIONN:
//          MArmOS is a powerful framework made to solve complex direct and inverse kinematics
//          to allow to easily control any kind of mechanical arms.
//          MArmOS v3.0 is the result of the collection of experiences learned from v1 and v2.
//          Since v3.0, MArmOS is structured in a highly effective way that free the user from
//          having to manage unintuitive rules and arbitrary conditions.
//          This new version is designed to be as user friendly as possible.
//          You just need to define your pieces and controllers. MArmOS take care of the rest.
//
//    TABLE OF CONTENT:
//          Page: 1  - ARM CONFIGURATION
//          Page: 2  - DEFINITION EXAMPLES: basic and advanced
//          Page: 3  - ADVANCED DEFINITION GUIDE
//          Page: 4  - CONSTRUCTORS: rotary, linear, solid and controller
//          Page: 5  - AXIS TIPS
//          Page: 6  - CLASS MAP
//          Page: 7  - MAIN
//          Page: 8  - GENERAL PARAMETERS
//          Page: 9+ - MARMOS'S INNER WORKING
//
//
//
///////////////////////////////////////////////  Page: 0  //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////







    ///////////////////////////////////////////////  Page: 1  //////////////////////////////////////////////////////
  /////////////////////////////////  A R M  C O N F I G U R A T I O N
///
//
//    This is where you must define the hardware of your arm.
//    This step can be done in multiple ways and can get pretty complex.
//    That's why I've put some example and documentation below to help you define your arm.
//
//
void MArmOS_Configuration(){







}
//
//
//
///////////////////////////////////////////////  Page: 1  //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////







    ///////////////////////////////////////////////  Page: 2  //////////////////////////////////////////////////////
  /////////////////////////////////  D E F I N I T I O N  E X A M P L E S
///
//
//    There is now two ways to define your arm. Basic and advanced.
//    The basic setup only you to define your hardware. It is perfect for fast and eazy general use configurations.
//    Note that the basic mode is sensible to the order in witch you declare your hardware, will not consider parallelism
//    and only work for a single arm.
//    In the advanced setup, you can assemble one or multiple arms yourself and define precisely how the pieces are linked.
//    The advanced setup is better if you want to make more specific projects.
//
//    /////////  2.1 BASIC EXAMPLE  //////////
//  //
// //        newRotor( Name: "Motor1", Axis: "Y", OriMode: false );  // Reffer to the Rotor Documentation at page: 4.1 for details.
// //        new SolidSG( 2, 0, 0 );
// //        new Piston( Name: "Piston1" , Axis: "X" );
// //        new UserControl( );  // [Optionnal] If the controller is not declared, a default one will be used instead.
// //
//    /////////  2.2 ADVANCED EXAMPLE  //////////
//  //
// //        var R1 = new Rotor( Name: "Motor1", Axis: "Y", OriMode: false );  // Components are stored in Variables.
// //        var S1 = new SolidSG( 5, 0, 0 );
// //        var P1 = new Piston( Name: "Piston1" , Axis: "X" );
// //        var MyArm = R1+S1+P1;  // Assembling the arm using the components
// //        MyArmController = new UserControl( Arm: MyArm );  // You need to tell the controller whitch arm to use.
// //
//
//
///////////////////////////////////////////////  Page: 2  //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////







    ///////////////////////////////////////////////  Page: 3  //////////////////////////////////////////////////////
  /////////////////////////////////  A D V A N C E D  D E F I N I  T I O N  G U I D E
///
//
//    Assembling your arm manually in MArmOS is just like a mathematical equation using " + ", " * " and " () ".
//    The "+" operator is used to represent two hardware attached in series.  "end to end"
//    The "*" operator is used to represent two hardware attached in parallel.  "side by side, working together"
//    Don't forget that, like in math, order of operations is a thing.  "2+2*3 = 8, not 12 ... "
//    Because of that, you may want to use parenthesis in some cases.  "(2+2)*3 = 12 yay!"
//
//    Here is a step-by-step example:
//    - Step 1: Declare local variables for each components of your arm (including solid pieces).
//        Here are some common examples:
//          var R1 = new Rotor( Name: "Rotor1", Axis: "Y", OrientationMode: false );
//          var P1 = new Piston( Name: "Piston1", Axis: "X" );
//          var S1 = new SolidSG( 5, 0, 0 );
//    - Step 2: Assemble all your pieces together like a mathematical equation using " + ", " * " and " () ".
//        Here are some examples:
//          // Example 1: "Serial"
//          MyArmExample_1 = R1 + S1 + R2 + S2;
//          // Example 2: "Parallel"
//          MyArmExample_2 = R11*R12 + S1 + R1 + S2;
//          // Example 3: "With grouped Serials in parallel"
//          MyArmExample_3 = ( R11 + S22 + R1 ) * ( R12 + S22 + R22 ) + S3;
//    - Step 3: Define your controller and tell it to control your arm instead of the default one.
//          var R1 = MyArmController = new UserControl( Arm: MyArm );
//
//
//
///////////////////////////////////////////////  Page: 3  //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////







    ///////////////////////////////////////////////  Page: 4  //////////////////////////////////////////////////////
  /////////////////////////////////  C O N S T R U C T O R S
///
//
//    Here are all constructors available in MArmOS.
//
//
//    //////////////////////////////////////////////////////// Page: 4.1
//  ////////////  ROTARY JOINTS CONSTRUCTORS  //////////
// ///
// //
// //        new Rotor(
// //            String      Name
// //            , String    Axis  // ( "X", "-X", "Y", ... ) Reffer to the Axis Tips bellow for details.
// //            , bool      OriMode  // If true, the rotor will favors orientation against position.
// //            , Single    MaxSpeed  // (rpm)
// //            , Single    Offset  // (deg)
// //            , Single    SoftMaxLimit  // How soft should be the max limit
// //            , Single    SoftMinLimit );  // How soft should be the min limit
// //
// //        new Hydraulic(  // Not yet ported
// //            String      Name
// //            , Hardware      Actuator
// //            , String    Axis  // ( "X", "-X", "Y", ... ) Reffer to the Axis Tips bellow for details.
// //            , bool      OriMode  // If true, the rotor will favors orientation against position.
// //            , Single    MaxSpeed  // (rpm)

// //            , Single    Offset  // (deg)
// //            , Single    SoftMaxLimit  // How soft should be the max limit
// //            , Single    SoftMinLimit );  // How soft should be the min limit
// //
// //
//    //////////////////////////////////////////////////////// Page: 4.2
//  ////////////  LINEAR JOINTS CONSTRUCTORS  //////////
// ///
// //
// //        new Piston(
// //            String      Name
// //            , String    Axis  // ( "X", "-X", "Y", ... ) Reffer to the Axis Tips bellow for details.
// //            , Single    MaxSpeed  // (m/s)
// //            , Single    SoftMaxLimit  // How soft should be the max limit
// //            , Single    SoftMinLimit );  // How soft should be the min limit
// //
// //        new RotorWheel(  // Not yet added
// //            String      Name
// //            , Single    Radius
// //            , String    Axis
// //            , Single    MaxSpeed  // (m/s)
// //            , Single    SoftMaxLimit  // How soft should be the max limit
// //            , Single    SoftMinLimit );  // How soft should be the min limit
// //
// //
//    //////////////////////////////////////////////////////// Page: 4.3
//  ////////////  SOLIDS CONSTRUCTORS  //////////
// ///
// //
// //        new SolidLG(  // Solid Large Grid
// //            Single      X  // 1 = 2.5m
// //            , Single    Y  // 1 = 2.5m
// //            , Single    Z  // 1 = 2.5m );
// //        new SolidsG(  // Solid Small Grid
// //            Single      X  // 1 = 2.5m
// //            , Single    Y  // 1 = 2.5m
// //            , Single    Z  // 1 = 2.5m );
// //        new Cubits(  // Solid Cubits
// //            Single      X  // 1 = 2.5m
// //            , Single    Y  // 1 = 2.5m
// //            , Single    Z  // 1 = 2.5m );
// //
// //
//    //////////////////////////////////////////////////////// Page: 4.4
//  ////////////  CONTROLLER CONSTRUCTORS  //////////
// ///
// //
// //        new UserControl(
// //            Hardware    Arm  // The arm that will be controlled.
// //            , String    Name  // The name of the controller.
// //            , Limits    Workzone  // The zone limitation of the tip of the arm
// //            , Single    Speed  // The maximum speed your arm should go (m/s)
// //            , Single    Softness  // How soft you want the controls
// //            , String    ShipControllerKeyword  // Your cockpit need this in it's name
// //            , bool      ReadKeyboard  // Read keyboard inputs WASDQEC"space"
// //            , bool      ReadMouse  // Read mouse movements
// //            , Hardware      ReferenceFrame );  // The referece frame for your inputs
// //
// //        new SequenceControl(  // Not yet ready
// //            Hardware    Arm  // The arm that will be controlled.
// //            , String    Name  // The name of the controller.
// //            , Limits    Workzone  // The zone limitation of the tip of the arm
// //            , Single    Speed  // The maximum speed your arm should go (m/s)
// //            , Single    Softness  // How foft you want the controls
// //            , String    ShipControllerKeyword  // Your cockpit need this in it's name
// //            , bool      ReadKeyboard  // Read keyboard inputs WASDQEC"space"
// //            , bool      ReadMouse  // Read mouse movements
// //            , Hardware      ReferenceFrame );  // The reference frame for your inputs
// //
// //
//
/////////////////////////////////////////////////  Page: 4  //////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////








    ///////////////////////////////////////////////  Page: 5  //////////////////////////////////////////////////////
  /////////////////////////////////  A X I  S  T I P S
///
//
//        The Axis system in MArmOS respect the "Right Hand Rule":
//                          Z (Thumb)
//                            |
//                            |
//                            |
//                            |______Y (Middle finger)
//                          /
//                        /
//                    /
//                  X (Index finger)
//
//        Also, MArmOS's axis convention is:
//        - "X" = Forward
//        - "Y" = Left
//        - "Z" = Up
//
//        You can put a "-" when you want the oposite of an axis. e.g. "-Z" is the opposito of "Z".
//
//        Finally, When working with rotors, the axis of rotation is in
//        the direction the rotor head is facing.
//        Pistons uses the same logic.
//
//
//
///////////////////////////////////////////////  Page: 5  //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////






    ///////////////////////////////////////////////  Page: 6  //////////////////////////////////////////////////////
  /////////////////////////////////  C L A S S  M A P
///
//
//        (Hardware)
//        |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|
//        (Solid)                                      (Rotary)                      (Linear)              (Addition)  (Multiplication)
//        |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|                |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|                  |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|
//        (SolidSG)  (SolidLG) (Cubits)    (Rotor)    [Hydraulic]  (Piston)  [RotorWheel]
//
//
//        (Controller)
//        |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|
//        (UserControl)  (Arguments)  (sequence)
//
//
//        [Limits]
//        |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|
//        [Prism]    [Cylinder]  [Sphere]
//
//        For more information, go check the MArmOS 3.0 steam guide.
//
//
//
//
///////////////////////////////////////////////  Page: 6  //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////







    ///////////////////////////////////////////////  Page: 7  //////////////////////////////////////////////////////
  /////////////////////////////////  M A I N
///
//
//    This Function is executed at every runs.
//    You can Use it to do the same things you would do with the usual Main()
//    note: Since 3.0, it is no longer needed to manually update your controllers here.
//
//
void MArmOS_Main( String argument ){









}
//
//
//
///////////////////////////////////////////////  Page: 7  //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////







    ///////////////////////////////////////////////  Page: 8  //////////////////////////////////////////////////////
  /////////////////////////////////  G E N E R A L  P A R A M E T E R S
///
//
//    Here are some usefull parameters that you may want to setup.
//
//

static String EchoScreenName =    "MArmOS Echo";  // Your arms’ status will be displayed on these panels.
static String DebugScreenName =    "MArmOS Debug";  // Your arms’ debug info will be displayed on these panels.
static String LogScreenName =    "MArmOS Log";  // A short log of the main events will be displayed on these panels.
static uint              NORMALFPS = 60;
static Single            dt = 0.1F;  // Derivation constant.







//
//
//
///////////////////////////////////////////////  Page: 8  //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 

Hello everyone,
The development of V3.0 is coming along very well. The closed testing people have been playing with the script for a week now and I only received positive feedback since. Because of that, I expect to be able to release V3.0 to the public in the coming weeks. The new script will be way more user friendly and simple to use. But until it's done I'd recommend new people to wait before trying to learn the script so they don't have to learn the old (more complex) ways.

 

Here is a little teaser to show how simple the new arm definitions will be.

 

This is gonna be awesome. Can't wait to make a shipyard with this.

 

MArmOS is coming in less than 24 hours.
I guessed some people might like to know that.
--- Automerge ---

MArmOS V3.0 is out! It's time to enjoy!

 

Quick! to the frontpage!

 

Here is the first video tutorial.

 

super cool

 

Uuuh I was going to play ME that weekend but I think I have to tinker with SE now. This is a exreamly cool script! 3.0 seems to make it very easy now to set everything up.

One question thoe. Would it be possible to get a position read out at certain states and than gather them in a path script. So you could basicly automate a arm. It could be done with a second prog. Block which has the gathered states in it and pushes it to Marmos. But I don't know how you gather the rotor and piston angels, positions and speeds. Would love to know. Also if it even is possible in SE. You would be the first to know if such a thing would be possible

 

@Silentfighter89 There is a way to register the current arm position into a text panel. I called it the "PrintPosition" command. It basically write a "MoveTo" command that can tell the arm to go to that position. You can then copy/paste it into a timer or a hotkey to execute it anytime. You could also use the easy automation script to make sequences I believe.

The synopsis of the PrintPosition command is:

Code:

PrintPosition TextPanelName
or
-PP TextPanelName

 

Great, I defensively have to play with it now...I come from the mechanical industries there is nothing more beautiful (In my job I mean with that) than watching machines / robots work in perfect harmony.

 

This may be off-topic but I just saw the most epic movie scene of all time.

@GrindyGears I bet you'll like it.

 

I have sneaking suspicion grindy does not like if you are trying to say excavators are actually toothpicks

 

Heh. Good old fashion pumper trucks. a really amazing bit of engineering work, but unfortunately useless in space engineers (as a direct usage)

Making something that complex out of small grid would be an incredible challenge, and im not quite sure if i'd even want to try

Though a interlaced unit like that probably lends quite well to you're scripts.