DIY split-flap display

Overview

DIY Split-Flap Display

This is a work in progress DIY split-flap display. Prototype four-character display: video.

animated rendering prototype video

Build Status Build Status Build Status

The goal is to make a low-cost display that's easy to fabricate at home in small/single quantities (e.g. custom materials can be ordered from Ponoko or similar, and other hardware is generally available).

The 3d model is built using OpenSCAD in 3d/splitflap.scad, the driver board is designed in KiCad in electronics/splitflap.pro, and the driver firmware is written using Arduino (with PlatformIO support) in arduino/splitflap/Splitflap/Splitflap.ino.

You can view an interactive 3d model of the design on the project website.

New: Join the community Slack group to discuss or ask questions about the project!

Want to help support prototyping and development? Buy Me A Coffee

How a split-flap display works

Current Status

You can download the latest stable release from the official 'releases' page.

Releases have been tested and used to produce working units, but as this is a DIY project, there may always be minor issues and/or incomplete documentation.

Component Status Notes
Enclosure/Mechanics Stable
Classic Controller Electronics Stable
New Chainlink Electronics Alpha Next-generation/alternative electronics, designed for easier assembly and larger displays
Firmware Stable
Control Software Example Stable Example python code for driving the display is in the software directory

I'd love to hear your thoughts and questions about this project, and happy to incorporate any feedback you might have into these designs! Please feel free (and encouraged) to open GitHub issues, email me directly, reach out on Twitter, and get involved in the open source development and let's keep chatting and building together!

⚠️ Latest Experimental Files:

Important: the files linked below are EXPERIMENTAL and have been auto-generated from the latest commit. They may contain changes that are untested or outright broken. Do not use these unless you are actively making changes to the project and know what you're doing. Otherwise, use the latest stable release.

  • Lasercut Vector File (svg)
  • Classic Controller electronics
  • Sensor PCB, panelized (gerbers / pdf)
  • Chainlink Driver PCB
    • Schematic pdf
    • PCB overview pdf
    • PCB gerbers zip
    • PCB bom (for JLCPCB assembly) csv
    • PCB bom (for manual assembly) link
  • Chainlink Base PCB

Design Highlights

  • laser cut enclosure and mechanisms from a single material
  • cheap, widely available 28byj-48 stepper motor (less expensive than NEMA-17 motors, and doesn't require an expensive high current stepper driver)
  • CR80 PVC cards for flaps, cheap in bulk
  • store-bought vinyl stickers for flap letters
  • control up to 12 modules from a single Arduino Uno

2d laser cut rendering

Build Your Own

Rough Cost Breakdown

This is an incomplete list of supplies needed to build a split-flap display module to get a rough sense of the overall cost. Many items have minimum package sizes, so per-unit-prices will be higher when building fewer units due to the need to buy more items than will actually be used.

Each section includes a subtotal based on building 4 modules, which is a relatively economical compromise where shipping costs and MOQs no longer dominate the cost.

Overall, expect to spend somewhere around $200 to $250 for 4 standard 40-character modules.

Housing

The laser-cut housing/mechanics can be ordered from Ponoko (high quality, US-based) or Elecrow. Or you can cut it yourself if you have a laser-cutter capable of cutting 3mm MDF or acrylic.

Ponoko

Price Units per order Name Supplier Notes
$52.97 4 4x MDF 3 mm, laser-cut, shipping Ponoko
$14 N/A Setup fee Ponoko

Total: $16.75 per unit (at 4 units)

Elecrow

Price Units per order Name Supplier Notes
$15 5 Wood laser cut, 3 mm, no engraving Elecrow
$22 5 Shipping Elecrow

Total: $9.25 per unit (at 4 units)

Hardware & Consumables

Price Units per order Name Supplier Notes
$5-10 4 50 pack M4-10 Button-Head Hex Screw Many options 11 screws needed per unit
$5-10 4 50 pack M4 Hex Nut Many options 11 nuts needed per unit

Total: $2.50-5.00 per unit (at 4 units)

Flaps

There are two options for flaps: hand-cut or professionally die-cut.

Hand-Cut (Option 1)

Each card needs to be cut in half and then have two pieces punched out of either side. Each display unit requires 40 flaps, or 20 cards per unit. 100 cards is enough for 5 units in theory, but 4 in practice because there are no spares for mistakes.

Price Units per order Name Supplier Notes
$14 4 Blank white CR80 cards Amazon One package ($14) covers 4 units
$9.17 N/A Badge slot punch tool Amazon One-time, up front cost
$7 2 Vinyl letter stickers Amazon One package ($7) covers 2 units

Total: $7.00 per unit (at 4 units) + $9.17 upfront for the punch tool + a lot of time and effort

Die-Cut (Option 2)

These professional die-cut flaps are manufactured specifically for this project (no manual cutting/punching required) and come in both white and matte black. Sold by Bezek Labs LLC, so proceeds help support continued development on this project.

Price Units per order Name Supplier Notes
$53 4 Die-cut flaps Etsy - BezekLabs One package ($45 + shipping) covers 4 units
$7 2 Vinyl letter stickers Amazon One package ($7) covers 2 units

Total: $16.75 per unit (at 4 units)

PCB

Circuit boards are available either in small quantities from the Bezek Labs LLC store, or in bulk from PCB manufacturers such as SeeedStudio.

Etsy - BezekLabs

Price Units per order Name Supplier Notes
$3.99 4 Controller PCB Etsy - BezekLabs One PCB supports 4 units
$2.99 4 Sensor PCB set Etsy - BezekLabs 4 PCBs per package

Total: $1.75 per unit (at 4 units)

SeeedStudio (Bulk)

Price Units per order Name Supplier Notes
$5 80 Controller PCB SeeedStudio 20 PCBs per order, 4 units per PCB
$5 200 Sensor PCB SeeedStudio
$15 Shipping Combined shipping for both items

Total: $6.25 per unit (at 4 units), or as low as $0.32 per unit (at 80 units)

Electronics & Motor

Price Units per order Name Supplier Notes
$14.00 4 Controller board components DigiKey One PCB supports 4 units
$2.00 1 Sensor board components DigiKey
$2.00 1 28byj-48 motor (12V preferred) AliExpress See motor notes for details
$10.00 10 3-pin servo cable (male to male) Amazon or AliExpress
$11.00 Up to 12 12V power supply Amazon One per display (up to 12 units)

Total: $5.00 per unit (motor, sensor components, cable) + $14.00 per 4 units (controller components) + $11.00 per display (up to 12 units)

You can find a more detailed breakout of electronics' bill of materials (BOM) in the ordering instructions.

Design & Modification Guide

3D Design

The main design file is 3d/splitflap.scad

You'll need a recent version of OpenSCAD (e.g. 2015-03), which may need to be installed through the PPA: sudo add-apt-repository ppa:openscad/releases

In general, solid objects such as the enclosure sides or spool components are built from 2d primitives and then extruded to the appropriate thickness for 3d rendering, rather than using 3d primitives. This simplifies the design without losing expressiveness; the perpendicular laser cut beam doesn't allow for cuts that vary in the Z dimension anyway.

Note that while the design is parameterized and many values may be tweaked, there is currently no error checking for invalid parameters or combinations of parameters. Please take care to validate the design if you change any parameters. For instance, while most of the design will adjust to a changed num_modules value, certain values may cause some elements to intersect with other elements or protrude beyond their expected dimensions.

Rendering

Laser-cut vector files

The design can be rendered to 2d for laser cutting by running 3d/scripts/generate_2d.py [--panelize ], which outputs to 3d/build/laser_parts/combined.svg. The optional --panelize argument allows for rendering a panel of modules in a single SVG, for bulk laser-cutting.

Internally, the design uses a projection_renderer module (3d/projection_renderer.scad), which takes a list of child elements to render, and depending on the render_index renders a single child at a time. It also adds material to each shape to account for the kerf that will be cut away by the laser.

The generate_2d.py script interacts with the projection_renderer module by first using it to determine the number of subcomponents to render, then runs OpenSCAD to export each component to an SVG file. It does some post-processing on the SVG output (notably adds "mm" to the document dimensions), and then combines all components into the single combined.svg output.

Once the combined.svg file is generated, you'll want to double-check there aren't any redundant cut lines that are shared by multiple adjacent pieces, to save time/cost when cutting. They should be detected automatically (and highlighted in red in the rendering above), but it doesn't hurt to double-check. In Inkscape, select the "Edit paths by nodes" tool and select an edge to delete - the endpoints should turn blue. Then click "Delete segment between two non-endpoint nodes", and repeat this for all other redundant cut lines.

Animated gif

The design can be rendered to a rotating 3d animated gif (seen above) by running 3d/scripts/generate_gif.py, which outputs to 3d/build/animation/animation.gif

The generate_gif.py script runs multiple OpenSCAD instances in parallel to render the design from 360 degrees to individual png frames, which are then combined into the final gif animation. As part of building the animation, generate_gif.py renders the design with multiple configurations (opaque enclosure, see-through enclosure, no-enclosure and no flaps) by setting the render_enclosure and render_flaps variables.

STL models/web viewer

The design can be rendered to a series of STL files (one per color used in the model) in order to be displayed in an interactive web-based 3d viewer. Similar to the projection_renderer used to render individual components for laser-cutting, the ColoredStlExporter detects all the colors used in the model and renders them one-by-one to separate STL files, along with a manifest that maps each STL file to its RGB color. The STL files and manifest are loaded using three.js to display an interactive model on a web site using WebGL. See this blog post for more details on how the export and three.js renderer work: OpenSCAD Rendering Tricks, Part 3: Web viewer.

3D Printed Tools

The project also includes a number of optional 3D printed designs to make assembly easier. These include:

All of these designs are parametric and customizable within OpenSCAD. To print them, open up the relevant file in OpenSCAD and use File -> Export -> Export as STL to render the design as an STL file for your slicer.

Electronics

The current recommended approach is the Classic controller board, which plugs into an Arduino Uno as a shield and can control up to 4 modules. Up to 2 additional Classic controller boards can be chained using ribbon cables for a total of up to 12 modules controlled by a single Arduino Uno.

For small displays (up to 3 modules), you can skip the custom controller boards and use off-the-shelf ULN2003A driver modules plugged into an Arduino Uno. This is partially documented in the wiki but may require some additional tinkering to get it to work. Help wanted: if you'd like to help improve these instructions, please reach out in the Slack group, thanks!

A new design (Chainlink) is currently under development, which allows for larger-scale displays by chaining more modules together and uses a more powerful microcontroller (ESP32). This also adds the possibility of wifi and BLE control, though this isn't currently implemented in firmware yet. For the latest on the Chainlink system, join the Slack group.

Module Electronics

Each module needs a hall-effect sensor for start-up calibration and fault monitoring. This can be mounted in different ways but the recommended approach is to use a small PCB, with an AH3391Q (or similar) sensor and connector, which mounts to the side of the module with a single screw and can easily be adjusted for precise calibration.

These boards are small (about 16mm x 16 mm) and the designs are available as a panelized PCB, which can be snapped apart. The panelization is configurable (see generate_panelize_config.py) and is optimized for production at SeeedStudio.

Classic Controller Electronics

The Classic driver board is designed to plug into an Arduino like a shield, and can control 4 stepper motors. Up to 3 driver boards can be chained together, for up to 12 modules controlled by a single Arduino. The designs for the controller can be found under electronics/splitflap.pro (KiCad 4 project). Nearly everything is a through-hole component rather than SMD, so it's very easy to hand-solder.

The driver uses 2 MIC5842 low-side shift-register drivers, with built-in transient-suppression diodes, to control the motors, and a 74HC165 shift register to read from 4 hall-effect magnetic home position sensors. There are optional WS2812B RGB LEDs which can be used to indicate the status of each of the 4 channels.

The PCB layout is 10cm x 5cm which makes it fairly cheap to produce using a low-cost PCB manufacturer (e.g. Seeed Studio).

Chainlink Electronics

The Chainlink system is an upcoming alternative to the Classic controller/driver, which is designed to be easier and
cheaper to build, especially in higher quantities due to its simplified BOM and surface-mount components. It's also designed to support longer chains of driver boards to control large displays (think 100+ split-flap modules).

This electronics design is still in very active development, and not recommended unless you know what you're doing.

The Chainlink system uses 2 PCB designs:

  • Each Chainlink Driver board accepts data and power and connects to 6 individual split-flap modules. Chainlink Driver boards can be chained together to construct a large display.
  • A Chainlink Base board holds the microcontroller (ESP32 with USB, Wifi, BLE capabilities), central power management/distribution, and sends data to the chained Driver boards.

Chainlink Driver

This is currently under active development. It has been tested and appears to work, but is not yet recommended for general use. Firmware support is in progress.

Key features:

  • Controls 6 split-flap modules per board instead of just 4 - fewer PCBs means lower cost and less wiring
  • Longer PCB (200mm) gets connectors closer to each module so wires have more slack
  • Primarily SMD and all components (except the pin headers and motor connectors) are available in JLCPCB's parts library for easy SMD/THT assembly
  • Clock and latch lines are buffered with a 74HC125 to support longer chains
  • Neopixels replaced by shift-register-driven single-color LED per module (one fewer data line needed in the chain, lower current draw, and 3.3v IO friendly)
  • 2 bits of loopback (connecting 2 spare output bits on output shift registers to 2 spare inputs) allows the controller to validate data integrity up and down the whole chain
  • TPL7407L mosfet low-side drivers instead of ULN2003A/MIC5842 (lower on-resistance means less voltage drop in the driver = more torque, less waste heat, and less total current consumption)
  • Module order goes from right-to-left since this is intended to be installed and accessed from behind the modules

This design is optimized for assembly at JLCPCB, and files are automatically generated for ordering assembled PCBs there. However, if you wish to assemble this board yourself, you can view the interactive BOM/placement tool

Chainlink Base

This is currently under very active development. It is untested and does not have firmware yet.

Key (planned) features:

  • TTGO T-Display ESP32 module as the controller, which includes USB-C, color IPS LCD display and buttons
  • Optional master relay output for 12V PSU control (5V relay, up to ~500mA coil current)
    • Future firmware will power on the 12V PSU after a startup self-test, and power off PSU in case of any faults
  • 5 channels of independently monitored 12V switches for powering groups of Chainlink Driver boards (6-8A max per channel)
    • Depending on the motors you use, each channel may be able to power about 5 Chainlink Driver boards which is 30 splitflap modules
    • Each channel includes an automotive fuse holder for additional over-current protection
    • INA219 and shunt resistor provide high fidelity voltage and current monitoring
    • Future firmware will power on each channel after a startup self-test, and power off the channel in case of any faults
    • 3.3V output for powering many Chainlink Driver boards
  • Flexible controller input power
    • USB power from the T-Display works by default, though external power is recommended for larger displays
    • Regulated 5V can be connected directly to the screw terminals, or
    • if you are using an always-on 12V PSU without a master relay, you can install a buck module and power the board from 12V using the 7-28V screw terminals

View the interactive BOM/placement tool

Electrical tools

Chainlink Driver Tester

This is not likely to be useful unless you're assembling a very large display, but the Chainlink Driver Tester is a complete testbed for Chainlink Driver boards as they come assembled by the PCBA fabricator.

This is currently under very active development. It is untested and does not have firmware yet.

Key (planned) features:

  • TTGO T-Display (ESP32) controller, screen, and buttons for controlling tests and reporting results
  • Pogo-pins for all connectors on the Chainlink Driver board-under-test (screw terminals, sensor pin headers, and motor connectors)
  • 12V switch to supply motor power to the board-under-test, with automotive fuse and INA219 voltage/current monitoring (based on the Chainlink Base channel switch design)
  • Separate 3.3V supply for the board-under-test, protected with a polyfuse, should avoid browning out the Tester's MCU in case of 3.3V short-circuits
  • Motor and sensor connections are broken out from the pogo-pins for a full closed-loop hardware test
  • Screw terminals to chain another Chainlink Driver (not under test) to validate that chained outputs work on the board-under-test
  • MCP23017 GPIO expander with 8 GPIO pins exposed via headers for future expansion inputs
  • Large cutout allows a barcode scanner or camera to be aimed at the bottom of the board-under-test for tracking serial numbers.
  • Buzzer option for audible pass/fail feedback

View the interactive BOM/placement tool

Rendering

The mechanical and electrical design renderings and links above are automatically updated on every commit with the latest rendering. See this blog post for more details on how that works: Automated KiCad, OpenSCAD rendering using Travis CI.

The PCB layout can be rendered to an svg or png (seen above) by running electronics/scripts/generate_svg.py file.kicad_pcb. This uses KiCad's Python scripting API to render several layers to individual svg files, manipulates them to apply color and opacity settings, and then merges them to a single svg. For additional details, see this blog post: Scripting KiCad Pcbnew exports.

For reviewing the design, a pdf packet with copper, silkscreen, and drill info can be produced by running electronics/scripts/generate_pdf.py file.kicad_pcb.

Gerber files for fabrication can be exported by running electronics/scripts/generate_gerber.py file.kicad_pcb. This generates gerber files and an Excellon drill file with Seeed Studio's naming conventions and produces a .zip which can be sent for fabrication.

EESchema isn't easily scriptable, so to export the schematic and bill of materials electronics/scripts/export_schematic.py and export_bom.py start an X Virtual Frame Buffer (Xvfb) and open the eeschema GUI within that virtual display, and then send a series of hardcoded key presses via xdotool to interact with the GUI and click through the dialogs. This is very fragile but seems to work ok for now. For additional details, see this blog post: Using UI automation to export KiCad schematics.

Code

Firmware

The driver firmware is written using Arduino and is available at arduino/splitflap/Splitflap/Splitflap.ino.

The firmware implements a closed-loop controller that accepts letters as input over USB serial and drives the stepper motors using a precomputed acceleration ramp for smooth control. The firmware automatically calibrates the spool position at startup, using the hall-effect magnetic sensor, and will automatically recalibrate itself if it ever detects that the spool position has gotten out of sync. If a commanded rotation is expected to bring the spool past the "home" position, it will confirm that the sensor is triggered neither too early nor too late; otherwise it will search for the "home" position to get in sync before continuing to the desired letter.

Computer Control Software

The display can be controlled by a computer connected to the Arduino over USB serial. A basic python library for interfacing with the Arduino and a demo application that displays random words can be found in the software directory.

Commands to the display are sent in a basic plain-text format, and messages from the display are single-line JSON objects, always with a type entry describing which type of message it is.

When the Arduino starts up, it sends an initialization message that looks like:

{"type":"init", "num_modules":4}

The display will automatically calibrate all modules, and when complete it will send a status update message:

{
    "type":"status",
    "modules":[
        {"state":"normal", "flap":" ", "count_missed_home":0, "count_unexpected_home":0},
        {"state":"sensor_error", "flap":"e", "count_missed_home":0, "count_unexpected_home":0},
        {"state":"sensor_error", "flap":"e", "count_missed_home":0, "count_unexpected_home":0},
        {"state":"sensor_error", "flap":"e", "count_missed_home":0, "count_unexpected_home":0}
    ]
}

(Note: this is sent as a single line, but has been reformatted for readability above)

In this case the Arduino was programmed to support 4 modules, but only 1 module is connected, so the other 3 end up in "sensor_error" state. More on status updates below.

At this point you can command the display to show some letters. To do this, send a message to the Arduino that looks like this:

=hiya\n

The = indicates a movement command, followed by any number of letters, followed by a newline. You don't have to send the exact number of modules - if you send fewer letters than modules, only the first N modules will be updated and the remainder won't move. For instance, you could send =a\n as shorthand to only set the first module (even if there are 12 modules connected). Any letters that can't be displayed are considered a no-op for that module.

Whenever ALL modules come to a stop, the Arduino will send a status update message (just like the one following initialization, shown above). Here's what the fields mean in each module's status entry:

  • state - normal indicates it's working as intended, sensor_error indicates the module can't find the home position and has given up trying (it will no longer respond to movement commands until told to recalibrate - see below). panic indicates the firmware detected a programming bug and has gone into failsafe mode (it will no longer respond to movement commands and requires a full reset of the Arduino to recover - should never happen).
  • flap - which letter is shown by this module
  • count_missed_home - number of times the module expected to pass the home position but failed to detect it. If this is non-zero, it indicates either a flaky sensor or that the motor may have jammed up. The module automatically attempts to recalibrate whenever it misses the home position, so if this number is non-zero and the module is still in the normal state, it means the module successfully recovered from the issue(s). However, if this number keeps going up over continued use, it may indicate a recurrent transient issue that warrants investigation.
  • count_unexpected_home - number of times the module detected the home position when it wasn't supposed to. This is rare, but would indicate a flaky/broken sensor that is tripping at the wrong time. Just like with missed home errors, unexpected home errors will cause the module to attempt to recalibrate itself.

If you want to make all modules recalibrate their home position, send a single @ symbol (no newline follows):

@

This recalibrates all modules, including any that were in the sensor_error state; if recalibration succeeds they will return to the normal state and start responding to movement commands again.

License

I'd love to hear your thoughts and questions about this project, and happy to incorporate any feedback you might have into these designs! Please feel free (and encouraged) to open GitHub issues, email me directly, reach out on Twitter, and get involved in the open source development and let's keep chatting and building together!

The vast majority of this project is licensed under Apache v2 (see LICENSE.txt for full details).

Copyright 2015-2018 Scott Bezek and the splitflap contributors

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Comments
  • Split Flap Card Design and Mass Production

    Split Flap Card Design and Mass Production

    Github Splitflap Characters.pdf

    This is more of a mental note for when I would make the jump to mass produce the split flaps.

    I am intending on making a good number of these modules at work and is an understatement to say that I am not looking forward to making the cards. I have inquired at some vendors. I am waiting to hear back on all quotes, but ballpark seems to be ~$30/set @ 100 sets, ~$15/set @ 300 sets. As these modules are still experimental, I don't think it would make sense to buy these right now. That being said, I need to have these made sometime this year.

    The main thing on my mind are these: -Number of characters in a set (10, 40, 48, 52, 60 etc) -Overall card shape (notch in the side like current design, or rectangle with just 1.5mm tabs sticking out) -Overall card dimensions (size of bezel opening, spacing between spools, tab size, use of 3.2mm MDF)

    Attempting to guess the future, I presume the spirit of being able to make these cards at home with only a badge punch and cutting jigs will mean the overall card dimensions stay the same. As far as guessing the number of characters in a set and card shape I see two paths:

    1. I would opt to shift to a rectangle with tab sticking out design so that I wouldn't have to worry about spool sizes affecting the notch size and redesigning the front bezel (fit opening to new card width, add notch for spool to stick through) which wouldn't be a big deal. Would increase the perceived gap between characters.

    2. Keep the current design shape and design the notch for a 60-character spool. Would maintain the current perceived gap between characters.

    opened by qwertyaardvark 19
  • Refactor to make SCAD files more modular

    Refactor to make SCAD files more modular

    This is NOT ready for merge, but instead an attempt to break up the monolithic (~1000+ SLOC) splitflap.scad into separate modules and elicit feedback for this refactor.

    There should be 0 functional change to splitflap.scad, just code moved around.

    The goal for this refactor is to make the scad files more "readable" for beginners to the project and to be able to split the parts into separate files so that we could iterate on them easier for 3d-printing.

    For example, see 3d/splitflap_3dprinter.scad which has a simplified version of the parts needed to 3d-print. This file could later be expanded to include the frame, which might vary depending on the material or design (e.g. without the captive nuts)

    Again, this PR is just to get feedback if we should proceed down this path or if the value isn't there.

    opened by lastcoolnameleft 14
  • PCB Tweaks

    PCB Tweaks

    Changes + Additions:

    • Changed VIN jumper from 2 position to 3 position, to allow for storing the jumper on the board
    • Added an LED solder disconnect jumper (NC), in case the user wants to disable the always-on LEDs

    Improvements:

    • Rotated capacitor C1 so that its polarity matches C3
    • Trimmed + added a notch indicator to the 74HC165 footprint's silkscreen
    • Rotated all silkscreen text vertically for easier readability
    • Added silkscreen outlines to Arduino ports on bottom

    Bugfixes:

    • Cleaned up excess / overlapping tracks (from grid / snapping issues)
    • Sensor: fixed PCB edge cut continuity
    • Sensor: moved commit silkscreen off of pads

    There should be no changes to the core PCB functionality.

    This changes the BOM ever-so-slightly, as the optional 2-pin VIN header is now 3-pin. Although per the ordering instructions it still requires a 1x40 header to be cut up.

    opened by dmadison 13
  • Documentation on ordering parts needs improvement

    Documentation on ordering parts needs improvement

    As @mflmartin helpfully highlighted to me, the documentation around ordering the electronics components is somewhat outdated, and has a number of assumptions baked in that may not be obvious.

    I see two main issues:

    • The relationship between the number of modules, the number of controller boards, the number of sensor boards, and the amount of supporting hardware needed (Arduinos, power supply amperage, etc) is unclear. This needs its own wiki page, ideally with supporting diagrams of different example cases (HELP WANTED for good looking vector graphics for this!)
    • the electronics BOM is auto-generated, but doesn't clearly explain what components it includes and whether all of them are actually necessary. I.e. it currently includes all components that might be needed for either an A, B, or C variant controller board (when in reality you only need some subset, depending on which variant you're making) and enough parts for 4 sensor boards (which you may not need if you're making fewer than 4 modules). It may make sense to simplify things to 2 variants: a "shield" ("A") and "expansion" (currently "B") variant. It may also make sense to either auto-generate an Excel spreadsheet with formulas for calculating part quantities based on # of modules, # of "shield" variant boards, and # of "expansion" variant boards, or else maybe create a BOM wizard on the project website to do those calculations based on the generated .csv?
    type: enhancement help wanted area: documentation 
    opened by scottbez1 12
  • Thickness Fixes (+ 3.0 default)

    Thickness Fixes (+ 3.0 default)

    This PR fixes a few issues relating to panel thickness:

    • Spool width now accounts for flap width. If the calculated spool width is smaller than the flap width, the enclosure width and front opening do not shrink further (ceb3664). This also comments out the legacyAssert for spool width which is no longer needed.
    • Flap notch height and depth are now static and reflect the die-cut flap dimensions (773f4df). The flap height can be set back to auto with the flap_notch_height_auto flag.
    • Enclosure side bolts are now positioned properly for all thicknesses (e87928c)
    • The enclosure vertical inset (distance between top/bottom of front and top/bottom pieces) now has a minimum value to prevent the bolt heads and nut edges from extending past the bounds of the enclosure at thinner thicknesses (ee7e685)
    • Sets the default thickness to 3.0, matching Ponoko's current MDF availability (8172e21). Tentatively closes #76

    Comparison, Standard Thickness (master / 8172e21):

    sf-thickness-comp

    (Take the tab edges of the flaps with a grain of salt, they're small features that render unevenly depending on the camera position)

    Comparison, 1.0 mm Front (master / 8172e21):

    sf-thickness-1-mm-comp

    Comparison, 1.0 mm Rear (master / 8172e21)

    sf-thickness-1-mm-rear-comp

    opened by dmadison 11
  • Peak Amperage & Overall Power Consumption

    Peak Amperage & Overall Power Consumption

    While receiving the parts for the project, I came across the power supply and I was wondering how many modules the 12V-6A power supply called out in the readme could safely support. Has someone measured the peak amount of amperage and total amount of energy the modules use when a module moves 39 characters forward (worst case regular operation, for example from 'B' to 'A')?

    I am still waiting for my PCBs to arrive from seeedstudio, and would be interested in seeing the energy requirements of an individual module so that I could later extrapolate power requirements for large boards or determine the feasibility of a indoor/outdoor solar powered split flap display.

    type: question 
    opened by qwertyaardvark 11
  • SplitFlap Display has three strange behaviors

    SplitFlap Display has three strange behaviors

    Hello Scott, It's been a long time and I would like to finish this project started more than a year ago. I have completed the construction of a module and mechanically it should be ok, I have also done some tests with the sensor and it is correctly detected but I still cannot see the letter I want on my display. In this short video I show the three problems I'm having:

    https://youtu.be/BHOUhOT_epA

    • 1 error: often when I select a letter to view the display freezes after 2 steps for no reason
    • 2 error: if I try to display a character that is too far from the starting point (for example I switch from A to Z), the display makes a complete revolution and returns to A, but no errors are reported on the console
    • 3 error: a few times when I recalibrate by entering the @ the display arrives at the home point and adds a micro step that changes the initial letter

    I would be really grateful if you could help me complete this project.

    type: question 
    opened by daniele8808 9
  • ESP8266 support

    ESP8266 support

    I've heard interest from a number of people about controlling a splitflap from wifi, and ESP8266 is the obvious default choice. It would be cool to see what's needed to get the code up and running on ESP8266 rather than an Uno, ideally with no hardware changes to the control board (at least initially; long term I could see a new revision of the control board that either takes an ESP board directly or plugs into something like a wemos d1 mini).

    I spent a little time a while ago and got basic motor output working over hardware spi, but I recall having issues getting the sensor input working correctly over hardware spi but didn't investigate further. I also forget if I was running the control board at 3.3v or 5v.

    In any case, opening this issue to centralize discussions around progress or investigations (cc @johnboiles)

    help wanted area: software priority: high 
    opened by scottbez1 9
  • Large Display (>12 characters)

    Large Display (>12 characters)

    Any thoughts on scaling beyond a single Arduino? Would a Mega or Duo board allow for more controllers per micro-controller?

    My initial thought would be to use a RasberryPi to daisy chain each Uno's 12 characters and also serve as a small web server for remotely controlling a large display. I'm going to start with connecting 4 controllers (16-char) and two Uno's so I can start working on the Pi. If successful, I plan to integrate it with my Google home and scale up to something big enough (100+ char) to display Tweets, song titles, news headlines, and stock tickers on command.

    type: question area: electronics 
    opened by barkerb1 8
  • Update rough costs section

    Update rough costs section

    I am looking to build two split flap units in the coming month (and many more in the near future) so I figured I'd help fill out this section and work on documentation in the wiki.

    opened by qwertyaardvark 7
  • ESP32 support

    ESP32 support

    As referenced in https://github.com/scottbez1/splitflap/issues/55 , the ESP32 is the successor for the ESP8266.

    One of the issues is that there isn't a board like the Wemos D1 mini that is as ubiquitous. An alternative is to create a board to solder the ESP32 directly, but that would require a 3.3V regulator as well as a programmer chip and a USB port.

    type: enhancement area: electronics area: software 
    opened by DrSkunk 6
  • Bump minimatch from 3.0.4 to 3.1.2 in /software/chainlink/js/splitflapjs

    Bump minimatch from 3.0.4 to 3.1.2 in /software/chainlink/js/splitflapjs

    Bumps minimatch from 3.0.4 to 3.1.2.

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 0
  • Bump minimatch from 3.0.4 to 3.1.2 in /software/chainlink/js/example

    Bump minimatch from 3.0.4 to 3.1.2 in /software/chainlink/js/example

    Bumps minimatch from 3.0.4 to 3.1.2.

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 0
  • News Headlines from a API?

    News Headlines from a API?

    Hello! I am a bored High-School student and I came across this project and I thought It would be a fun thing to make over the summer and could be pretty easy with the detailed assembly instructions. I wanted to make the split flaps display News headlines from the NYT API. Unfortunately, I have no Idea how I would do this as I am more of a mechanical guy. I found code on this repository that grabs whether info from an API and I tried to figure out what goes into this code and what it produces so I could change it to fetch headlines form the NYT API but I seem to be very unqualified. Im sorry if this is in the wrong spot, I am new to Github.

    opened by someone224466 0
  • Bump protobufjs from 6.11.2 to 6.11.3 in /software/chainlink/js/splitflapjs-proto

    Bump protobufjs from 6.11.2 to 6.11.3 in /software/chainlink/js/splitflapjs-proto

    Bumps protobufjs from 6.11.2 to 6.11.3.

    Release notes

    Sourced from protobufjs's releases.

    v6.11.3

    6.11.3 (2022-05-20)

    Bug Fixes

    Changelog

    Sourced from protobufjs's changelog.

    6.11.3 (2022-05-20)

    Bug Fixes

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 0
  • Arduino Not Working

    Arduino Not Working

    Hi All, I have a 6 module set up that works fine when I use PlatformIO. I am really struggling to program the functionality I want since I can't figure out the PIO environment so am hoping to just use the Arduino IDE. The code directly downloaded from github, unedited (except to say 6 modules), and uploaded to the board does not work right. The first 3 splitflaps work, the 4th one rotates but misses the sensor, even though it says "normal" in the serial output, the 5th and 6th never rotate and give a "sensor error" in serial.

    I can send messages and the first 3 flaps work fine. I know it's nothing mechanical since it all works on PIO. I know the documentation says limited support for Arduino IDE but it mentioned it said to open a git issue if I saw any issues so here I am.

    Thanks!

    opened by josecardona7 1
  • Update package.json

    Update package.json

    I was getting error messages to add @types/node as a dev dependency when running the typescript build. Might be worth adding to package.json file OR could be something I'm doing wrong....

    opened by bflatau 0
Releases(releases/sensor/v1.1)
A DiY holiday project to demonstrate how you can send data from adafruitIO cloud to a balena edge device

holiday-star balena ❤️ adafruitIO Introduction A DiY holiday project to demonstrate how you can send data from adafruitIO cloud to a balena edge devic

Ayan Pahwa 3 Dec 20, 2021
An IoT Trivia app that shows you how to take a JSON web API such as the opentdb.com API and stream and display it on a FeatherS2 in an OLED display.

CircuitPython IoT Trivia ESP32-S2 OLED Version An IoT Trivia app that shows you how to take a JSON web API such as the opentdb.com API and stream and

Kevin Thomas 1 Nov 27, 2021
Create a low powered, renewable generation forecast display with a Raspberry Pi Zero & Inky wHAT.

GB Renewable Forecast Display This Raspberry Pi powered eInk display aims to give you a quick way to time your home energy usage to help balance the g

Andy Brace 32 Jul 2, 2022
Minimal and clean dashboard to visualize some stats of Pi-Hole with an E-Ink display attached to your Raspberry Pi

Clean Dashboard for Pi-Hole Minimal and clean dashboard to visualize some stats of Pi-Hole with an E-Ink display attached to your Raspberry Pi.

Alessio Santoru 104 Dec 14, 2022
♟️ QR Code display for P4wnP1 (SSH, VNC, any text / URL)

♟️ Display QR Codes on P4wnP1 (p4wnsolo-qr) ?? QR Code display for P4wnP1 w/OLED (SSH, VNC, P4wnP1 WebGUI, any text / URL / exfiltrated data) Note: Th

PawnSolo 4 Dec 19, 2022
A dashboard for Raspberry Pi to display environmental weather data, rain radar, weather forecast, etc. written in Python

Weather Clock for Raspberry PI This project is a dashboard for Raspberry Pi to display environmental weather data, rain radar, weather forecast, etc.

Markus Geiger 1 May 1, 2022
A ch341dll Wrap is for using in Python 32bits windows to access I2C SPI and MDIO (by GPIO), and Demo with display PC sreen on OLED by i2c or SPI .

ch341dll_wrap_typcal_app A ch341dll Wrap is for using in Python 32bits windows to access I2C SPI and MDIO (by GPIO). In addition, I provided 3 Demo. I

null 13 Jan 2, 2023
Pi-hole with Inky pHAT ePaper display

Pi-hole with Inky pHAT ePaper display This is my Pi-hole with an ePaper display.

null 11 Sep 13, 2022
Python information display framework aimed at e-ink devices

My display, using a Raspberry Pi Zero W and Waveshare 6" e-paper hat infodisplay Modular information display framework aimed at e-ink devices. Built u

Niek Blankers 3 Apr 8, 2022
Python application, displaying currently played track from Spotify on OLED display connected via I2C

RaspberryPi Spotify OLED Display This application will display currently played track on SSD1306 OLED display connected to RaspberryPi. Displayed stuf

Wojciech Olech 2 Dec 30, 2021
Create (templateable) cameras that display qr codes in homeassistant

QRCam This custom component creates cameras displaying qrcodes. The QRCodes can be static or generated from templates. If you use a template as conten

Jannes Müller 5 Oct 6, 2022
To dynamically change the split direction in I3/Sway so as to split new windows automatically based on the width and height of the focused window

To dynamically change the split direction in I3/Sway so as to split new windows automatically based on the width and height of the focused window Insp

Ritin George 6 Mar 11, 2022
Pihole-eink-display - A simple Python script to display PiHole statistics on an eInk Display

Pihole-eink-display - A simple Python script to display PiHole statistics on an eInk Display

Mark McIntyre 64 Oct 11, 2022
DiY Oxygen Concentrator based on the OxiKit

M19O2 DiY Oxygen Concentrator based on / inspired by the OxiKit, OpenOx, Marut, RepRap and Project Apollo platforms. About Read about the project on H

Maker's Asylum 62 Dec 22, 2022
Hand tracking demo for DIY Smart Glasses with a remote computer doing the work

CameraStream This is a demonstration that streams the image from smartglasses to a pc, does the hand recognition on the remote pc and streams the proc

Teemu Laurila 20 Oct 13, 2022
DIY gravity falls cryptograms made with python

ciphers-cryptograms some diy code to implementing ciphers-cryptograms from gravity falls with python, it's fun tho Algorithm or ciphers list Caesar At

Muhammad Asthi Seta Ari Yuwana 3 Jun 26, 2022
MiniTorch - a diy teaching library for machine learning engineers

This repo is the full student code for minitorch. It is designed as a single repo that can be completed part by part following the guide book. It uses

null 1.1k Jan 7, 2023
A DiY holiday project to demonstrate how you can send data from adafruitIO cloud to a balena edge device

holiday-star balena ❤️ adafruitIO Introduction A DiY holiday project to demonstrate how you can send data from adafruitIO cloud to a balena edge devic

Ayan Pahwa 3 Dec 20, 2021
A basic DIY-project made using Python and MySQL

Banking-Using-Python-MySQL This is a basic DIY-project made using Python and MySQL. Pre-Requisite needed:-->> MySQL command Line:- creating a database

ABHISHEK 0 Jul 3, 2022
An IoT Trivia app that shows you how to take a JSON web API such as the opentdb.com API and stream and display it on a FeatherS2 in an OLED display.

CircuitPython IoT Trivia ESP32-S2 OLED Version An IoT Trivia app that shows you how to take a JSON web API such as the opentdb.com API and stream and

Kevin Thomas 1 Nov 27, 2021