Skip to content

Latest commit

 

History

History
259 lines (215 loc) · 13 KB

Parts.md

File metadata and controls

259 lines (215 loc) · 13 KB

Acrylic case

Idea:

The left-hand side panel is attached to the structure permanently with some screws; use the step drill bits to add holes for access to the USB port and to mount the power switch.

A bottom plate might be wise to protect the electronics while moving around.

The rest of the structure is kind-of-optional. I basically made a 20x30x~5cm enclosure, using the cement to glue the edges. The hole saw is just big enough for the lidar unit to fit through the case.

Structure

Idea:

A lot of the design was informed by the mecanum wheels, aka The Single Most Expensive Item on this parts list. You may be able to get cheaper ones on e.g. ebay.

The Mecanum wheels come in pairs: 2 left-hand side and 2 right-hand side, based on how the casters are oriented. The correct way to mount them is so that, when viewed from above, the casters for each wheel point towards the center of gravity of the robot (forming an X).

The Mecanum wheels let you move sideways by turning the wheels in opposing directions. For that to work, the wheels need to be in a square configuration.

In my case, that meant:

Use two 30cm makerbeams for the length; use two 20xm for the width. Use the 90 degree brackets to make a 22cm (20 + 1 + 1) wide by 30cm long rectangle. Attach the motor mount directly to the bottom of this at the very corners (using 3 out of the 4 mounting holes on the motor brackets). Attach the motors to the brackets with the shaft near the bottom (using the eccentric gear box to give you a bit more ground clearance).

Attach the wheel hubs to the mecanum wheels; attach the hubs directly to the shaft. The shaft will have some slop, so leave some space between the hub and the motor so that they don't touch when you put weight on the wheels.

That gives you a rectangle with wheels; I added some vertical space below that basic frame to hold the electronics and the battery.

The vertical space consists of a separate 17cm (== 15 + 1 + 1) long by 22cm (== 20 + 1 + 1) wide makerbeam rectangle that hangs about 2cm below the main frame. This 'height' puts the bottom of that rectangle at about the same ground clearance as the motors and the axles. It is lined up with the forward two motor brackets.

To get the four 2cm pieces, I sawed the ends off two 10cm makerbeams. The corner cubes make it really easy to attach the ends of three beams in one place. Hacksawing through aluminium is not too bad, though you may want to have some 120-grit sandpaper around to smooth the edges.

Electronics

Idea:

Power + motors

The old-school v1 motor shield uses a bunch of pins on the arduino instead of something like I2C; it can drive all four motors in both directions at different speeds. I haven't run out of pins yet, and we'll be using the I2C bus heavily for sensor data. I might try the I2C version at a later date if I start running low on pins.

The motor shield takes power directly from the LIPO battery (with the power switch in between to interrupt the positive terminal). REMOVE the jumper that lets you power the Arduino itself from the motor board. Connect the buck convertor input to the battery directly, and connect its output to the Vin pins on the Arduino.

There's a couple of reasons for this:

  1. The regulator in the buck converter lets you draw more current through the Arduino + peripherals than the built-in regulator in the arduino. Note that the Arduino will be powering the LIDAR laser, LIDAR motor, the LEDS, and the bluetooh breakout, and the LiPo battery maxes out at just under 15V when fully charged. The built-in regulator heats up propotional to the amount of current and the voltage difference, so it'll work great right until it catches fire.

  2. The switching regulator ought to be much more efficient than the linear regulator in the Arduino.

                            (+)[converter in][converter out](+)
                             |                               |
    [battery](+)--[switch]--(+)[motor shield]               (5V)[Arduino]
             (-)------------(-)**remove jumper**            (Gnd)                  
                             |                               |    
                            (-)[converter in][converter out](-)

Bluetooth

The Bluetooth breakout board comes with a decent set of pinout instructions at AdaFruit. I soldered the breakout onto a prototype board and connected the prototype board to the Arduino using a 6-wide ribbon cable (with a JST connector for the prototype board to make stuff easier to disconnect if needed).

LEDs

I superglued a JST connector to a piece of acrylic, which I then mounted to some of the structure. Super useful for helping debug things. Note that the NeoPixel rings use a pretty timing-sensitive protocol (no separate clock wire like I2C), so changing the pixels often will mess with your ability to receive LIDAR data. It might not be unreasonable to find some different 'individually addressable' set of LEDs that doesn't rely on a 2-wire protocol.

Finally, note that this is just 12 LEDs, which is why we can power them directly off of the Arduino's power rail. Attaching more LEDs might take a bit more though, since it probably isn't a good idea to draw much more current through the traces on the Arduino.

Lidar

The LIDAR unit takes a bit of work. It communicates with the Arduino over a serial connection at 115k baud. It pushes a lot of data, and the Arduino has exactly one (1) byte of buffer, so you lose packets of LIDAR data every time you block interrupts for longer than ~1100 CPU clock cycles at 16 Mhz. In addition to handling the sensor data (360 16-bit ints per rotation), you'll need to actively control the speed at which the motor spins that thing around.

I used the diagram here to wire up the LIDAR: https://github.com/bombilee/NXV11/blob/master/ArduinoMegaAdapter/ArduinoMega%20XV-11%20LDS%20Adapter%20Schematic.png

I put this together on one of the pieces of PCB prototype boards; one of the resistors, one N-channel MOSFET, and one diode are there to let you safely drive the motor off of a single PWM pin. I connected the data (serial port) stuff to the serial 3 pins on the Arduino. This is a good reason to use the MEGA: it supports up to 3 serial interfaces, so you can still debug via USB while receiving data from the LIDAR unit.

The JST connector on the LIDAR is smaller than the 2.54mm pitch ones we're using elsewhere, so you may need to bend some pins to be at the right distance.

Structure: the LIDAR is oddly shaped, so the 4 screw holes don't line up to a rectangle. I worked around this by rotating the unit (the motor is a bit off to the side) and mounting it with 3 screws rather than 4. I used 3 more hacksawed pieces of makerbeam to get the right offset relative to the bottom of the robot.

VL6180X sensors

I got 8 of these, to match the number I could use with one I2C multiplexer. The VL6180 is kind of annoying: even though it supports I2C, there is no way to permanently change the I2C address of each chip. Instead, you would need to power on each chip individually, then change its address, then power on the next one, etc. More typical I2C hardware lets you set the address using e.g. jumpers.

We're using the I2C multiplexer to solve this. The downside is that it requires 4 leads (power, ground, I2C data, I2C clock) from the multiplexer to each sensor, so it's a bit messy. I used lots of 4-wide ribbon cables and JST connectors for this.

we mounted these sensors as low as possible on the structure, with 3 in front, 2 on each side, and one in the back.