The Haskellboard is an electric longboard that uses Haskell to control the motor using input from a Joy-Con. It uses a Raspberry Pi Zero W, which I selected for its form factor and wireless capabilities.
Recently, I’ve had the urge to play around with alternative transport methods. I don’t have a car, so getting around places gets kind of difficult sometimes. Commuting tends to revolve around carpooling, taking Ubers, and, more recently, taking the bus. I like to travel this way over driving, but it does come at the cost of immediate convenience.
During my time in my high school robotics club, it became almost a tradition for upperclassmen to build so-called ‘boosted boards’ — electrically-powered longboards you controlled with a remote. I’ve always wanted to build one myself, but I never really got around to it until now.
why haskell ? ??
Haskell is not the most ideal language to use for this sort of project — it would have been easier to slap some generic Arduino code on and be done with it. During the inception of this board, I was working my way through the Haskell book. I was itching to use it in a practical setting, so I figured that writing the software for the board in Haskell would be a fun way to apply what I’ve learned! It would also be a little novelty for me to mention ;)
Haskell ecosystem on the Pi
I was pleased to see that (for the most part) everything builds and runs as expected on the Raspberry Pi. A pleasant suprise came in the form of the wiringPi bindings on Hackage. I thought that I’d have to write my own bindings for PWM output myself, but luckily some work has been done on this front already!
I based the software on the Yampa FRP framework.
A quick overview of Yampa’s approach to FRP: a signal in Yampa represents a time-varying value (
Signal a). A signal function represents a transformation of a signal into another signal (
SF a b). More complex signal functions can be constructed out of primitive signal functions and then executed as an
IO action. I encourage you to take a look at the slides here for a more involved explanation.
The core of the program is one large signal function. It transforms an
Inputs signal (representing input updates from the Joy-Cons) into an
Outputs signal (representing motor output).
I found it difficult to formulate logic using Yampa, but I feel that this is mainly due to my unfamiliarity with FRP and not Yampa itself. Once I got over the initial learning curve of Yampa’s DSL, I found it incredibly concise compared to other frameworks.
Building Haskell programs for the Pi
I decided to build the project on the Raspberry Pi itself. Although setting up a cross-compiler seemed possible and would have been faster, the process seemed finicky and would have taken a lot of time.
stack on the Pi
stack is not yet in Raspbian repositories, but it seems like it’s possible to run on the Pi. However, I noted the current difficulty of building
stack for the Pi, and decided to forgo using
stack for this project in favor of using plain
Joy-Con behavior through
The Joy-Con only seems to send the absolute state of the joystick when connected to a non-Switch device through Bluetooth (e.g. Up, Down, Left, Right instead of
x: 0.8, y: 0.2). This may just be a driver quirk.
Pi boot time
I was surprised at how much I could chop the Pi boot time down to by disabling services and components (14 seconds on average). A microcontroller like an Arduino would definitely fare better, however.
- Controller: Raspberry Pi Zero W
- Bluetooth capability
- Raspbian Linux
- HID: a Joy-Con (left side) from the Nintendo Switch
- Motor: KEDA 56-63 Brushless Outrunner
- 195 kV
- Batteries: 2x ZIPPY Flightmax 3S1P
- capacity: 10,000 mAh
- discharge rate: 20C
- ESC: red brick (???)
- 125A continuous
- 140A burst