90 ton 1/14 metal excavator scratch build w/embedded PC

[SteinHDan]

You can try the visualization on your own PC by clicking on this link:
- http://d1t2tbzmskak12.cloudfront.net...ion/index.html




To view the client source code, just click "View source" on the web page.

The web page will try to connect to the excavator using the local IP address 192.168.0.107:8001. If it isn't able to connect, it will just play some random movements. Only computers on my network will be able to connect to my excavator, so you all will see the random movements.


On the excavator (the server in this case) I run these few lines to broadcast the positions to all clients that connect:

var ws = require("nodejs-websocket")
var server = ws.createServer().listen(8001);
setInterval(function() {
    server.connections.forEach(function (conn) {
        conn.sendText(JSON.stringify({bucket: state.bucket.pos, stick: state.stick.pos }));
    })
}, 40);

That's all there is to it!

Best regards,
Stein :-)

[SteinHDan]

This is now the code on the motor controllers, that has the new current limiting, position reporting and position end limits, acceleration and variable braking.

You don't need to understand any of this code to use it. Just:

1. Connect the USB cable to a PC
2. Download the Arduino programmer: https://www.arduino.cc/en/Main/Software
3. Copy and paste the code below into the programming tool
4. Set the device ID on the second line (any number from 0 to 255, used to identify the controller later) I'm using device IDs 10, 11 and 12 for this build.
5. Click the "Upload" button

Done!

[SteinHDan]

/*  Based on the MonsterMoto Shield Example Sketch by: Jim Lindblom */
#include <limits.h>
int deviceId = 10; // TODO: Set this to a unique ID for each controller!


#define BRAKEVCC 0
#define CW   1
#define CCW  2
#define BRAKEGND 3

// VNH2SP30 pin definitions
int inApin[2] = {7, 4};  // INA: Clockwise input
int inBpin[2] = {8, 9}; // INB: Counter-clockwise input
int pwmpin[2] = {5, 6}; // PWM input
int cspin[2] = {2, 3}; // CS: Current sense ANALOG input
int enpin[2] = {0, 1}; // EN: Status of switches output (Analog pin)

// Position sensors
int pospin[2] = {4, 5}; // Position sensors at ANALOG input 4,5

// Serial state
int inBytes[15];
int inBytesCount = 0;
int command = 0;
unsigned long lastCommandTime = 0;
unsigned long timeoutMillis = 1000; 

// Timing
int timerDivisor = 8;
int defaultTimerDivisor = 64;
int millisDivisor = defaultTimerDivisor / timerDivisor;

// Motor state
int current[2] = {0, 0};
int currentLimit[2] = { 160, 160 };
int overcurrentDivisor[2] = {8, 8};
unsigned long overCurrentTime[2] = {0, 0};
int direction[2] = { BRAKEGND, BRAKEGND };
int directionWanted[2] = { BRAKEGND, BRAKEGND };
int speed[2] = { 0, 0 };
int speedPrev[2] = { 0, 0 };
int speedWanted[2] = { 0, 0 };
int acceleration[2] = { 100, 100 };
int position[2] = { 511, 511 };
int positionMin[2] = { INT_MIN, INT_MIN };
int positionMax[2] = { INT_MAX, INT_MAX };
bool positionMaxTriggered[2] = { false, false };
bool positionMinTriggered[2] = { false, false };
int positionHysteresis[2] = { 100, 100 };

// Loop state
unsigned long lastTime = 0;
unsigned long now = 0;
int speedScaler = 4;


void setup() {
  setPwmFrequency(5, timerDivisor);
  setPwmFrequency(6, timerDivisor);
  
  // Initialize digital pins as outputs
  for (int i=0; i<2; i++) {
    pinMode(inApin[i], OUTPUT);
    pinMode(inBpin[i], OUTPUT);
    pinMode(pwmpin[i], OUTPUT);
  }
  // Initialize motors braked
  motorGo(0, BRAKEGND, 255);
  motorGo(1, BRAKEGND, 255);
  
  // start serial port at 9600 bps:
  Serial.begin(9600);
  while (!Serial) {
    // wait for serial port to connect. Needed for native USB port only
  }
}


void loop() {

  // Keep time
  now = millis() / millisDivisor; // to account for the change of the timer by setPwmFrequency below

  // Read commands from serial port
  if (Serial.available() > 0) {
    int inByte = Serial.read();
    if (inByte > 127) {
      inBytesCount = 0;
      command = inByte;
      switch(command) {
        // 0x90 & 0x91: Get Motor M0 & M1 Current
        case 0x90: Serial.write(current[0] / 4); command = 0; break;
        case 0x91: Serial.write(current[1] / 4); command = 0; break;

        // 0x94 & 0x95: Get Motor M0 & M1 position
        case 0x94: Serial.write(position[0] / 4); command = 0; break;
        case 0x95: Serial.write(position[1] / 4); command = 0; break;
      }
      lastCommandTime = now;
    }
    else if (command != 0) {
      if (inBytesCount < 14) {
        inBytes[inBytesCount] = inByte;
      }
      inBytesCount++;
      switch(inBytesCount) {
        case 1: {
          int inSpeed = inByte * 2; // From 0-127 range to 0-254 range
          int motor = -1;
          int inDirection = CW;
          switch(command) {
            case 0x86: motor = 0; inDirection = BRAKEGND; break;
            case 0x87: motor = 1; inDirection = BRAKEGND; break;
            case 0x88: motor = 0; inDirection = CW; break;
            case 0x8A: motor = 0; inDirection = CCW; break;
            case 0x8C: motor = 1; inDirection = CW; break;
            case 0x8E: motor = 1; inDirection = CCW; break;
            case 0x83: {
              if (inBytes[0] == 0) {
                Serial.write(deviceId);
              }
              command = 0;
              break;
            }
          }
          if (motor != -1) {
            speedWanted[motor] = inSpeed;
            directionWanted[motor] = inDirection;
            command = 0;
          }
          break;
        }
        case 4: {
          // 0x84, parameter number, parameter value, 0x55, 0x2A // Set parameter
          // Parameter number 8 and 9 are the current limits for motors 0 and 1 respectively
          switch(command) {
            case 0x84: {
              int retVal = 1;
              if (inBytes[2] == 0x55 && inBytes[3] == 0x2A) {
                retVal = 0;
                switch(inBytes[0]) {
                  case 4: acceleration[0] = inBytes[1]; break; // 0-127
                  case 5: acceleration[1] = inBytes[1]; break; // 0-127 
                  case 8: currentLimit[0] = inBytes[1] * 8; break; // 0-1016
                  case 9: currentLimit[1] = inBytes[1] * 8; break; // 0-1016 
                  case 72: positionMax[0] = inBytes[1] * 8; break; // 0-1016
                  case 73: positionMax[1] = inBytes[1] * 8; break; // 0-1016
                  case 74: positionMin[0] = inBytes[1] * 8; break; // 0-1016
                  case 75: positionMin[1] = inBytes[1] * 8; break; // 0-1016
                  case 76: positionHysteresis[0] = inBytes[1] * 8; break; // 0-1016
                  case 77: positionHysteresis[1] = inBytes[1] * 8; break; // 0-1016
                  default: retVal = 2; break;
                }
              }
              Serial.write(retVal);
              command = 0;
              break;
            }
          }
          break; 
        }
      }
    }
  }



  // Update motor state every 10ms
  if (lastTime == 0 || now < lastTime) { // If the first time or when the millis() values wrap, we need to fix the lastTime to be before the now time.
    lastTime = now;
  }
  if (now - lastTime >= 10) {
    lastTime = now;
      
    for (int i = 0; i < 2; i++) {
      bool sameDirection = direction[i] == directionWanted[i];
      direction[i] = directionWanted[i];
      speed[i] = speedWanted[i];
      
      if ((direction[i] == CW) || (direction[i] == CCW)) {
  
        // Apply accelleration limiting
        int accelSpeed = speedScaler * speed[i]; // 10ms loop time and *4 gives the 40ms as in the Pololu controller
        if (direction[i] == CCW) {
          accelSpeed = -accelSpeed;
        }
        if ((acceleration[i] > 0) &&
            (!(sameDirection && (abs(accelSpeed) < abs(speedPrev[i])))) &&
            (abs(accelSpeed - speedPrev[i]) > acceleration[i])) {
          accelSpeed = speedPrev[i] + ((speedPrev[i] > accelSpeed) ? -acceleration[i] : acceleration[i]);
        }
        direction[i] = accelSpeed < 0 ? CCW : CW;
        speed[i] = abs(accelSpeed / speedScaler);
        speedPrev[i] = accelSpeed;
  
        // Apply current limiting
        current[i] = analogRead(cspin[i]);
        // If overcurrent, kill the output
        if (current[i] > currentLimit[i]) {
          overcurrentDivisor[i] = 0;
          overCurrentTime[i] = now;
        }
        // Slowly bring it back
        if (now > overCurrentTime[i] + 1000 && overcurrentDivisor[i] < 8) {
          overcurrentDivisor[i]++;
          overCurrentTime[i] = now;
        }
        speed[i] = speed[i] * overcurrentDivisor[i] / 8;
        
      }
    
      // Apply position limits
      int readPosition = analogRead(pospin[i]);
      int changeLimit = positionHysteresis[i] / 2 + 10;
      if (abs(readPosition - position[i]) > changeLimit) {
        position[i] = position[i] + (position[i] > readPosition ? -changeLimit : changeLimit);
      } else {
        position[i] = readPosition;
      }    
      if (position[i] > positionMax[i]) {
        positionMaxTriggered[i] = true;
      }
      if (position[i] < positionMax[i] - positionHysteresis[i]) {
        positionMaxTriggered[i] = false;
      }
      if (position[i] < positionMin[i]) {
        positionMinTriggered[i] = true;
      }
      if (position[i] > positionMin[i] + positionHysteresis[i]) {
        positionMinTriggered[i] = false;
      }
      if ((positionMaxTriggered[i] && direction[i] == CW) ||
          (positionMinTriggered[i] && direction[i] == CCW)) {
        direction[i] = BRAKEGND;
        speed[i] = 255;
        speedPrev[i] = 0;
      }
  
      // Stop on serial command timeout
      if (now - lastCommandTime > timeoutMillis) {
        direction[i] = BRAKEGND;
        speed[i] = 0;
        speedPrev[i] = 0;
      }
    
      motorGo(i, direction[i], speed[i]);
    }
  }
  
}



void motorGo(uint8_t motor, uint8_t direct, uint8_t pwm) {
  if (motor >= 0 && motor < 2 && direct >= 0 && direct < 4 && pwm >= 0 && pwm < 256 ) {
    digitalWrite(inApin[motor], (direct == BRAKEVCC) || (direct == CW) ? HIGH : LOW);
    digitalWrite(inBpin[motor], (direct == BRAKEVCC) || (direct == CCW) ? HIGH : LOW);
    analogWrite(pwmpin[motor], pwm);
  }
}



void setPwmFrequency(int pin, int divisor) {
  byte mode;
  if(pin == 5 || pin == 6 || pin == 9 || pin == 10) {
    switch(divisor) {
      case 1: mode = 0x01; break;
      case 8: mode = 0x02; break;
      case 64: mode = 0x03; break;
      case 256: mode = 0x04; break;
      case 1024: mode = 0x05; break;
      default: return;
    }
    if(pin == 5 || pin == 6) {
      TCCR0B = TCCR0B & 0b11111000 | mode;
    } else {
      TCCR1B = TCCR1B & 0b11111000 | mode;
    }
  } else if(pin == 3 || pin == 11) {
    switch(divisor) {
      case 1: mode = 0x01; break;
      case 8: mode = 0x02; break;
      case 32: mode = 0x03; break;
      case 64: mode = 0x04; break;
      case 128: mode = 0x05; break;
      case 256: mode = 0x06; break;
      case 1024: mode = 0x7; break;
      default: return;
    }
    TCCR2B = TCCR2B & 0b11111000 | mode;
  }
}

[SteinHDan]

Added the final angle sensor that reads the angle of the boom. This sensor is the same as the previous two, except that it's mounted a bit differently and it has no cover.

With this sensor in place it's finally possible to run the excavator without risking to break it. :-)

If I have time later I'll try to read the rest of the positions and angles with encoders for the swing and tracks, and an IMU (BNO055) + GPS for the house.

[Trucker Al]

Beautiful form and fit, just outstanding !!

[SonoranWraith]

When you say charge connector...are you planning on charging a lipo in your model?

[SteinHDan]

Originally Posted by SonoranWraith

When you say charge connector...are you planning on charging a lipo in your model?

I want to allow for it to be charged inside the model, but most of the time, I'll take the battery out to charge it.

I know of the general rule not to charge inside the model, but I charge very lightly (only 1A out of the 1C 4.5A normal charge current) and also the compartment where the battery lies is well ventilated so heat should not build. But of course, time will tell. I guess when you charge inside the model, you should assume that everything can catch fire, and place the model in such a way that it would not burn down your house or garage if that happens.


Best regards,
Stein :-)

[SteinHDan]

Test digging gravel and also testing the audio and the smoke generator. The engine sound will be replaced with an excavator sound and both the sound and the smoke will be made to adjust according to the power output of the machine when it's working.





https://youtu.be/MyzdAea7NRI

[SteinHDan]

The smoke generator was the surprise that I promised earlier :-)

It works quite well as you can see on the video above. I mounted it so that the output is at the same location as the exhaust on the original CAT 390 F.




Ebay link:
- http://www.ebay.com/itm/112036055150

I have the 12V, "standard NON ESC" version with red color. I control the variable output with the first channel on the fourth motor controller.

[RexRacer19]

Great idea using the smoke machine. The RC drift guys have been trying to use smoke generators for a while now with mixed results. I think it should work well for your application though since it doesn't require the volume of smoke that a car needs.

[SteinHDan]

Lately I've been working on designing and printing the house of the excavator. I want:
- To have quick access to the on/off switch, voltage meter and the sound volume control
- To have easy access to all the electronics inside the excavator house.

For the first item, I designed the lid above the control panel:





So that makes it easy to quickly turn the machine on/off or to change the sound volume.


But for getting access to everything, i wanted to be able to remove as much of the house as possible in just one piece. So I designed most of the body to be just one big piece that can removed by unscrewing four thumb screws from below. The exception is the cab and the thing on the front on the other side (whatever it's called, anyone knows? :-) ). This gives very good access to everything that's mounted on the upper structure base plate:




















The body attaches to the base plate with four thumb screws, one in each corner:







This body is much to big for my 3D printer, so I had to break it up into nine individual parts. And even each of them was almost to big for my machine.







The printing time for each of these is between 10-15 hours, so that means there's more than 100 hours of continuous printing in this body.









I'll add some photos of the parts and how they are connected together shortly.


Best regards,
Stein :-)

[Doggy]

Great work, loving the details. Dont know how good your printer is, but if I were you, I would remove this grills, and print them separatly.

[SteinHDan]

Hi Doggy!

Yes, I could probably get them even nicer if they were separate pieces. But now it's already done and also it's less pieces to handle when it's in one part. The number of parts on this machine is growing rapidly.. :-)

Best regards,
Stein :-)

[SteinHDan]

I experimented a bit to figure out the smallest mesh size I could print without supports on my 3D printer. On the original, the meshes in the doors and in the platform look like this:






I can't make that fine lines easily, so I made the meshes a bit coarser. On the platform it's supposed to be two rows of six holes, but on this model it is two rows of three.

At a distance it all looks quite similar, though.

The mesh lines are 0.8mm thick This is because the print head nozzle is 0.4mm wide and I need two lines beside each other to print the mesh nicely without supports on my machine. The layer height is 0.2mm and thus there are 4 layers in the vertical direction to make up the 0.8mm mesh line size.

Also, the mesh had to be coarse enough to allow air to flow through, as the air is needed for the cooling of the motor controllers on the inside.

Detail images:






The parts:

Counterweight:




Doors:




Smoker air intake and smoker exhaust:




Lid and temporary hinge pin mechanism:




Tanks:




Steps:
(this is printed in yellow and then painted partially black afterwards)

[RexRacer19]

Your prints are coming out really nice. What 3D printer do you use? Are you able to change your nozzle size for printing some finer details?

[SteinHDan]

Hi RexRacer19!


This is the machine I have:
- MakerBot Replicator 2X

It's a very standard configuration, very similar to most all 3D printers sold today. I think it is possible to get this quality with most all current printers.
If you don't, then have a look at this very good print-quality-troubleshooting page:
- https://www.simplify3d.com/support/p...oubleshooting/

But mine is quite an old 3D printer. I think these days, you can get better offers. The only important thing is that you can print ABS, because it's so much tougher than PLA (less brittle). And then you need a heated build plate for ABS printing. Maybe one of these could do the job:
- Ultimaker 2
- Zortrax M200 Pro
- FlashForge Creator Pro

I've not tried any of them, but I've heard some good things about them and the specs look ok. There's probably lots of reviews on youtube.


I think most 3D printers that work with filament have 0.4mm nozzles. You can change to 0.2mm to get finer detail, but that will also make the print take a lot longer (4 times as long if you print the same object with the same wall thicknesses, and if the print time was 10 hours, then the new print time is 40 hours..).



Best regards,
Stein :-)

[RexRacer19]

Stein,

Thanks for the detailed reply. That is a good printer that you have. My first printer was actually the FlashForge Creator Pro, that I purchased to use at the company that I worked for. It worked very well.

I no longer work for that company, but since bought a printer for home use. It is a Makerfarm Pegasus 10". It does a nice job, and has a large build volume. The hot end is a E3D V6, and I have that on a E3D Titan extruder. It is a very customizable platform, and easy to upgrade. It all runs on Simplify 3D.

I will have to post up some details and pics sometime in my 963K build thread.

-Jeff

[SteinHDan]

I'm looking forward to that, Jeff!

Stein :-)

[SteinHDan]

I don't like doing non-reversible operations like gluing, painting and welding, because it's then a lot a work to make small adjustments to parts. And when doing prototyping like this, you make small changes all the time. I think I've had the machine built completely up and down around five times now..

Anyways, sometimes you need to do those types of operations anyway, either because it's the only way or I'm not able to think of any other way.. ;-)

I've glued the counterweight pieces together now. First there are three 75mm M3 threaded rods. They don't screw into anything, they are just there to align the pieces and give more strength. Then the two pieces slide together:








I think the best glue to use for a certain type of plastic is... more of that same plastic! Dissolved in acetone. This approach works very well with ABS.

For this model, I've just cut the yellow 3D-printer filament into very small pieces and put them into a glass jar. Then add acetone and let dissolve for a couple of days (depends on the size of the pieces).








I've also glued in the stainless steel M4 nuts that hold the body to the base plate with the thumb screws. One in each corner:





Just a tiny amount of glue is needed here. We just don't want the nuts to come loose when the thumb screws are not holding them in place.






Ebay link:
- Thumb screw - 10pcs M4 x 15mm

[SteinHDan]

The body goes together by using eight M3 threaded rods, four self-tapping screws and two M3 machine screws.

First M3 nuts are inserted into slots in the counterweight parts:






Then the threaded rods are screwed into the nuts:





The rear doors slide onto the threaded rods, and are attached with an additional two M3 20mm long bolts:








The front doors also slide onto the threaded rods. They are attached to each other in the middle by three M3 bolts and locking nuts. This attachment is the bridge that holds any weight on top of the house body.






Finally the tanks and the steps slide onto the threaded rods:




For these two parts, there are four additional self-tapping screws that attach the tanks and steps to the front doors:




At the end of the threaded rods, there are M3 nuts countersunk into the end of the front parts. Since they are completely inside the part, a socket screw driver is needed to fasten them: