- Citizen Science
- IoT Applications
- Great microbit.org Resources
- ScratchX (Micro:Bit extension!)
- Making Blocks
This project was created in an effort to create a real-world example project for my introductory IoT courses.
The mini-garage provides nearly the same features as a real garage door opener:
The videos below shows the basic garage door control that developers (students) have to implement. They implement all control logic (direction of motor, when to start/stop, etc.). Some of the required behaviors include:
Follow-up assignments implement internet-based control of and feedback from the door. These include features that aren’t feasible on traditional garage door openers, such as notifications if the door has been left open.
Basic Opening Due to Button
Alternate Video Source
Detecting a Fault (Person in the Way)
Alternate Video Source
View of the Mechanical Parts Opening/Closing from Above
Alternate Video Source
View of the Mechanical Parts Opening/Closing from Side
Alternate Video Source
A Tour of the 3D Model
Alternate Video Source
An Overview of Constructing the 3D Model
Alternate Video Source
A garage was selected for a variety of reasons:
I also had some personal goals:
The intended purpose (classroom use), imposed some requirements on the mini-garages:
Given the requirements, I decided on something that’s approximately shoe-box size. A 1/24th scale was a good fit. The model is parameterized and many aspects of it will scale with a simple change to the scale parameter. The size of tabs on the box joints may need some adjustment and some elements, like the motors/gears/etc. are a set size and don’t scale. Consequently, modifications of scale often need some triage to get back to a working model and things go awry if the scale is significantly different than 1/24th.
I chose a two processor design to help protect hardware and to require compliance with an API. The students write code for a Particle Photon, which is then plugged into the garage hardware via a ZIF socket. It interacts with an Arduino Pro Micro, which does the real I/O. The only shared electrical connections from the Photon are power, ground, and RX/TX from a UART. This minimal interface helps avoid a wayward short-to-ground due to an accidentally misconfigured output. (RX/TX is relatively safe due to code review prior to using the hardware and because we don’t use that RX/TX for any other aspect of class. Circuits for other work only uses the DX and AX pins).
When developing and testing code without the garage, developers use stubs for the API. The stubs typically simulate the garage via LEDs and switches, which is sufficient for most testing. Some aspects of the assignments require meeting timing constraints, which requires code instrumentation as well.
The motors (steppers) were chosen partly due to size and, largely, due to price and availability. The choice of motors impacted both the technique for stall detection and the power requirements. Since it’s relatively difficult to detect stalls in steppers via changes in current, a mechanical rotary sensor on the front belt gear is used. If motion stops for a sufficiently long time it’s assumed that the door is stalled. This technique has some limitations if the mechanical strength of the motor/belt can damage the mini-garage prior to a stall being detected, but fortunately this doesn’t seem to be the case.
Typically the Arduino Pro Micro is connected via a USB cable to a PC, which monitors for errors. If the developer’s code attempts to overdrive hardware or misses timing constraints, it’s reported via a message. It was originally hoped that the USB cable could also satisfy all power requirements. Unfortunately the total current used by all components may exceed the current supplied by either of the Arduino Pro Micro’s on-board voltage regulators, which could lead to erratic performance. Rather than using a custom USB cable and additional power supply, I decided to just use an independent power supply for the motors (4AA batteries).
Files / Source
|Item||Link||Notes||Cost (USD)||Items per Purchase||Items needed per Build||Average cost per build|
|MDF||Home Depot: 2’x2′ MDF Sheets||3.72||1||1||3.72|
|Timing Belt Gear||Amazon: BEMONOC 2GT Timing Pulley 20 Teeth 6mm Bore fit GT2 Belt Width 6mm||Used for rotation sensor||21.88||5||1||4.376|
|Timing Belt Kit||Amazon: Drillpro 8Pcs 5mm 20Teeth Timing Pulley Wheel+GT2 5 Meters||Belt, pully (for motor)||15.54||8||1||1.9425|
|Timing Belt Clamp||Amazon: Mercurry 5pcs 2GT Timing Belt Aluminum Gear Clamp Mount Block||9.99||5||1||1.998|
|Canvas Panel||Used as door hinge (glued with wood glue)||~$7||15||1||0.46|
|Perf Board||Amazon: Gikfun Solder-able Breadboard Gold Plated Finish Proto Board||12.88||5||1||2.576|
|Rotary Encoder||Amazon: Podoy 6Pcs Rotary Encoder Switch 6mm 18 Detent Points||Used to detect door stalls / prevent crushing (easier than current detection w/ stepper)||8.39||6||1||1.398333333|
|Laser||Amazon: GeeBat 10pcs Mini Laser Dot Diode Module||Safety beam / sensor||5.99||10||1||0.599|
|Laser Reciever||Amazon: Icstation 5V Laser Recevier Sensor Module||Safety beam detection||12.99||5||1||2.598|
|Contact Switches||Amazon: Gikfun Micro Switch Long Hinge Lever||Detect when door is at extremes of travel||7.98||20||2||0.798|
|Stepper Motor||Amazon: Elegoo 5 sets 28BYJ-48 ULN2003 5V Stepper Motor + ULN2003 Driver Board||Door opener||13.99||5||1||2.798|
|ZIF Sockets||ebay: US Stock 2x 24 Pin 2.54mm ZIF ZIP IC Test DIP Board Socket Universal 3M 224-6182||7.19||2||1||3.595|
|Arduino Pro Micro||Amazon: KOOKYE 3PCS Pro Micro ATmega32U4 5V/16MHz||19.99||3||1||6.663333333|
|26 Gauge wire||Amazon: 26 AWG Flexible Silicone Wire Electric wire||Narrower wire would be better. (28 maybe?)||16.39||5||1||3.278|
|LED||Amazon: Chanzon 100 pcs 5mm White LED Diode Lights (Clear Round Transparent DC 3V 20mA)||Not the exact parts I used. Overhead light.||6.67||100||1||0.0667|
|M2 Screws (Door connector hinges)||Amazon: M2x25mm Stainless Steel Phillips Flat Countersunk Head Screws 50pcs||Connect door to door hinge; Door hinge to traveller||4.99||50||2||0.1996|
|M2 Screws||Amazon: 50 Pcs M2x14mm Stainless Steel Round Head Phillips Machine Screws||Connect stop switches to guide||6.8||50||4||0.544|
|12 pin Header socket||Amazon: 0pcs 2.54mm Single Row Female Pitch Header Socket||PCB Sockets for Arduino||1.74||10||2||0.348|
|M4 Screws / 16mm||Amazon: Class 4.8 Steel Machine Screw, Zinc Plated Finish, Pan Head, Phillips Drive, Meets DIN 7985, 16mm Length, M4-0.7 Metric Coarse Threads||2 for motor to mount||7.37||25||2||0.5896|
|M4 Nuts||Amazon: 20pcs M4 Thread 304 Stainless Steel Hex Hexagonal Nuts||2 for motor to mount||6||20||2||0.6|
|M2 Nuts||Amazon: 70 Pcs Silver Tone Metal M2 Hex Screw Nut||6; 4 for switches, 3 for hinges||6.24||70||6||0.5348571429|
|Ribbon Cable||Amazon: 30CM M/F Breadboard Jumper Wires Kit,80 Pin Male to Female Ribbon Cables||For motor board to Arduino; Bundle of 6 wires per board||6.99||6||1||1.165|
Average cost for a single garage: $40.83 (plus minor incidentals)
Special thanks to Carly Lowe, who was a Dream Consultant at Tech Shop when I made these. Around 5pm one day I mentioned to Carly that I wanted to create a little model garage. There was a prototype building with sliding door assembled and waiting when I came in at 9am the next morning. She showed me the idea was feasible. Of course it took me about two months to recreate what she’d done as an evening project. (I wouldn’t have considered the windows/door/etching if I hadn’t seen Carly’s model. She also suggested the use of fabric for the door “hinge”)
This is out-of-date. Just follow the instructions at https://github.com/Microsoft/pxt-microbit
I’ve been looking into the Micro:Bit and Microsoft’s PXT (Programmer eXperience Toolkit). PXT and all the required build tools can be installed on macOS, but the official instructions are a little weak. Here are the required steps:
All these commands need to be run in a terminal:
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
brew install node
brew tap ARMmbed/homebrew-formulae
brew install python cmake ninja arm-none-eabi-gcc
pip install yotta
brew install srecord
git clone https://github.com/Microsoft/pxt-microbit
npm install -g pxt
This will download the needed components, do compilation, and eventually launch the PXT environment in your default browser. Watch the terminal window though. Downloads may exceed github limits and it may require you to paste a URL to login in and complete downloads (something like https://yotta.mbed.com/?provider=github#login/...).
git clone https://github.com/Microsoft/pxt-bluetooth-temperature-sensor
mv pxt-bluetooth-temperature-sensor bluetooth-temperature-sensor
I helped put together two simple projects that could be used in agriculture applications (monitoring livestock):
Thanks for participating in our Workshop. Feel free to contact us at any time either via e-mail or connect with us on LinkedIn:
|Bill Siever||Michael Rogers|
Please download these files:
Please help SIGCSE evaluate workshops by completing this survey at the end of our session:
In preparation for the SIGCSE 2015 I put together a demo showing ways to leverage Swift’s Playgrounds for a more immersive learning experience. They are:
The second example introduces while-loops and the Assistant Editor. It also contains a “code building” component that uses a “Parsons problem” from Runestone Interactive. The Parson’s Problems are a powerful way to guide learners to proper logic and syntax. Rather than create code from scratch, it’s just a matter of dragging/dropping code in the correct order, as seen here:
In the full while-loop playground example the learner should also type in the actual code and evaluate it in the playground.
One of the most most common debugging techniques is “logging”, or creating a history of what happens while code runs. Logging can be especially difficult in embedded systems, which often lack a natural way to log events, like a console. Commonly UARTs are used to log messages via a serial port, but this approach can consume significant run-time that may undermine the timing constraints of the software. It also requires the use of additional pins to support development.
I’ve found it especially difficult to debug applications using Nordic’s Bluetooth Low Energy products (nRF family). Fortunately, due to some helpful hints by fellow Nordic developers (Thanks Jeremy) and great products from Segger, I’ve got a solution that suits my needs fairly well. Segger’s Real-Time Terminal is a perfect solution to the problem. I’ve taken the example’s provided by Segger and made a package from them (easier to configure on multiple projects). I’ve also added some wrapper functions that provide additional data I find helpful when debugging.
The following explains how to setup a logger for the nRF series of chips, but assumes that:
This guide is broken into three distinct phases:
These steps should only need to be performed once.
The Tools menu should now have a new item that will be used to launcher the Log Viewer.
You will need to do this for each project on which you want to use these logging functions.
In order to use the logging functions you will need to add calls to the logging functions to your code. You can use primitive functions provided by Segger, but I choose to use my own wrappers. In order to use my wrappers you will need to include the header file:
Here are some examples in code:
This work is provided as-is with no warranty or guarantee of any sort. I’m new to Segger’s RTT and haven’t done any review of performance issues. I’m also new to CMSIS Packages and haven’t verified that I’ve followed all appropriate package conventions. At this point this is an alpha version, but any input or suggestions are welcome. The log macros were made for my needs when I developed them and may not suite other’s needs. The formatting used for them could certainly be improved.
The package includes unmodified code provided by Segger at: http://download.segger.com/J-Link/RTT/RTT_Implementation_141217.zip. Code by Segger includes a copyright notice, but they have given me permission to share the package.