Placeholder

Joltron, a very shocking game

Wed, 14 May 2025 10:43:32 -0400

The Concept

I don't remember how I stumbled on it, but there's a party game where 4 players each hold a little handle with a button on it, there's a music playing, when the music stops the last player to press the button gets a shock. As soon as I saw that game I knew I had to make my own version.

The Shock

I immediately thought of the cheap high-voltage modules you can get on AliExpress/Amazon. I had briefly experimented with them in the past and it seemed like I had finally found a "practical" application for them. They usually take in 3 to 6 volts and are often advertised with an output of 400Kv or something ridiculous like that, they actually output in the range of 10Kv to 20Kv. That's still enough to produce electric arc a couple of centimeters long. That might sound scary but the current is very low and depending on the specific module the shock can range from a little pinch to a full arm numbness.

The Game(s)

At this point I knew I wanted to have a similar reaction-time game, but I also wanted more, I was looking for way to push the concept further. The idea that came to me was to make different minigames the players could compete in. The first game that would fit the format that came to my mind was the good old classic pong!

I also had a couple of little 128x64 OLED display that I really wanted to use. I planned to use at least one for menu screen but I was also looking very hard for an excuse to give one screen to each player. After much thinking I came up with a concept that did require players to have their own individual screens, a social game of voting and betrayal! Each player would vote for someone, the person with the most votes would loose and get the shock, unless they got all the votes, in that case the other players would get the shock.

The fourth game is a more complicated version of the reaction game, where player have to wait for multiple "conditions" to be fulfilled, the conditions being if the song is playing or not, how many leds of a certain color there is and how many of a certain shape there is on the main screen.

The Electronics

As usual, I reached for the trusty Arduino Nano which is cheap and compact to be the brain of this project.
The 5 lcd screens are connected via I2C but they all share the same address so I connected them to a TCA9548A multi-channel expansion board which lets me enable or disable channels from code. This way I can control which screen I'm sending data to, or even send the same data to multiple screens at the same time.
For playing music and sounds I selected a DFPlayer Mini, it's a little board with a MicroSD card slot that can play MP3 and be controlled from code. If I remember correctly, the speaker was scavenged from an old laptop. The whole thing is powered from a single 18650 lithium battery and a tp4056 charge/discharge board plus a XL6009 step-up booster to raise the voltage to 5V. There's also 3 push buttons on top to go through the menus and 10 addressable LEDs around them.

The original plan was to have a single high voltage module and to physically switch which remote it was connected to by rotating a servo with a series of connector. But that would probably have been unreliable, fragile and bulky. Instead I opted to put a taser module in each handle. That made more sense than trying to route 20kv inside the body of the game and through long wires.

The handles are made with a simple push button on the top, aluminum foils glued to pieces that come out on each side and connects to the high voltage module. These are large to ensure you will always make contact with both sides when you hold the handle, ensure you do get shocked if you lose. They connect to the body of the game through audio jacks so that if someone pulls their arm in surprise the handle can easily disconnect rather than tear or break the wires.

The Interference

I tested multiple times to make sure the mosfets I selected could trigger and the high voltage modules and hat I could control them from the arduino, everything seemed to worked perfectly. But once I assembled it into a handle, every time I tried to trigger an arc from the code, the Arduino would just crash or freeze. At first I thought the modules were pulling too much current or injected noise on the ground or power rails but adding capacitors didn't seem to help. I then tried to inspect the circuit at various points using my oscilloscope but I couldn't find any voltage peak or drop like I would have expected. I thought maybe since it produced electric arcs multiple centimeters long there might have been enough EM radiation to mess with the microcontroller, but no amount of shielding or keeping it far from the arc solved the problem.

In the end it turned out to be current induced into the wires for the button, which were running right next to the arc. The fix was simple, I just twisted that wire pair and the problem went away!

The Playing

The game turned out great, knowing you might get a shock if you lose really raises the stakes even if the games are relatively simple. The game also keeps track of each player's score and displays a scoreboard in between each game.

Convincing people to play is not always easy, especially after they hear the crackling of an electric arc, which can be quite loud! But in the end it's more scary than dangerous and when they do endup getting a shock people are generally relieved that it's not too bad and willing to continue playing. Although some people have higher or lower skin resistance and that means you can have one person that barely feels anything when they get the shock playing against someone that gets a more significant jolt, not the most fair situation but still a lot of fun!

Overengineered Automatic Cat Feeder

Sat, 28 Jan 2023 09:43:32 -0500

The Monsters

Two little perfect black balls of hair have elected domicile in my home. They are lovely, cuddly and HUNGRY!
When 6h AM rings, they come screaming and scratching at the door. Because I value my sleep and because I love adding to my pile of unfinished projects, I decided to make them an automatic cat feeder. Little did I know it would take me years to complete it.

The Idea

I had a few requirements, I wanted the machine to be:

reliable
The most important thing is that it works, and that it works consistently.
safe
If it doesn't work, I should be alerted one way or another.
Can't let the poor kittens starve because something malfunctioned.
configurable
If I need to change at which hour they get fed or how much to feed them, I don't want to be required to reprogram the device, there should be some sort of interface.
perennial
Ideally the reservoir should be big enough so that I can put at least a month worth of food. I want to just fill it and forget about it.

At the time we had a little litter box furniture, with an empty spot of the same size next to it. I thought it would be perfect to make my machine of the same size. I had been looking for an excuse to use an ESP32 with a camera for a while, this was the perfect opportunity. So the plan at that point was:

A big wood box for the structure and the reservoir
An ESP32 with a cam module, so I can spy on the little creatures
A webserver running on the ESP for the configuration interface and view the video feed
An Arduino Nano for handling controlling the electronics
Some sort of mechanism that can measure and dispense the food
Some sensor to detect if the food was actually dispensed

The reason I decided to use an Arduino in addition to the ESP is that the location I wanted to put the camera in was a bit far from where the rest of the electronics would be. Also, the ESP32-CAM board I had had a limited number of GPIO available and they can only provide 3.3V. Most of the parts I already had required 5V.

The Structure

One of the first thing I designed is the box. I took the dimension of the litter box furniture then guesstimated the width and height that would be needed for the electronics and dispenser parts. Leading to that compartment I added a 30 degree slope and that was basically it.

Once I had all the dimension it was a matter of laying out all the different rectangles together to see which size of plywood I needed to buy. I cut up the plywood with a circular saw and joined them with pocket holes. It was my first time trying pocket holes and I have to say, they are AWESOME.

It's basically a guide you clamp on the edge of a board, you adjust it for the width of your wood and when you drill with the special bit it makes a hole of the perfect angle and depth to screw into an adjacent board. It's super easy and quick to use and I couldn't be happier with the result, the box is super sturdy and rigid!

The structure's finishing touches were a coat of primer and white cabinet paint. I also added hinge for the top lid as well as a chest latch, to prevent the little devils from opening the lid and eating all the food.

The front access panel was originally on a hinge too but I later switched it to being screwed, it was easier to get right and it makes the inside much more accessible, which is nice for an access panel.

The First Prototype

During a failed attempt at making an automatic kombucha machine (automate all the things!) I designed an auger in OpenSCAD. OpenSCAD is a script-based CAD program and it's super fun, I'll probably make a blog post on that subject at some point. Anyways, the auger was fully parametric and powered by a 28byj-48 stepper motor. It seemed like a perfect fit for this project!

The issue is that that stepper motor isn't particularly strong. I found both the speed and the torque to be pretty low, even when overpowering it a bit. It took quite a while but after many iterations I figured out the right parameter of size, taper and angle for the auger to dispense food without getting stuck all the time. It was still very slow and tended to get stuck, but I was stuck too and it was time to move on to the next part.

My idea was to use a weight sensor to measure how much food to dispense. I designed a box with two compartment and the bottom of it swivels on an axis, a string was attached to the plate and connected to a wheel on a servo motor, turning the wheel pulls on the string, closing the bottom. The wire was routed over a weight sensor, so that the weight of the food on the plate would be applied on the sensor and it could be used to measure the amount of food in the compartments. In addition there's a "selector" tunnel, also on a servo motor, to control which compartment the food goes in, allowing the machine to dispense an equal amount of food into two bowls.

Most of it was working fine, the servo was able to rotate the wheel to open and close the bottom, the other servo rotated the selector to channel the food to one chamber or the other. The weight sensor mostly worked, the issue is that I was getting very inconsistent issue, the same amount of food would give me a different weight. I think the issue was due to the string not sliding perfectly in the channel and the friction between the food and the wall of the chambers. The weight sensor worked correctly outside of the machine so it was down to mechanical issues.

I tried different strings but I couldn't manage to get good results. Then I realized that design was quite tall and wouldn't fit very well inside the structure. It was time for a new prototype!

The Second Prototype

After reviewing how others have achieved this task, and trying to inspire myself from what I've learned in solving the auger's constant jamming issues, I went for a design with a wheel on a vertical axis, with long paddles that divide the body into chambers, an access to fill those chamber from the top on one side and a hole to dispense from the bottom on the opposite side.

And it worked very well! No jamming no nothin'! It helped that I used one of those classic 5V DC motor with a little gearbox, like those you can find in toys, they have much more torque than the stepper I tried to use previously.

To keep track of the position of the wheel I used an infrared optical encoder, it simply gives you a signal depending on if something is between two black leg or not. I printed an encoder wheel that attached to the motor and voila! At the beginning I had issues with the inconsistent signals from the encoder, I tried to make the "teeth" of the wheel wider and wider until I realized it was simply too transparent, after giving it a couple coats of black sharpie it worked perfectly.

To save space I replaced the previous top part with a big funnel, printed in two part so it can fit on my printer. I printed a second part that goes on the bottom that holds the motor and the encoder, it also has two holes, one for a 5v laser and one for a photoresitor. The idea is that when the food falls through the chute it'll break the laser line and the microcontroller can monitor the photoreistor's value to detect if food was actually dispensed or not.

The first tunnel I designed were absolutely terrible, round angled shapes are not easy to interface with in CAD, they took a lot of operations to get right, Fusion360 wasn't very happy with me by the end of it. The angle was too shallow, food wouldn't slide nicely and would even get stuck at the "fork" between the two sides.

The second one was much better, the rectangle tunnels were very easy to work with and in the end turned out to be more optimal. I managed to get a steeper angle by rotating the whole mechanism 180 so that the output is already falling on the side where the food needs to exit and by optimizing the funnel and other parts to gain some height to work with.

The Disruption

At this point I had every parts working together pretty well, including the electronics but I'll touch on that further down. But I had been working on this project on and off for quite some time, so much time in fact that the requirements changed. That's right, because of life circumstances we had to take in a family member's cat. The problem is, this machine was designed for two cats, not three…

No time to despair, we can do it, there must be a way to make it work for three cats. I figured I could just add another tunnel in the middle, and go back to a rotating "selector" to fill them one by one. I decided to with the an active method to split the food instead of a passive one because even with just two tunnels it had a tendency to fill one more than the other, because the dispenser rotates so the food doesn't fall equally on both sides. I didn't feel like printing a thousand prototypes to figure out exactly the geometry required to have a fair three-way split.

And who would have thought, it was actually not too hard to modify the design. It was just a matter of "extending" one of the tunnels past the split and cut it to create the "selector" and adding a third tunnel that matches with the position of said selector when it's rotated midway.

Then it's just a matter of attaching the tunnels to the rest of the machine, with the brace showed here in red. One of the reason the whole CAD file looks like Frankenstein's monster is because I designed the part one at a time, not always knowing what the next part would look like, so the later parts sometimes need to get a bit creative to fit with the previous ones without having to reprint everything.

The Electronics

With the hardware all taken care of let's take a look at how everything gets controlled. I have an Arduino Nano (or a clone of it anyways) to control the dispensing motor, the servo and read the sensors. To control the motor it uses a double-H bridge. There's a couple of resistance to read the photresistors. This board doesn't have much more on it, just bunch of connectors and a USB cable to connect to the ESP32. As always, I just mount everything on some perfboard and add wires until everything is connected as it should.

The ESP32 board isn't much more complex, it's just some headers for the chip, another USB connector and a JST header for programming the chip.
The JST connector was quite an improvement, before that every time I wanted to reprogram the ESP I had to press the BOOT button then press the reset button. It's not too annoying if you only have to do it once but when you to do it repeatedly and the board is in an inconvenient location it gets tiring real quick. Luckily I accidentally burned the programmer board that came with the ESP, I had to get a generic programmer and it was a perfect occasion to setup a good workflow where it automatically resets the board into programming mode when uploading code.

The Coding

On the Arduino side the code is pretty simple, it waits for commands on the serial port, execute them and outputs a response. For dispensing it rotates the motor and reads the encoder with a bunch of timers and debouncing to make sure it actually rotated correctly. There's a pin change interrupt to read the chute laser sensor. The three failure modes are if the motor gets stuck, if the laser fence is not triggered or if the laser path is broken before it starts rotating the motor, as that would mean food is stuck in the chute. After dispensing it outputs the results, either the error code or success, back to the serial.

There's a lot more business happening on the ESP32. Here's a little list of the things it handles.

Monitoring the time and triggering dispensing events
Communication with the Arduino
Serving the Interface's webserver
Handling communication on the WebSockets
Streaming the camera
Sending a Discord and Pushover notification after dispensing

The websocket's server is registered under a path that contains a password so you can't only see the camera that's streamed over WS or change the settings if you have the password. eg: ws://website.com/ws/PASSWORD_HERE

For Discord notification I use the webhook feature, super simple and easy. I also added Pushover notifications, which is an app you install on your phone and it gives you push notifications, the advantage is that the push notification could include an image at the time, it doesn't seem to work anymore so that part is a bit useless for me.

When the ESP32 boots up it tries to connect to the last wifi config. If it hasn't managed to connect after 30 seconds, it starts its own wifi access point, from which you can access the Interface and make it connect to one of the available wifis.

The Interface

The Interface is a website in HTML, JS and SCSS. It gets built into minimized files using webpack, the hot-reload feature is also useful for development. There's one box for the last camera capture, one for the live camera stream, an area to set the actual dispensing settings, time and amount. There's also a button to get a list of available wifis and connect to one of them. The console logs all the commands that gets sent and received on the websocket and let you manually send commands. The field above the console is for putting the access password, without it nothing is accessible except the camera capture box. It uses JS localStorage to save the password so you don't need to enter it every time. I also made sure the website is responsive on mobile, as that's probably how I'll access it most of the time.

At this point there's basically three different programs that need to talk to each others, the Arduino, the ESP32 and the Interface. To help them understand each other I listed the shared constants and enums in a JSON file and made a JS script that I can execute using NodeJs (which I'm already using to build the Interface). The script generates a C++ header files with all the constants populates as well as a new JSON file with the new values. It then copies those files to each project's folder. Now each project can include either the header (for Arduino and ESP) or the JSON (for the Interface) so that they always use the same values for commands and share the same constants!

{
  "commands":
  {
    "ESP":
    [
      "Capture",
      "Dispense",
      "SetDispensingSetting",
      "SaveDispensingSettings",
      "WifiList",
      "WifiStatus",
      "WifiConnect",
      "Temperature"
    ],
    "ARD":
    [
      "Dispense",
      "Reservoir"
    ]
  },

  "enums":
  {
    "DispensingResult":
    [
      "Started",
      "Ok",
      "NoOutput",
      "PaddleStuck",
      "FoodJammed"
    ]
  },

  "constants":
  {
    "DispensingEventMax": 4,
    "PositionCount": 3
  }
}

The Heating

So everything is finally working, everything is perfect, now you just make a little cover for the ESP32 to protect it and hold the camera in place, what could go wrong?

Somehow putting the cover on massively decrease performance, until the chip disconnect from wifi and is unreachable. Uh what's going on now…

Turns out the chip was overheating and it only started happening after I trapped it inside a thick-walled enclosure. I tried drilling a bunch of holes in the box but that didn't help. I then spent a considerable amount of time trying different power settings in the hope of reducing the heat dissipated but nothing help. I finally reluctantly resigned myself to putting a fan inside the case, I already had a fan of the right size but I wasn't too happy because I knew it would end up noisy. Still, I was out of options so I printed the new case with a spot for the fan and some holes for the exhaust. And… it worked! The chip was cooler than ever! Yet I was not satisfied, as predicted the fan made noise, and so I pushed a little bit farther, that's when it hit me! The problem was the camera! After measuring the current draw when I don't initialize the camera module at all I realized it was pulling more than have the total current for that board. After playing with the settings I managed to find how to turn it off when not in use. No more overheating even without the fan, yay!

The Wifi

So everything is finally working, everything is perfect, now you just have to close up the machine and put it in its final place, what could go wrong?

It seems like everything is working but the web interface is extremely slow and most of the time it can't connect at all. Uh what's going on now… Bring the machine back down the stairs, disassemble, debug, find the problem, all over again. This project sure is starting to take a long time, started it what.. hmm.. let me count, 2 years ago?? Alright time to wrap this thing up.

For some reason it seems the ESP's wifi connection is really weak, even when really close to the router. What makes it even stranger is that the connetion is bad even with an external camera. Trying with a different ESP32-CAM module gave the same result. Then I realized that the wifi performance was much better when it wasn't on the machine's perfboard. Which is strange since there's almost nothing on that board. After trying all kind of things including dubious methods of shielding, I finally realized that the issue was the UART RX pin coming from the Arduino's TX. That pin was giving 5V, I never had issue with directly connecting 5V to the esp32 even though it's supposed to be used with 3.3V but I guess it was messing with RF for the wifi one way or another. That took me a long time to find, but in the end a simple voltage divider solved the problem.

The Finishing Touches

The tunnel was drooping lower than it should have been, and that was a problem as they were designed to end just above the low profile stainless bowls I got especially for this project. I should have expected that with all the different 3D printed parts, the flex adds up. After probing a pushing from different places I established that holding it from the back would be the most ideal solution. I quickly designed a little piston, a 3D printed tube with a heat-set insert at the end, a long screw and a cap for that screw that also has a heat-set insert. heat-set insert are awesome and I always forget they are a great option.

Next was covers to put around the tunnels where they come out of the wall. There was no way I was going to cut nice holes of the perfect shape and dimension in the middle of the wood board so I intentionally oversized them and printed covers to hide it.

The last thing was realizing my cats are very aggressive eater and like to push bowls around when they eat. At firs I thought of putting magnets under them but the bowls are barely magnetic so I would have to glue one set of magnets to the bowls and one to the floor of the machine, a bit cumbersome. Plus magnets near food is stressful since they can be quite a hazard when ingested. I was thinking about crazy solutions like gluing a nut to the bowl and screwing from the bottom when I remember I hold the holy power of 3d printing and can simply print little holders:

The Result

After many a trouble and literally years of efforts, I finally made it, the automatic cat feeder machine! It works perfectly, the cats now leave me alone in the morning and it does everything as it was supposed to. In retrospect, I could have made it smaller, especially since we don't even have the cat litter furniture that was supposed to be its companion. I'm very happy with the result, and also very happy it's done!

Here's come pictures of the inside

And of the outside

I had a lot of fun with this project, this is exactly the kind of stuff I enjoy making, as always I learned a lot and that's at least half the pleasure. I made this blog post as a way of reflecting on the adventure and sharing the fun. I'm not sure if there's much to gain for other people here but if you're still reading I imagine you got something out of it! Thank you for reading and see you on the next one!

3D Printed RTX 3080 Keycap with working fan

Sun, 13 Jun 2021 02:21:23 -0400

The Printer

I recently purchased a used Artillery Sidewinder X1 on Amazon which sadly arrived broken. It kept producing "slanted" prints like this:

Fortunately Artillery had a great customer service, they helped me try different things to resolve the issue and when none of them worked sent me a replacement motherboard for the printer. Once I swapped the old motherboard for the new one it worked perfectly. I'm very happy with this printer and I definitely recommend it!

To control the printer I installed Ocotprint on a used Raspberry Pi I found on Marketplace. Using balena to manage the RPI made it super easy to monitor and update the images, I was able to add a pi-hole instance running on the side to block ADs on the network. Of course I printed a case for the RPI using the printer. In addition, I installed a relay inside the X1 directly in series with the On/Off switch and connected it to the RPI's GPIO pins so that I can turn the printer On/Off from the Octoprint interface.

The Design

When you get a 3D printer you start looking for anything to print, it's very exciting to see things appear before your eyes, it gives you a whole new creative power. I wondered if there was any keycap model to print, I found some, customized them a little to see what could be done. Here's a simple Escape key, I added 4 little holes so you could still see the rgb light of the key.

Then I wanted to make one that would be more interesting, I asked my friends for inspiration and one of them sent me an image of a keycap in the shape of an RTX 3080, some even had a little fan that you could turn using your finger or by gently blowing on it. This gave me an idea, why not make one with an actual working fan?

The Modeling

It was my first real CAD project, I had done a couple of simple shapes in Fusion 360 before but this was far more complex. It was quite an iterative process, in retrospect I could have tried to make it more complete before trying to print it each time. At least it was quite a small print so it didn't take too long to print and didn't was too much material. It took a couple of tries to get the keycap to properly fit on my keyboard and hold in place but once I found the perfect measures it felt like just any other key.

I originally planned to spray paint it black and highlight the edges with a silver sharpie but after multiple unsatisfying attempts I abandoned that idea. One of the things that made it quite hard was that I wanted the letters to stay in the color of the PLA filament, I thought it would be easy to just plug them with some play dough and over it, then simply remove the play dough but it turned out much harder. The play dough wasn't really sticking to the plastic so it was really hard to get it to stay inside the indentation of the letters. Even when I managed to fill all the letters, after painting it and spending way too long removing the play dough, the result wasn't uniform enough. Maybe I'll revisit this idea, maybe if I find something else to plug the indentations, let me know if you have any suggestions!

It actually took at least twice as many as that.

The Fan

The fan was surprisingly easy to model and print even though it's quite small. It's hard to remember how small some details are when you do CAD, I spent some time adding bevels and get the shape right just to realize afterwards that they won't really make any difference at this size.

To turn the fan I needed a really small motor. I used a little 3V vibration module which I had bought to add haptic feedback to a different project. After removing the case of the module you can see a little rotor with two coils and a weight. Carefully removing the weight leaves you with a mostly balanced rotor that won't vibrate.

Under the rotor is a ring magnet and two tiny brushes used to send the current to the rotor's coils. After gluing the fan to the rotor I had to very carefully adjust the position of those brushes so that the correct tension to hold the fan assembly up but not so far that it would jump out or have the brushes not make contact with the contacts. This actually took some time to get working properly. Another thing that took some time is that when removing the case of the vibration module it's extremely easy to disconnect the wires and I couldn't manage to solder them back in place. I actually ended up destroying many modules before finding the perfect technique.

The Assembly

Only things left was to fit a battery and a switch. My first instinct was to go to the pharmacie, where I knew they had multiple models of tiny batteries. Those turned too expensive for what they are and I just bought the more common LR44 button cell battery. It's slightly larger size than I had anticipated meant that I could only fit a single cell, giving me only 1.5V instead of the 3V the motor is supposed to run on. This didn't cause any issue as the motor still turned and I just went with it.

For the switch I found one in my miscellaneous parts box that just happened to fit perfectly. It wasn't too big, gave barely any resistance when pressed and was just long enough that you don't have to press the key much before it starts making contact.

For the wiring I simply connected everything in series so the motor would turn when the switch is pressed.

The Result

The result is a nice golden keycap that fits very nicely and has a fan that turns when you press on the key. Even I was surprised when I got it complete, the whole project sounded a bit crazy when I first started.

DIY Smart Door-Lock

Sun, 13 Jun 2021 02:21:23 -0400

The Repetition

There are things you do every day, they don't always take long, but they always make me dream of a way to automate them. A task I found of no value and wished to automate is the action of locking and unlocking my front door. The whole process of getting my keys out, selecting the right one, inserting it correctly into the keyhole and turning is incredibly gratifying. I began to dream of a system that would do it all for me, without any involvement on my part. Of course this might take more time to make then it would save me but that's without counting the fun I would have in building it and the immense satisfaction I would get each time I passed my door.

xkcd 1205

The Perfect Lock

My idea was to make a lock that would automatically unlock the door as I arrive home and lock it when I leave. I started looking for a way to detect when I come close and away from home. Immediately I decided to disregard geolocalisation because I wanted something more reliable and didn't want to require having any program running on my phone. I then looked into Bluetooth, but it wasn't clear if there would be an easy and reliable way to detect my phone from an Arduino through Bluetooth. Finally, I realized my phone connects to my Wi-Fi when I get close to home and if I assign it a static IP I could simply ping it continuously to see if it was connected to the network. It might not be the cleanest solution but it was easy to get working and so I went with it.

I'm still amazed at the price and availability of microcontroller these days. I can get a couple of Arduino Nano and ESP8266 for a few bucks. I already had some Nanos lying around for exactly this kind of project and had recently purchased ESP8266 and NodeMCU boards as I never had the chance to mess with Wi-Fi in my electronics project so far.

Here's the Nano and ESP I used on a prototype board and a little 5v to 3v converter to power the ESP.

The Hardware

One of the requirement of my design was to not modify the current lock mechanism. My rent contract explicitly stated that I was forbidden from changing the key and I wanted something that would be simple to remove when the time comes. It was also important that you can still open the lock with the key for any of those occasions:

landlords should still be able to access
as any maintenance personnel like a plumber
if I give a key to a friend
in the inevitable case of my system crashing
for the unfortunate situation of a power outage

This means that I could not couple a motor directly to the lock, as the resistance of the motor would prevent you from easily turning the key. My door fashions a deadbolt lock similar to this:

After some time of thinking passively about it I figured out that this shape would allow the handle of the deadbolt to rotate 90 degrees from the action of the key while also allowing for the shape to rotate the lock by applying a 180 degrees rotation.

I made the circular piece was made out of layers of foam board panels with the middle cut in that hourglass shape. To rotate it I used a motor already integrated with a gearbox, that made it slower but gave it more torque, I extracted from a toy years ago. Since this is just a simple DC motor there wasn't a way to know the current angle of the motor. To be able to rotate it accurately I placed a little tab on the circular piece and three sensors around it, one at locking position, one at unlocking position and finally one in the center relaxed position to allow the handle to move freely without having any force from the motor on it.

For the sensors I used some LM393 wheel speed sensor I had lying around. The sensor is composed of two little arms and sends a signal when there's something between them. And here's the thing with the motor and all the sensors mounted in all its glory. In retrospect I really should have trimmed all the wires a bit more.

I also added two buttons on the top to lock/unlock and an on/off switch.

The Software

Controlling the motors and reading the states of the sensors was quite easy, it wasn't my first Arduino project and I got it out of the way very quickly. Now I had to get the Nano and the ESP8266 talking together. The ESP works on 3.3v, and I used a little 5v to 3v convert to power it. I also needed something so they could talk together and I tried to use a level shifter IC which is supposed to enable a 5v chip to communicate with a 3.3v chip without damaging them by shifting the voltage level on each side but I couldn't get it to work so in the end I used the cheap and dirty solution of a voltage divider using two resistors on the Arduino to ESP line and just connected the ESP to Arduino line as-is since the Arduino had no issue reading a signal at 3.3v.

Once I had that working it was just a matter of reading the documentation, I used a direct serial communication so I learned about AT commands and how they work. It was really exciting when I got it working and I saw it lock when I turned off the Wi-Fi on my phone and unlock when I turned the Wi-Fi back on. Sometimes the ping would fail even if my phone was connected. That was easy to fix by adding a counter of "failed" ping and only locking after 3 fail in a row. Next I wanted to be able to control it from a webpage, I opened a port on the ESP to receive TCP connection and forward that port in my router. I didn't need to do proper HTTP request parsing, just the bare minimum to extract the information I needed, which is essentially just the password which was passed in the URL making it's location was very standard and easy to extract. The webpage was extremely minimal, just a textbox with two buttons under it to lock or unlock. Even if I wanted I couldn't make the page very complex as the text quickly takes place on this already quite limited hardware and it also means it takes more time to send it from the Arduino to the ESP.

The Voice Activation

Now that I had a way to lock/unlock using a web request it means that I could connect it to any services that uses a webhook. A very nice website to connect services and devices of all sort together is IFTTT (If This Then That). You give it an event to trigger on (If this) and an action to perform (Then That) and it will perform the action when it receives the event. There's all kind of events like, when you receive an email with optional filters, when you enter a certain location, on a Facebook post, by a Google calendar event. There's a ton of services adding their own piece to the website so that you can connect them to other things. The event I used was Google Assistant when I say "Ok Google, open front door" or "Hey Google, unlock the door" and the likes. My action was a simple webhook, sending a request with the correct password to my device. In a couple of minutes I got it working so that I could lock/unlock my door using Google Assistant, pretty cool.

The Finishing Off

After finishing the software and the hardware and had glued the remaining panels I was finally able to enjoy the fruit of my hard labour, after adjusting a couple of things… For the power I used two thin and long white cables, matching the color of the door and making sure they wouldn't show too much. Turns out when my phone's screen is turned off it takes a long time to respond to pings, sometimes too long, and it would lead to the system thinking I left and locking the door. It was extremely creepy and startled me each time. I already had added an on/off switch which only toggled the pinging and didn't disable the web server. I simply made it so that when I turn it off it would lock the door, since it would mean that I arrive home and when I turn it on it would unlock as I am probably leaving. This way it would be off most of the time I am home and it wouldn't randomly decide to trigger the mechanism.

Here's a picture of the final product, a bit clunky but I love it. I'm very happy I thought of leaving a little hole so I could upload a new program to the Arduino as it would have been much more painful to do this upgrade without it. Also note that I later added some black electrical tape on the edges which gave it a much better appearance.

The Security

It might seem like adding a clumsy, self-made lock system connected to the internet could be a huge security issues but I don't believe this has significantly increased the chance of someone gaining unauthorized access to my apartment. First of all this is a unique device, no one has access to its program which already makes it harder to create an exploit for it. I'm pretty confident that I sanitized all the inputs and all the buffers in the code are static. Brute forcing it would be difficult because it's quite slow, it can take a couple of seconds to try even a single combination. The password could be anything, since there's about 95 printable ASCII character and an URL can be about 2000 characters, let's say minus 100 for the address of and the path, that leaves 95^1900 combination. But my main point is that my door isn't very secure to start with, the truth is that most residential door lock aren't any good and I can lockpick it open without too much trouble even though I barely have any experience. So if someone wanted to gain access to my apartment it would be easier to just lockpick the door (or straight away break it down or break a window) than to hack into my system.

PS: Now that I think about all the connections are over HTTP so assuming that someone is able to sniff those packets, they could probably retrieve the password, oh well.

Rubber Duckies and practical trolling

Sat, 29 May 2021 18:21:23 -0400

The Troll

Leaving your computer unlocked when you leave to get some coffee is a risk. It's a security risk as someone could just walk up and exploit the free admin access to your computer, from which point they could do any number of things like install a backdoor or copy important files. But most importantly, it's a very powerful troll magnet. There's no better prank than changing someone's background while they are not looking.

Rubber ducky

A rubber ducky is a tiny little Arduino-like board that features an Attiny85 chip and a little protrusion on the PCB which just the right shape and lines to be inserted in a USB port.

I soldered headers on those for some reason but they usually come without those which gives them a really tight footprint.

The idea behind those devices is that they can simulate a keyboard, with the ability to send thousands of characters per seconds. Now if you had some nefarious intentions and you managed to either plug this device in an unlocked computer or trick someone in doing so themselves you could easily make it install a virus or extract information. If you are slightly less evil you might also realize that it is the perfect trolling tool.

It also works as a normal Attiny85 so you can control a led or read some switch for example. I toyed with this a little to make one where you could switch which script it would execute. (There used to be two additional switches on this but at some point I stole them for another project)

They also come in other form factor, with better chips or a micro sd card reader, etc.

The plan

Those devices are great but are quite limited, if you want to type a lot of text the storage quickly becomes a problem. Luckily people are smart and have thought about ways to circumvent the issue. If the target computer has access to internet you can:

Open the Windows start menu ("Windows Key")
Open an administrator Powershell (Type "powershell" then press Ctrl+Shift+Enter to launch as admin)
Say yes to the admin prompt ("Left Arrow" to select the yes button then "Enter" to confirm)
Use a powershell command that will download a script and run it immediately

This way you have no limit on the size of the script. I used a combination of GitHub's gists and TinyUrl to both keep the URL short and be able to modify the script as I develop it.

The Rootkit

At this point I had a couple of fun powershell scripts working but it was clear that powershell windows floating around had nothing stealthy about them. It's possible to launch a powershell script with no window but I knew the first thing any competent person would do is to open the Task Manager where they would immediately spot the quite suspicious powershell processes, I needed a better way.

Thing is, Windows is designed in such a way so that no process can "hide" itself. In other word, a program able to hide itself is essentially a virus (Unless you're Sony and you think you're the most important thing on earth). A rootkit is a software, or group of software, designed to maintain access to a system and to conceal itself. After reading a bit on the subject I decided to go the quick and dirty way; injecting a DLL into every running process on the machine.

DLL injection is a method by which you make a program load a piece of code and then execute it in the program itself. On your code is running in the program it can alter its memroy and even its code. For example, ZwQueryDirectoryFileReal is a function to list the files in a directory. Pretty much all calls a program makes to query the files in a directory go through this function as it's a system function and the way to go to interface with the OS. This function gets loaded in memory somewhere, we can get the address of the function, make that part of memory temporarily writable then put our own code there. This code could do anything but the most useful thing to do in our case is to look at the queried path, if it points to something we want to hide, we return the same thing the original function would return if the path didn't exist. If we don't care about this path then we just call the original function and forward it's return value. Same applies for the function responsible for listing processes. Now we just have to inject that code into all the running programs and monitor new ones so we can inject it into them too.

The code "injector" I made for this is called Vaccinator and the DLL it injects is Kernel64

The pranking

I want to make it very clear that I wouldn't do this on just anyone, nor should you. The person I did this to was sitting right next to me, we joked a lot about locking your computer when you get up, which he always forgot to do, and he was actually well aware of what I was working on.

That said, here's what the final scripts were doing:

Periodically change his wallpaper (Of course)
Trigger Text-To-Speech randomly ("I will lock my computer", "Computer compromised", "All systems hacked", "Never Forget, Never Forgive, Expect Us", "Once upon a time, I forgot to lock his computer", "Trollollollollollollollollolloll")
Periodically open/close CD tray
And most importantly, hide all the relevant processes and files

It was easy to deploy, just wait for him to get up, leaving his computer unlocked, stick the little thing in a USB port(our keyboards had very accessible ports on the back), screen briefly flashes a console and voila!

The Defusing

I was so sure, so certain, my code was so perfect. He would have to capitulate, there was no way he could defeat my beautiful system.

Turns out by opening a powershell window through the start menu it left it in the history. He didn't fail to notice that and upon opening a shell he just had to press the up arrow to see the history of commands where he found the address of my script. That script contained links to other scripts and to the GitHub repository of Vaccinator where it was pretty easy to spot the code I had left to deactivate all the hiding functions when a file with a specific name was place at the root of the C drive.

If I had just cleared the powershell command history he probably wouldn't have found a way to deactive my scripts. They could have been more aggressive anyways but this was just for fun. Turned out pretty funnny in the end.

Persistence-Of-Vision Display

Sat, 29 May 2021 18:21:23 -0400

The Itch

Sometimes you get the urge to try something, an idea come to you or you see something and you just know you have to make it. Me and my friends call this "the itch". Sometimes it would be a huge endeavour, which you would probably never finish, so to avoid adding to the huge pile of unfinished project you already have, you have to resist it. But sometimes the scope is approachable, that's when it gets really dangerous, that's when the itch is irrepressible.

POV Display

I saw a video about a POV Display and it reminded me of their existence. That was enough, I had to make one, today. They work quite simply, you have some spinning leds and if you light when they are at the same angle on each turn they will appear like there's a constance source of light there. Blink them at the right place and time, you got a circular screen on which you can write or draw things.

Construction

For this kind of "on the spot" projects I have to do with what is laying around, I already had a couple of motors, AC adaptor, Arduino Nano, leds, pretty much everything needed. It took me a couple of trial and error to find the right combination of motor and power supply, in the end I used a DC 12V motor, which came from something I dismantled but I can't remember what it was, and an old computer's PSU which double as a base for the contraption. Even with this big heavy base it still vibrates a lot and wobbles around so I ned to hold it a bit with one hand Which is a bit scary since the upper part is made of a 4XAA battery holder on one side and a mix of popsicle sticks and pointy prototype board on the other giving a radius of about 20 centimeters, the whole thing turning quite fast.

I wanted to maximize the ability of my Arduino nano so I went with a resolution of 10 pixel in "height" and 2 colors. I think I chose white and blue for my colors because those leds worked fine with the 5V and didn't need any resistor. Took me quite some time to finish the led board because the leds kept dying, until I realised I was accidentally shorting them when testing.

Testing and Adjusting

Getting the code to work wasn't too hard but once I got the speed aproximatively tuned to the speed of the motor it became apparent that the design was flawed. The lines were very moving around and it was impossible to keep it exactly sync as the motor's speed isn't exacly constant. I knew other who have made this used some kind of sensor to detect the RPM so I looked for something that could work and found some LM393 wheel speed sensor. The sensor is composed of two little arms and sends a signal when there's something between them. I just had to mount the sensor on the rotating part of the display and a little piece of popsicle stick on the static part so that it pass in the sensor on each rotation then measure the time it took between two rotation to know the speed at which it was rotating. As soon as I got the speed sensor working I was amazed, the display was precise and clear, much better than I had imagined it would work.

Result

The result is a big deadly circle of light title "CIRCULUS LUMINIS" (Google assures me it means "circle of light" in Latin). It has a nice radius, I'm pretty happy with the result. As always those kind of things are hard to capture properly on camera, between brightness and rolling shutter effects it makes it look much worse on camera than it does in real life. It works well with the lights on but the picture were better in the dark. Also I took some videos but as I said the effect made them quite unattractive. When asking my friends what I should display for the showcase they came up with the very mature "send nude" so here it is, in two colors.

Going further

I had started on animations for the display using a pixel art animation editor and a little script(that my friend generously made for me) to convert the images into binary on/off arrays but I was stretching the limit of the storage available and processing power on my Arduino Nano so it was hard to put more frames but I'm sure I could manage some simple compression which doesn't take too much time. Maybe one day I'll get back to it.

Compile-time templated A* pathfinding in C++14

Mon, 17 Jul 2017 18:21:23 -0400

What is this?

In simple terms, a complete mess. More concretely, it's a piece of code that I wrote which computes a path using the A* algorithm and works entirely at compile-time, that is, all computations are done by the compiler and nothing is done at runtime. So at the end, the executable only contains the result, in this case, the path.

Inspiration

I asked my good friend Nyrox on the #sfml IRC channel for a compile-time challenge to my measure.
He finally suggested doing A* pathfinding and I gladly took the challenge.

Tools

To help me in my task I used the superb Compiler Explorer. It lets you choose between a vast selection of compilers and versions and continuously tries to compile your program as you type it. When your program compiles, it shows the resulting assembly on the right, it's really practical when doing. At the end I also used Regex101 to quickly filter part of the compiler output. Finally, I used C++ Shell which lets you execute C++ code online.

Code

Let's dive right in! For those who just want to see the code, here's the link.

Starting simple, Vec class

template<int X, int Y>
struct Vec
{
    static constexpr int x = X;
    static constexpr int y = Y;
};

There we go, a simple templated class, I use it to store a position on the map. For example Vec<4, 5> v; would create an instance, but in this project I almost only work with type, so I would more likely write using V = Vec<4, 5>; which is a type alias declaration. I can then access the value like this V::x.

I want to do pathfinding in a 2D map and I will store this map as a 1D array, so I need a way to map 2D coordinates, which I'll call Vec now, to a 1D coordinate, which I'll call Index.

template<int X, int Y>
struct Vec
{
    static constexpr int x = X;
    static constexpr int y = Y;
    
    template<int sizeX>
    static constexpr int Index = Y * sizeX + X;
}

I basically declare a templated variable that is static, so that it is not part of an instance but of the class itself, and constexpr, so that it can be used in a constant expression and thus at compile-time. If any of those terms are unknown to you, I suggest researching and experimenting with them as it is the best way to learn. Also this is not a tutorial about template haxery but merely an overview of my experiment.

Assuming that the horizontal size of my map is 10, I'd use it like this int Index = V::Index<10>;.

Of course we also need to do the opposite operation, going from Index to Vec:

template<int sizeX, int Index>
using FromIndex = Vec<Index % sizeX, Index / sizeX>;

And using it is as easy as using V = FromIndex<10, _IndexHere_>;

It will also be handy further down the road to get the neighbors of this Vec:

template<int X, int Y>
struct Vec
{
    static constexpr int x = X;
    static constexpr int y = Y;
    
    template<int sizeX>
    static constexpr int Index = Y * sizeX + X;
    
    using Up =    Vec<X, Y - 1>;
    using Down =  Vec<X, Y + 1>;
    using Left =  Vec<X - 1, Y>;
    using Right = Vec<X + 1, Y>;
}

Vector

Now that I have some Vec I need a way to hold them in an array, so I implemented a Vector class. I won't cover every line, it's not trivial but with the "function" name, and some serious dedication, understanding the code should be possible. It is probably not the best way to do those things anyways, I wanted something that worked, coding features as I needed them, once they worked reasonably well and the code was not too terrible, I just moved on.

With that in mind, feel free to inspire yourself from it or suggest improvements.

Note that, as to not make the post too long and boring, I removed most functions of the following code. In the complete code you can find functions such as PopBack, Find, Transform, Get, Remove and so on.

template <typename... T>
struct Vector
{
    template<typename...V>
    using PushFront = Vector<V..., T...>;

    template<typename...V>
    using PushBack = Vector<T..., V...>;

    template<typename V>
    struct Insert
    {
        template<typename>
        struct Impl;
        
        template<typename...Vs>
        struct Impl<Vector<Vs...>>
        {
            using Type = Vector<T..., Vs...>;
        };

        using Type = typename Impl<V>::Type;
    };

    template<typename V>
    using insert = typename Insert<V>::Type;
};

Note on my synthax

You might have noticed I declare my "function" in a strange way, look at the insert function:

    template<typename V>
    struct Insert
    {
        template<typename>
        struct Impl;
        
        template<typename...Vs>
        struct Impl<Vector<Vs...>>
        {
            using Type = Vector<T..., Vs...>;
        };

        using Type = typename Impl<V>::Type;
    };

I just feel like it's less of a mess when I write it this way, it feels more "contained", it's simply a personal preference, I could also write it in a more "normal" way:

    template<typename V>
    struct Insert;
    
    template<typename...Vs>
    struct Insert<Vector<Vs...>>
    {
        using Type = Vector<T..., Vs...>;
    };

It is way less typing in this case, and I would guess it compiles faster, I didn't do any benchmark in this regard yet.
Let me know what you think of it!

I also define aliases in lower case that are easier to call so rather than doing MyVec::Insert<MyOtherVec>::Type I can do MyVec::insert<MyOtherVec>.

    template<typename V>
    using insert = typename Insert<V>::Type;

Bad, bad Vector

In itself, this class works well, you can do fun stuff at compile time, hold any kind of type and insert, remove, find them, etc. But there is a problem, it only holds Types, so no int or any kind of value. And I want my final map to be made of chars, how to solve it?

The solution is simple, make a type that has the sole purpose of holding a value:

template<typename T, T Value>
struct ValueHolder
{
    using Type = T;
    static constexpr T value = Value;
};

Now I can hold a value, a 5 as an int for example ValueHolder<int, 5>. But it's still extremely annoying to always have to care about the ValueHolder and such. So I made an overload for values, this way I can push, remove, and find value using the exact same syntax as I would with types.

Again, I removed most functions, this time I left Find.

template <bool ForceGeneric, typename... T>
struct VectorImpl;

template<typename...T>
struct Vector : public VectorImpl<false, T...>
{
    static constexpr int Size = sizeof...(T);
};

template <bool ForceGeneric, typename... T>
struct VectorImpl
{
    template<typename V, template<typename, typename> class Condition = std::is_same>
    struct Find
    {
        template <int CurrentIndex, typename Current, typename...I>
        struct Impl
        {
            static constexpr int Index = Condition<Current, V>::value ? CurrentIndex : Impl<CurrentIndex + 1, I...>::Index;
        };

        template <typename Current, typename...I>
        struct Impl<Vector<T...>::Size, Current, I...>
        {
            static constexpr int Index = -1;
        };

        static constexpr int Index = Impl<0, T..., IgnoreT>::Index;
    };

    template<typename V, template<typename, typename> class Condition = std::is_same>
    static constexpr int find = Find<V, Condition>::Index;
};

template <typename T, T...V>
struct VectorImpl<false, ValueHolder<T, V>...> : public VectorImpl<true, ValueHolder<T, V>...>
{
    template<T Value, template<typename, typename> class Condition = std::is_same>
    struct Find
    {
        template<typename Left, typename Right>
        struct ConditionWrapper;

        template<T Left, T Right>
        struct ConditionWrapper<ValueHolder<T, Left>, ValueHolder<T, Right>>
        {
            static constexpr bool value = Left == Right;
        };

        static constexpr int Index = vecImpl::template Find<ValueHolder<T, Value>, ConditionWrapper>::Index;
    };

    template<T Value, template<typename, typename> class Condition = std::is_same>
    static constexpr int find = Find<Value, Condition>::Index;
};

Map

The map itself is just inheriting from vector and simply adds a function to get a value from a coordinate and holds the horizontal size

template<int SizeX, typename...T>
struct Map : public Vector<T...>
{
    using GetVector = Vector<T...>;
    static constexpr int sizeX = SizeX;

    template<typename VecT>
    struct GetFromPos
    {
        static constexpr auto Value = GetVector::template Get <VecT::template Index<SizeX> >::Value;
    };

    template<typename VecT>
    static constexpr auto getFromPos = GetFromPos<VecT>::Value;
};

Node

A* is implemented using nodes, which hold a pointer to its parent, the cost of its path so far, its heuristic cost and its position.

template<int index, int G, int H, typename ParentType = void>
struct Node
{
    static constexpr int Index = index;

    static constexpr int g = G;
    static constexpr int h = H;
    static constexpr int Cost = G*G + H;

    using Parent = ParentType;
};

You might wonder why G is squared, it's because my heuristic function takes two Vec and returns the distance between them squared. Sqrt is a real pain in template since we can't use float at compile-time and it's really easy to just represent every distance as squared distances!

template<typename Vec1, typename Vec2>
struct Heuristic
{
    static constexpr int X3 = Vec2::x - Vec1::x;
    static constexpr int Y3 = Vec2::y - Vec1::y;
    static constexpr int Value = X3 * X3 + Y3 * Y3;
};

Pathfinding

I made an AStar class, in it there's a couple of members which are the start value of the algorithm, so the start and end position, the openlist and closedlist, etc.

Then I have a "function" called BuildNeighbors its role is to gather all the neighbor position of a node in a vector, removing all those are out of the map bounds. Then there is FilterNeighbors which removes the position that point to a wall or if a node with the same cost and position exists in the closedlist or openlist.

MakePath is the final function that takes the final node when the algorithm has reached the end position and unroll all its parents and puts all the position in a vector.

MainLoop is, well, the main loop, it takes the node with the least cost on the openlist, removes it from the list and find its neighbors using BuildNeighbors, filter them using FilterNeighbors and add them to the openlist. It then adds the least node to the closedlist and recurse, unless the least node position is equal to the end position, in which case it stops recursing and returns the result of MakePath.

Debugging

Many times during the development, things refused to work as intended, but I could not use a simple std::cout as I'm used to, because everything was at compile time. So I found a nice trick, you can force an "error" and hope that the compiler will throw you the information that you want. Here for example I want to know the content of a vector.

using MyVector = Vector<Vec<0,0>,Vec<1,1>,Vec<2,2>,Vec<3,3>>;
using Test = MyVector::Test;

Clang, for example, will output this

666 : <source>:666:24: error: 'Test' in 'using MyVector = struct Vector<Vec<0, 0>, Vec<1, 1>, Vec<2, 2>, Vec<3, 3> > {aka struct Vector<Vec<0, 0>, Vec<1, 1>, Vec<2, 2>, Vec<3, 3> >}' does not name a type
 using Test = MyVector::Test;

And GCC will do something close. Another way is to use static_assert, it's just like a classic assert but at compile-time, so it takes a constant expression and if it resolves to true then it's ignored, if it's false however, it will output an error and potentially stop.

So I could do this to verify that the size member of my vector is correct

using MyVector = Vector<Vec<0,0>,Vec<1,1>,Vec<2,2>,Vec<3,3>>;
static_assert(MyVector::Size == 4);

Thus, if I made an error somewhere, I will immediately know. I made a couple of test cases as I was adding various functions. The define is because this is all C++14 conformant and the C++14 static_assert version requires a string as second parameter to output in case of failure, in C++17 it is optional. To make my life easier, I made that macro that just put an empty string there for me.

Here's some part of my tests.

#define static_assert(...) static_assert(__VA_ARGS__, "")

static_assert(map::getFromPos<Vec<6, 0>> == 0);
static_assert(map::getFromPos<Vec<3, 4>> == 1);

static_assert(map::get<0> == 'S');
static_assert(map::getFromPos<Vec<0, 0>> == 'S');
static_assert(map::getFromPos<Vec<2, 3>> == 'E');

static_assert(map::find<'S'> == 0); // Start
static_assert(map::find<'E'> == 3*8 + 2); // End

static_assert(Vec<1, 2>::Index<8> == 17);
static_assert(std::is_same<FromIndex<8, 17>, Vec<1, 2>>::value);
static_assert(FromIndex<8, 17>::Index<8> == 17);

using TestVec1 = VectorFromValue<int, 0, 1, 2, 3, 4, 5>;
using TestVec2 = TestVec1::PushFront<6>;

static_assert(TestVec1::Get<0>::Value == 0);
static_assert(TestVec1::Get<5>::Value == 5);
static_assert(TestVec1::remove<2>::get<3> == 4);

static_assert(TestVec2::Get<0>::Value == 6);
static_assert(TestVec2::PopFront::value == 6);

using TestVector4 = Vector<Test<0>, Test<-1>, Test<1>, Test<8>, Test<-1>>;
using LeastNode = FindLeast<TestVector4>;
static_assert(LeastNode::Index == 1);
static_assert(LeastNode::Type::Cost == -1);

The actual map

Here's my map, 0 is void, 1 is a wall, S is the start and E is the end. Note that I used define because if I typed 'S' it would offset the whole row and I really wanted to use S and not 2 or something.

#define S 'S'
#define E 'E'

    using map = MapFromValue<8, char,
        S, 0, 0, 0, 0, 0, 0, 0,
        1, 1, 1, 1, 1, 1, 1, 0,
        0, 0, 0, 0, 0, 0, 1, 0,
        0, 0, E, 1, 1, 0, 1, 0,
        0, 0, 0, 1, 0, 0, 1, 0,
        0, 0, 0, 1, 0, 0, 1, 0,
        0, 1, 1, 1, 0, 0, 1, 0,
        0, 0, 0, 0, 0, 0, 0, 0
        >; 

#undef S
#undef E

The Final code

The complete and final code is available on github

It's nice and all that but how do you know it actually works?

Excellent question! As I showed earlier, we can force the compiler to output the final path, then I extract that path using a regex .*?(Vec<(\d+), (\d+)>).*? and replace with {$2,$3}, \n so that

668 : <source>:668:21: error: no type named 'Test' in 'Vector<Vec<0, 0>, Vec<1, 0>, Vec<2, 0>, Vec<3, 0>, Vec<4, 0>, Vec<5, 0>, Vec<6, 0>, Vec<7, 0>, Vec<7, 1>, Vec<7, 2>, Vec<7, 3>, Vec<7, 4>, Vec<7, 5>, Vec<7, 6>, Vec<7, 7>, Vec<6, 7>, Vec<5, 7>, Vec<5, 6>, Vec<5, 5>, Vec<5, 4>, Vec<5, 3>, Vec<5, 2>, Vec<4, 2>, Vec<3, 2>, Vec<2, 2>, Vec<2, 3> >'

Becomes

{0,0}, 
{1,0}, 
{2,0}, 
{3,0}, 
{4,0}, 
{5,0}, 
{6,0}, 
{7,0}, 
{7,1}, 
{7,2}, 
{7,3}, 
{7,4}, 
{7,5}, 
{7,6}, 
{7,7}, 
{6,7}, 
{5,7}, 
{5,6}, 
{5,5}, 
{5,4}, 
{5,3}, 
{5,2}, 
{4,2}, 
{3,2}, 
{2,2}, 
{2,3},

Then I simply paste that into a program that I made which print the map with the a # at all the aboves positions.

#include <iostream>
#include <vector>

int main()
{
    //  .*?(Vec<(\d+), (\d+)>).*?
    //  {$2,$3}, \n

    int mapSize = 8;

    std::vector<char> map = {
    0, 0, 0, 0, 0, 0, 0, 0,
    1, 1, 1, 1, 1, 1, 1, 0,
    0, 0, 0, 0, 0, 0, 1, 0,
    0, 0, 0, 1, 1, 0, 1, 0,
    0, 0, 0, 1, 0, 0, 1, 0,
    0, 0, 0, 1, 0, 0, 1, 0,
    0, 1, 1, 1, 0, 0, 1, 0,
    0, 0, 0, 0, 0, 0, 0, 0
    };

    struct Vec
    {
        int x;
        int y;
    };

    std::vector<Vec> path = 
    {
        // INSERT POSITIONS HERE
    };

    for(char& c : map)
    {
        c = (c == 0 ? ' ' : '#');
    }

    for(const Vec& vec : path)
    {
        map[vec.x + vec.y*mapSize] = '*';
    }

    for(size_t x = 0; x < map.size(); x++)
    {
        if(x % mapSize == 0 && x != 0)
            std::cout << '\n';
            
        std::cout << map[x];
    }
}

Final Output

Finally, I run this program using Cpp Shell and it outputs the map and I can see that the path is correct.

********
#######*
  ****#*
  *##*#*
   # *#*
   # *#*
 ### *#*
     ***

Conclusion

This was pretty fun to write, even thought it can't really be used in real world code I still learned a lot of tricks that can be useful during real development. I also find it amazing that I was able to write everything on the web, in my web browser, it was really easy and practically pain free.

Thank you for reading I hope you did enjoy.
As always comments are welcome and appreciated!

A 4-bit Calculator made in cardboard and marble

Sat, 19 Nov 2016 12:37:23 -0500

LOGIC

What is it?

LOGIC is a fully functional 4-bit calculator made entirely out of cardboard, hot glue and marbles. I built it with my little sisters for a science activity, it can add numbers from 0 to 15 for a maximum computable number of 30. We made it from scratch and at the time I didn't see any of the various kind of calculator that have been made using Lego, wood and other, so it's a completely new model!

Why?

Mostly for fun! For some time now I wanted to build an adder but I wasn't sure how I wanted to do it yet. I was thinking of maybe make it using a water system or with only cardboard. Then my sisters had a science activity where they had to present a science project and I was helping them to choose a subject. I randomly found a video about a calculator made with dominoes and I thought, why not make one with marbles?

What was learned?

My little sisters already knew how to count in binary, through the project they also learned about, binary addition, binary/decimal conversion, logic gates, basic logic circuits, and more.

I also learned how simple it can be to build logic circuits using simple material lying around. As in all my projects, I always try do with what I already have.

What does it look like?

Woah, How do you use it?

You place your input numbers as binary in the inputs, a marble is a one, no marble is a zero. The bit on the right is the least significant bit. You have to reset some part of the calculator before each calculation too. Then you remove the little bit of cardboard that kept the marbles from running down and they will slide along the paths, moving and changing the paths as they go, to finally arrive at the outputs at the bottom, giving you the result, as binary again.

Here's an example of input if you wanted to add 7 plus 5.

How does it work?

When we were reflecting on how to make the logic gates we needed, we always started by stating what the gate is doing in common term. The first gate we did was the AND gate.

AND gate

So what do a AND gate does? Basically:

If there is no marble in: no marble out
If there is one marble in: no marble out
If there is two marble in: one marble out

So we needed a system that let one marble pass if there is two else it there is none out.
Here's what we came up with.

One marble: no output

Two marbles: one output

XOR

The XOR was a bit more complicated because the inputs had to be at the exact same time.

So how do we model an XOR? Simple!

If you have one marble than it pass
If you have two marbles then they should cancel out

We imagined that it would be quite simple to have them cancel out. Put a path only large enough for one marble and when they arrive they collide and keep each other falling in the path. The problem is that they have to be in perfect synchronization and even when it's the case they bounce and usually they get out anyways.

We still managed to make one but it was so unreliable that we decided to move on and to just let it be as a prototype as we might not need it at the end.

Half-Adder

AND and XOR gates we would have needed 16 AND gates, 16 XOR gates and 4 OR gates which would have made it just way too big and we didn't have to make all those.

That's where thinking the gates in common terms comes handy, for a Half-Adder it would be:

If there is one marble: make it fall in the first output
If there is two marbles: make one of them fall in the second output

It actually wasn't too hard to make one. The first marble flip a little piece of cardboard, so if there is a second marble it fills fall in a hole. That second marble lands on another flip which block the first one.

For one marble you can see it fall in the 1 path

For two marble you can see it fall in the 2 path

The one begin the sum and the two begin the carry.

Full Adder

A Full-Adder is normally made of two Half-Adder and one OR gate. We were really surprised to see that we could make one by modifying only slightly our Half-Adder. In common term the Full-Adder is the same as a Half-Adder apart that if there is a third marble, then it should fall in the 1 path.

If there is one marble: make it fall in the first output
If there is two marbles: make one of them fall in the second output
If there is three marbles: make one the fall in the first output and another in the second

It was really easy to add the third case to our Half-Adder model, literally only one little piece of cardboard needed to be added. The reason our Full-Adder looks so different is because we edited it to allow for more time between the first and second marble thus lowering the synchronicity requirement.

So for one marble it falls in path 1

For two marble one of them fall in path 2

And finally for three marble one of them fall in path 1 and another in path 2

Putting it all together

Now that we can make Full-Adder we can finish our calculator. We just had to connect them so that the carry out go to the carry in of the next.

The Problem

Even if each Half-Adder and Full-Adder we made were working properly, once all glued together the calculator had problem working. Marbles would go too fast or too slow, they would bounce off and that sorts of things. This is not to say that it can't work, the calculator work but you have to try multiple time before everything go the way it supposed to be. The logic itself is flawless, it's just that cardboard turn out to not always be the most practical and require a lot of adjustment, we just couldn't finish all the adjustment on time.

Done!

We built two more Full-Adder and the rest are just path so that the marbles go to the correct inputs and outputs!

Conclusion

After finishing this project I searched if others had made similar constructions and was amazed by the diversity and the creativity. One thing I noticed was that in most mechanism using balls, you entered the number by setting the flips and you had to have a lot of ball running down, in our model you set the input numbers using directly the marbles position and count. This is closer to how it works in computer and it seems to me that it would be easier to incorporate in bigger project. I'm already thinking of how I could make a minimalist marble computer or a Turing machine.

Thank you for reading I hope you did enjoy.
As always comments are welcome and appreciated!

Facechat - Custom chat api

Tue, 07 Jun 2016 17:05:23 -0400

Facechat

Why?

If you followed my previous post you may know that I tend to go on IRC and that we have there some pretty cool bots. I was swapping between a conversation on IRC and one on Facebook when an idea struck me, how cool would it be to have those bots functionalitys directly in Facebook's chat? And even better, how about reading and writting Facebook's messages in IRC chat or reading and writing IRC's messages on Facebook? Awesome!

Why "Unofficial"?

It should be easy, right? Facebook must have an API for sending and receiving messages, surely they have something like a REST API? Well… No. It turns out that they had an XMPP API that they shot down on April 30, 2014 ¹. They still had a service to read the inbox but they put it down too, exactly one year later on April 30, 2015 ¹. Since there was no official API I had to create my own.

How?

The idea is that if your browser can connect to Faceboos and send messages, then your program can too, as the browser is just another program. When the you go to Facebook's login page you receive an html page and some js scripts, when you enter your identifiant and hit enter the scripts generate data to send to the server to make https request to establish a connection. Now a theoretical way our program could do that would be to simulate the whole browser, html parser, js code interpreter etc. The problem with this thechnique is that it makes a big dependency and it does way more than we need, we only need to send and receive specifique https responses and know how to generate/decode them. To do that we completely forget what our browser is doing and only look at the https request sent to Facebook and the response and we try to guess how they were generated. So rather than trying to execute the js code or understand it, we make our own code, that works in the way we want it. Let me give you an example.

I open my browser (Firefox) and launch a plugin called "Live HTTPS headers" that logs all https requests my browser makes. I open facebook.com and login then I send a message "test".

Here's the https request that my browser made.
As you can see, for a question of privacy I obfuscated the user ids.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
POST /ajax/mercury/send_messages.php?
message_batch[0][action_type]=ma-type:user-generated-message
message_batch[0][thread_id]
message_batch[0][author]=fbid:100000*******67
message_batch[0][author_email]
message_batch[0][timestamp]=1467513329087
message_batch[0][timestamp_absolute]=Aujourd'hui
message_batch[0][timestamp_relative]=22:35
message_batch[0][timestamp_time_passed]=0
message_batch[0][is_unread]=false
message_batch[0][is_forward]=false
message_batch[0][is_filtered_content]=false
message_batch[0][is_filtered_content_bh]=false
message_batch[0][is_filtered_content_account]=false
message_batch[0][is_filtered_content_quasar]=false
message_batch[0][is_filtered_content_invalid_app]=false
message_batch[0][is_spoof_warning]=false
message_batch[0][source]=source:chat:web
message_batch[0][source_tags][0]=source:chat
message_batch[0][body]=test
message_batch[0][has_attachment]=false
message_batch[0][html_body]=false
message_batch[0][specific_to_list][0]=fbid:100003*******64
message_batch[0][specific_to_list][1]=fbid:100000*******67
message_batch[0][ui_push_phase]=V3
message_batch[0][status]=0
message_batch[0][offline_threading_id]=6155197026245292939
message_batch[0][message_id]=6155197026245292939
message_batch[0][ephemeral_ttl_mode]=0
message_batch[0][manual_retry_cnt]=0
message_batch[0][other_user_fbid]=100003*******64
client=mercury
__user=100000*******67
__a=1
__dyn=7AmajEzUGByA5Q9UoGya4A5ER6yUmyUyGiyEyfirWo8popyui9zob4q68K5U4e2O3J1ebkwy8wGFeex3BKuEjKeCwxxRa3CnDBxe6rxCLGqu2PxOcxu5ocE88C9z9oybx24o9Esw
__req=17
__be=-1
__pc=PHASED%3ADEFAULT
fb_dtsg=AQG5P4wy1kJ6%3AAQGxD7sfo49g
ttstamp=26581715380521191214910774545865817112068551151021115257103
__rev=2425895

That makes a lot of parameters, but actually only a few interests us.

In particular, line 20, the "body" parameter which is set to "test", exactly our message!
Line 4, 23, 24 and 31 are relative to who sent the message and to whom.
Note: line from 33 to 41 are parameters setup in the login phase, they are used to authentify the connection.

So in my program if I want to add the functionality to send a message (not taking into account sending photos, files etc, which are attachments) all I have to do is fill in all those parameters which are for the most pretty easy to guess what they mean, easier than trying to read the obfuscated js code anyways. Also, most of the parameters are not required for the request to work, here's a more minimalist request:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
POST /ajax/mercury/send_messages.php?
message_batch[0][action_type]=ma-type:user-generated-message
message_batch[0][author]=fbid:100000*******67
message_batch[0][source]=source:chat:web
message_batch[0][source_tags][0]=source:chat
message_batch[0][body]=test
message_batch[0][has_attachment]=false
message_batch[0][specific_to_list][0]=fbid:100003*******64
message_batch[0][specific_to_list][1]=fbid:100000*******67
message_batch[0][other_user_fbid]=100003*******64
client=mercury
__user=100000*******67
__a=1
__dyn=7AmajEzUGByA5Q9UoGya4A5ER6yUmyUyGiyEyfirWo8popyui9zob4q68K5U4e2O3J1ebkwy8wGFeex3BKuEjKeCwxxRa3CnDBxe6rxCLGqu2PxOcxu5ocE88C9z9oybx24o9Esw
__req=17
__be=-1
__pc=PHASED%3ADEFAULT
fb_dtsg=AQG5P4wy1kJ6%3AAQGxD7sfo49g
ttstamp=26581715380521191214910774545865817112068551151021115257103
__rev=2425895

So if I want to send a message to someone else I just have to replace "test" by the text and put their id (there is a function to find the user id of someone).

For this example it's not too hard to guess what the parameters are for but for some function it can get much more confusing. Fortunately. I didn't have to do all that tiedous work by myself, there is the excellent facebook-chat-api project in nodejs on which I could refer to help me in my coding.

Goals

The goal of the Facechat library is to cover all functionality in a way that you could make your own messenger client with the features as the official and even more. One example of a use case that is not covered by the official client and which I need is downloading a complete conversation. Anyone that's ever used Facebook Messenger knows that it's a real pain to read ancient messages and if the conversation is somewhat long then it's simply impossible to get to the start. So I made a program that download the complete conversation to a file using my lib.

Difficulty

As mentioned in the previous paragraph I made a concrete program using my lib. But I had some problem, between the time I wrote the lib and the time I got to use it Facebook's internal working changed and the lib didn't work anymore. A couple of change and actually a lot of debugging time was required to make it functional again.

Facebot

As I said the original intent for writing this lib was to make a bot with the same functionality as some IRC bots and also to channel Facebook's messages through IRC and vice versa. And that's what I did in my Facebot project, here's a list of the available commands which is pretty easy to extend:

#.say

simple command that echo back. eg: .say text to be echoed

.g, .google

Google search. eg: .google how to be as cool as lapinozz?
Image search. eg: .google image cool image

.y, .youtube

Youtube search. eg: .youtube how to break laws of physic

.w, .wiki, .wikipedia

Wikipedia search. eg: .wiki proton

.tr, .translate

Translation command. eg: .tr traduit ce text en englais
The default target language is English you can change that like this:
.tr fr This text will be translated to French

.def, .define

Get Definition. eg: .define paradox

.rnd

Random, word, sentence or paragraph.
eg: .rnd
eg: .rnd sentence
eg: .rnd paragraph

.time

Give the current time. eg: .time;

.userID, .userId, .userid

Get the facebook user id of someone. eg: .userId Marie Gagnon

.userInfo, .userinfo

Get the facebook information of someone. eg: .userInfo Marie Gagnon

.tell

Send a mesage to someone. eg: .tell Marie Gagnon : you'r so sexy today
you can also send to multipel personne eg: .tell Marie Gagnon | Stephanie Gagnon : im not a cheater

.g++, .gcc, .nasm (My favourite command)

Execute code, yes this use cee from BoxBox :D
eg: .g++ {int i; i = 4*5; cout << i};

.choose

Randombly choose between multiple choice eg: .choose choice1|choice2|choice3

#.irc

IRC commands
eg: .irc join #sfml
eg: .irc part #sfml
eg: .irc send #sfml im too cool for you
eg: .irc send Nyrox im too cool for you
Turn on Facebook to IRC eg: .irc on
Turn off Facebook to IRC eg: .irc off

If Facebook to IRC is turned on each, when someone send a message to you or you send them a message on Facebook it will automaticly connect a IRC user with their name and send you the message in private, you can then replie to that irc user and it will send that replie on facebook.

.in

Send message after a certain time eg: .in 4m 30s tell me this
can also send to someone else eg: .in 4m 30s Marie Gagnon: tell her this
or even to mutiple personne eg: .in 4m 30s Marie Gagnon | Stephanie Gagnon: i already told you nothing happened between your sister and me

Limitation

One down side of Facechat is that, contrary to the case where Facebook would have an public API, you can't use an authentification token, the library user must provide his login credentials which can make it harder for the user to trust the application.

Conclusion

It was a fun project and I plan to add more functionality, if you have any idea or suggestion feel free to contact me by email.

Thank you for reading I hope you did enjoy.

facebook docs ↩ ↩²

Lazy Theta* Any Angle Pathfinding

Tue, 07 Jun 2016 17:05:23 -0400

Any angle pathfinding

To get smooth path there is a widely used method of using A* and then smoothing the path. Theta* is an any angle pathfinding algorithm, which mean that it allow for a path between two nodes even if they are not neighbors as long as there is a direct line of sight between them.

Examples of grid path(left) vs shortest path(right)

Theta*

Where in A* a node parent's must be a neighbor, the idea behind Theta* is that a node parent's can be any other node. So in A* we take the node in the open queue with the lowest g-value and for each of its neighbors, we check if the g-value of the current node plus the cost to travel from that node to the neighbor is inferior to the current cost of the neighbor. If so, we set the neighbor parent to the current node and update its g-value.

Here's a pseudo code for A* (note that most image were taken from this page and this one)

Now for Theta* the only difference is in the ComputeCost function. What we add is a line of sight check between the neighbor and the parent of the current node, if there is we check if the g-value of the parent plus the cost to travel from it to the neighbor is inferior to the current cost of the neighbor, if it is then we update the neighbor g-value and set its parent to the parent of the current node. Here the cost is calculated by simple line distance.

Again, pseudo code of the updated ComputeCost

Lazy Theta*

Lazy Theta* is an optimization of Theta* which reduce the number of line of sight check. Rather then doing the line of sight check for each neighbors of the current node we assume that there is a line of sight and check it latter. So for each neighbors, we directly check if it would have a smaller g-value if we set the its parent to the parent of the current node and if it does then set it. And at the step where we fetch the node with the smallest g-value in the open list, before processing its neighbors, we do the actual line of sight. Because it was added to the open list and its parent updated wihtout knowing if there was a line of sight or not. If there is a line of sight between the node and its parent then it's all perfect and we can skip this step, if there is none, we look at each neighbor in the closed list and set the parent to the one which give the lowest g-value.

Here's the complete pseudo code, from left to right for A*, Theta* and Lazy Theta*

Implementation

I had some theory and even some pseudo code, what could go wrong? Well, I don't if you can understand line 37/38 of the third code but I sure could not. So when I searched if I could find any code online but pretty much anything I could find was a comparison of different pathfinding algorithm and the code was very dispatched and hard to follow, it would have been hard to make sens of the Theta* code without going over pretty much every other file, plus most of them were implementation of Theta* and I could already make sense of the Theta* pseudo code, what I needed was a source code for Lazy Theta*. I finally found this page http://idm-lab.org/project-o.html which host an archive with code for several any angle pathfinding algorithms. I had to rewrite it pretty much completrly because the code style really did not suit me and I wanted a nice C++14 code.

Modularity

I also wanted the code to be the most modular and reusable as possible so I used the concept of adaptor(shamelessly stolen from a friend of mine ¹)

This approach makes it possible to use it for grid, hexagon tiles, polygon map. Really anything where you need to find a path between two points, my friend even told me he was able to reuse his code to find the shortest path between two words.

One last optimization

Another optimization that was discussed in the article linked above was to use weighted h-value. Remember that the h-value is the heuristic distance between a node and the goal. This method can give slightly longer path, but can also reduce a lot the number of line of sight check. So it simply consists of multiplying our h-value by a weight superior to 1.

Here's all the nodes that get checked with on the left a weight of 1(basically no weight) and on the right a weight of 1.1

Conclusion

My github repo contains the main file, pathfinding.hpp and an adaptor example for tile grid in tileadaptor.hpp (2x AA battery included)

I also added a demo in main.cpp to show how to use everything, it makes little map and find the path from the start to the end then output it to the console like so:

######################################################################
#S   #              #                                                #
#    #              #                                                #
#    #              #                                                #
#    #              #                            2                  3#
#    #              #                             ################## #
#    #              #                                           #    #
#    #              #                                           #4   #
#    #              #                                           # ####
#    #              #                                           #    #
#    #              #                                           #    #
#    #              #                                           #    #
#    #              #                                           #    #
#    #              #                                           #    #
#   0               #                                           #    #
#                   #                                           #    #
#                                 1                             #5   #
#                                                               #    #
#                                                               #   E#
######################################################################
#  = walls
S  = start
E  = end
number = path nodes

feather kit ↩

Placeholder

Joltron, a very shocking game

The Concept

The Shock

The Game(s)

The Electronics

The Interference

The Playing

Overengineered Automatic Cat Feeder

The Monsters

The Idea

The Structure

The First Prototype

The Second Prototype

The Disruption

The Electronics

The Coding

The Interface

The Sharing

The Heating

The Wifi

The Finishing Touches

The Result

3D Printed RTX 3080 Keycap with working fan

The Printer

The Design

The Modeling

The Fan

The Assembly

The Result

DIY Smart Door-Lock

The Repetition

The Perfect Lock

The Hardware

The Software

The Voice Activation

The Finishing Off

The Security

Rubber Duckies and practical trolling

The Troll

Rubber ducky

The plan

The Rootkit

The pranking

The Defusing

Persistence-Of-Vision Display

The Itch

POV Display

Construction

Testing and Adjusting

Result

Going further

Compile-time templated A* pathfinding in C++14

What is this?

Inspiration

Tools

Code

Starting simple, Vec class

Vector

Note on my synthax

Bad, bad Vector

Map

Node

Pathfinding

Debugging

The actual map

The Final code

It's nice and all that but how do you know it actually works?

Final Output

Conclusion

A 4-bit Calculator made in cardboard and marble

LOGIC

What is it?

Why?

What was learned?

What does it look like?

Woah, How do you use it?

How does it work?

AND gate

XOR