O Falcão

I needed a LEGO mechanism that could turn ON or OFF an electrical circuit using an independent power source. This power source could be a regular LEGO battery but could also be a different type. So a LEGO relay.

I remember seeing somewhere a few LEGO mechanisms with the same purpose, like moving the slider of a Power Functions battery box or rotating an axle inside of a Power Function switch… but could not find them.

So this is my own implementation.

I used a Power Functions switch. We can mechanical control the switch with a Technic axle inserted in two different ways – over the top or through it:

I decided to insert the axle through it. As the idea is using a MINDSTORMS to control the relay, I could have connected the axle directly to a motor and control the time or the angle. But I started with a Power Functions motor connected to a Power Functions battery and since the motor is too strong and fast I used a clutch gear to protect the switch when extreme position is reached.

The switch has 3 working positions where the neutral (middle) is the OFF position and both left and right extremes are ON both with opposite polarities. As I just wanted ON and OFF I needed to limit the motion to just half.

Perhaps not most the efficient mechanism or beautiful design but this works:

The cam gears were the first piece I found with the proper size – when the switch is off the cam gears touch the Technic grey brick so if the motor keeps rotating the clutch gear will slip and protect the switch axle.

The relay works with power Functions cables so regular LEGO batteries and devices can be used. But I used a 2.1 mm female jack with a pair of crocodile cables to connect an old LEGO electric plate to a 12V/1.5A wall power supply and a custom Power Functions cable with male headers soldered to it to connect to a kanthal wire.

I prefer to use kanthal wire instead of nichrome wire for several reasons: it has a higher electrical resistence and also a higher melting temperature… and it is also widely available now that vaping is a trend (I don’t smoke but could not find a single nichrome supplier here in Portugal but have several online vaping stores selling dozens of variants of kanthal wires). Metal strings used with guitars also work and are easy to find but electrical resistance is too low.

So I used a 20 cm piece of kanthal wire to make a coil with perhaps a dozen turns and test it several times:

Then connected the coil endpoints to 2 crimp pins and soldered it to the custom Power Functions wire (it’s not easy to solder kanthal wire so crimping is a better option)

And now I have a MINDSTORMS controlled ignitor. Great for hobby rockets or party candles:

Remember: don’t try to do this if you don’t fully understand it. Also keep in mind that although party sparkles aren’t dangerous per se igniting one near flammable products can start a fire. Always take safety measures.

Edit:

And the bash script for the sparkle ignitor’s video (ev3dev):

#!/usr/bin/env bash

MTRTIME=1000   # 1 second
MTRSPEEDON=-650
MTRSPEEDOFF=650
PAUSE=1 # MTRTIME / 1000

IGNITION=10 # ignition time in seconds

function Init {
    echo "Start"
    echo $MTRTIME > /sys/class/tacho-motor/motor0/time_sp
}

function SwitchON {
    echo $MTRSPEEDON > /sys/class/tacho-motor/motor0/speed_sp
    echo run-timed > /sys/class/tacho-motor/motor0/command
    sleep $PAUSE
}

function SwitchOFF {
    echo $MTRSPEEDOFF > /sys/class/tacho-motor/motor0/speed_sp
    echo run-timed > /sys/class/tacho-motor/motor0/command
    sleep $PAUSE
}

function SpeakCountdown {
    espeak -a 200 -g 12 -p 70 "Ten"
    espeak -a 200 -g 12 -p 70 "Nine"
    espeak -a 200 -g 12 -p 70 "Eight"
    espeak -a 200 -g 12 -p 70 "Seven"
    espeak -a 200 -g 12 -p 70 "Six"
    espeak -a 200 -g 12 -p 70 "Five"
    espeak -a 200 -g 12 -p 70 "Four"
    espeak -a 200 -g 12 -p 70 "Three"
    espeak -a 200 -g 12 -p 70 "Two"
    espeak -a 200 -g 12 -p 70 "One"
    espeak -a 200 -g 12 -p 70 "Zero"
}

function SpeakHB {
    espeak -a 200 -g 12 -p 70  "Happy birthday!"
}

function finish {
    SwitchOFF
    echo reset > /sys/class/tacho-motor/motor0/command
    echo "End"
}

trap finish EXIT

Init
SwitchOFF
SpeakCountdown
SwitchON
sleep $IGNITION
SpeakHB
SwitchOFF

Now that I have a working cable to intercept Powered Up signals I no longer need to cut a sensor cable to hijack it.

So let’s start with a simple sensor: the 45304 LEGO WeDo 2.0 Motion Sensor

Procedure:

1. connect the male plug of the Powered Up Interception Cable to LEGO BOOST Move Hub (port C)
2. connect a WeDo 2.0 Motion Sensor to the “female” plug of the Interception Cable
3. connect the Bus Pirate to the “interception” 6-pin header
4. connect the Bus Pirate to a USB port and set it up as a Transparent UART Bridge (115200 bps, 8N1, floating inputs)
5. run jpnevulator to read traffic comming from the Bus Pirate
6. turn of the LEGO BOOST Move Hub
7. connect to it with gatttool
8. enable notifications (‘char-write-req 0x0f 0100’)
9. enable the Motion Sensor on port C (‘char-write-req 0x0e 0A004101000100000001’) in mode ‘0’
10. watch, watch, watch

So everytime the measured distance change I get a notification in gatttool and a 3-byte message in jpnevulator. And it is simple:

00 => C0 00 3F
01 => C0 01 3E
02 => C0 02 3D
03 => C0 03 3C
04 => C0 04 3B
05 => C0 05 3A
06 => C0 06 39
07 => C0 07 38
08 => C0 08 37
09 => C0 09 36
0A => C0 0A 35

A start byte (‘C0’) plus the payload  plus and end byte (‘3F’ i.e. the complement of ‘C0’ minus the payload).

Great! Not even an initialization sequence!

So disconnect the Interception Cable male plug and replace the Bus Pirate with the FTDI Beefy 3 adapter, set ‘/dev/ttyUSB3’ to 115200 and raw mode and test several bash commands.

Not totally clear yet but this works:

#!/usr/bin/env bash

# sync
for i in {1..50000}
do
    echo -e -n "\x00" > /dev/ttyUSB3
done

for i in {1..50000}
do
    echo -e -n "\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" > /dev/ttyUSB3
done

(that ‘echo’ command is just a line)

Now the usual voodoo explanation:

The first byte sent is like a read command. I got success with ’02’, ’04’, ‘0F’, ’27’ and ‘FF’ and 3 different behaviors.

The remaining 15 bytes (’00’) are like the inital synchronization commands… I don’t think they are valuable data and sending a ‘break’ to the TX line for enough time would do the same… but I just can’t find a way to send a break.

So the 3 different behaviors:

• ’02’ gets a lot of 3-byte messages from the Motion Sensor. Probably one message for each ’02’, I suspect 50 messages per second but need to check that. After a few minutes, it stops sending data.
• ‘FF’ gets much less messages, about 1 per second. And the message is now 5-bytes long: ‘7B C1’ or ‘7B C2’ followed by the 3-byte message above (like ‘C0 00 3F’). And after a few minutes the sensor also stops sending data. So ‘7B C1’ or ‘7B C2’ are warnings from the Sensor stating that it expects something more.
• Finally ’04’, ‘0F’ and ’27’ (and probably other values) make the Sensor behave in Mode 0 (i.e. just send data when distance changes). But it also expires after a while (I think sooner than other two modes) and the sensor sends a few ‘7B C1’ warnings followed by a read).

Now the interesting part is that if I keep moving something in front of the sensor it doesn’t “expire”. So it is probably some power saving definition, it would be nice if we could disable it.

So perhaps I’ve found a way to make my own sensor: if I can emulate the AutoID of the WeDo 2.0 Motion Sensor (device type ’23h’) I just need to send it short 3-byte messages (just 11 different values but that would be a start).

Fancy name 🙂

Arrived from holidays and had two small packets in the mail box:

• One from David Lechner with 2 Powered Up-compatible male plugs with cables already attached (and 4 great ev3dev stickers!)
• Other from Mouser Electronics with a few 1.27 mm headers I ordered to try to replicate Philippe “Philo” Hurbain idea to a pseudo female plug

So I finally made my own Powered Up extension cable with a third connector to sniff the communicares between the hub and a sensor or an interactive motor:

Philo hack works but it’s really tough to execute. My soldering skills aren’t great (my hands shake _a_lot_) and my vision is getting worse. But at my third attempt I got a working connection, not 100% tight but stable enough for my purposes.

Too bad I get back to work this week… I hope that spying the WeDo 2.0 tilt and motion sensors I can find something more about the protocol used on Powered Up sensors.

Next holidays don’t forget:

• USB soldering iron (great acquisition!) and decent thin solder wire
• small base for the soldering iron, with flexible arms if possible
• high current USB hub and a high current USB battery pack
• jumper wires (F-F, M-F, M-M, several colors)
• alligator wires (several colors)
• a few female headers compatible with the jumper wires (6 pin were great for EV3 and Powered Up hacking)
• multimeter
• Bus Pirate and BitScope (but a decent Logic Analyzer with linux support would be great)
• Ubertooth (but a more recent BLE sniffer with linux support would be great)
• a decent small wire stripper (still to be found)
• a few EV3 and Powered cables and plugs
• an Arduino and a NodeMCU
• a FTDI Beefy 3 breakout board (or 2!!!)
• a kit of resistors, diodes, capacitors and LEDs
• a small motor driver or H-Bridge breakout board (shame!!!)
• a swiss army knife
• of course some LEGO (at least one EV3 rover with wi-fi and BLE)
• some ziplock bags
• a good excuse