Posts | Comments

Planet Arduino

A neat little hacker project that’s flying off the workbenches recently is the Arduboy. This tiny game console looks like a miniaturized version of the O.G. Game Boy, but it is explicitly designed to be hacked. It’s basically an Arduino board with a display and a few buttons, anyway.

[rv6502] got their hands on an Arduboy and realized that while there were some 3D games, there was nothing that had filled polygons, or really anything resembling a modern 3D engine. This had to be rectified, and the result is pretty close to Star Fox on a microcontroller.

This project began with a simple test on the Arduboy to see if it would be even possible to render 3D objects at any reasonable speed. This test was just a rotating cube, and everything looked good. Then began a long process of figuring out how fast the engine could go, what kind of display would suit the OLED best, and how to interact in a 3D world with limited controls.

Considering this is a fairly significant engineering project, the fastest way to produce code isn’t to debug code on a microcontroller. This project demanded a native PC port, so all the testing could happen on the PC without having to program the Flash every time. That allowed [rv] to throw out the Arduino IDE and USB library; if you’re writing everything on a PC and only uploading a hex file to a microcontroller at the end, you simply don’t need it.

One of the significant advances of the graphics capability of the Arduboy comes from exploring the addressing modes of the OLED. By default, the display is in a ‘horizontal mode’ which works for 2D blitting, but not for rasterizing polygons. The ‘vertical addressing mode’, on the other hand, allows for a block of memory, 8 x 128 bytes, that maps directly to the display. Shove those bytes over, and there’s no math necessary to display an image.

This is, simply, one of the best software development builds we’ve seen. It’s full of clever tricks (like simply not doing math if you’ll never need the result) and stuffing animations into far fewer bytes than you would expect. You can check out the demo video below.

With many LED projects—like clocks—you’ll want to use a diffuser to keep light somewhat even over a wide area. Diffusers, as their name implies, diffuse light, but what if one was to instead use it as the light source itself?

This clever timepiece from Zaphunk does just that, employing an array of UV LEDs to illuminate a photochromic face. In the case of the glowing screen, the material first shines in response to the lit LEDs, then stays ‘on’ after they turn off, showing four numbers and a colon. When the photochromic cover is in use, the filament instead changes color based on the LEDs. 

The clock is implemented with an Arduino Nano, an RTC module, and a heavily modified 8-digit 7-segment display, and triggered via the press of a button on top.

This clock uses a custom built 4-digit 7-segment display made from UV LEDs. In front of the display a screen is placed that consists either of phosphorescent (“glow-in-the-dark”) or photochromic material. A push button on the top lights up the UV display which then illuminates the screen for a few seconds so that it starts glowing or changes color which then slowly fades away.

This is a quick start guide for the Four Digit Seven Segment Display Module and Enclosure from PMD Way. This module offers a neat and bright display which is ideal for numeric or hexadecimal data. It can display the digits 0 to 9 including the decimal point, and the letters A to F. You can also control each segment individually if desired. 

Each module contains four 74HC595 shift registers – once of each controls a digit. If you carefully remove the back panel from the enclosure, you can see the pin connections:

four-digit-seven-segment-display-with-enclosure-from-pmdway

If you’re only using one display, use the group of pins at the centre-bottom of the board. From left to right the connections are:

  1. Data out (ignore for single display use)
  2. VCC – connect to a 3.3V or 5V supply
  3. GND – connect to your GND line
  4. SDI – data in – connect to the data out pin on your Arduino/other board
  5. LCK – latch – connect to the output pin on your Arduino or other board that will control the latch
  6. CLK – clock – connect to the output pin on your Arduino or other board that will control the clock signal

For the purposes of our Arduino tutorial, connect VCC to the 5V pin, GND to GND, SDI to D11, LCK to D13 and CLK to D12. 

If you are connecting more than one module, use the pins on the left- and right-hand side of the module. Start with the connections from your Arduino (etc) to the right-hand side, as this is where the DIN (data in) pin is located.

Then connect the pins on the left-hand side of the module to the right-hand side of the new module – and so forth. SDO (data out) will connect to the SDI (data in) – with the other pins being identical for connection. 

The module schematic is shown below:

four-digit-seven-segment-display-with-enclosure-from-pmdway

Arduino Example Sketch

Once you have made the connections to your Arduino as outlined above, upload the following sketch:

// Demonstration Arduino sketch for four digit, seven segment display with enclosure
// https://pmdway.com/collections/7-segment-numeric-leds/products/four-digit-seven-segment-display-module-and-enclosure
int latchPin = 13; // connect to LCK pin intclockPin = 12; // connect to CLK pin intdataPin = 11; // connect to SDI pin int LED_SEG_TAB[]={ 0xfc,0x60,0xda,0xf2,0x66,0xb6,0xbe,0xe0,0xfe,0xf6,0x01,0xee,0x3e,0x1a,0x7a,0x9e,0x8e,0x01,0x00}; //0 1 2 3 4 5 6 7 8 9 dp . a b c d e f off void setup() { //set pins to output so you can control the shift register pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); } void displayNumber(int value, boolean leadingZero) // break down "value" into digits and store in a,b,c,d { int a,b,c,d; a = value / 1000; value = value % 1000; b = value / 100; value = value % 100; c = value / 10; value = value % 10; d = value; if (leadingZero==false) // removing leading zeros { if (a==0 && b>0) { a = 18; } if (a==0 && b==0 && c>0) { a = 18; b = 18; } if (a==0 && b==0 && c==0) { a = 18; b = 18; c = 18; } if (a==0 && b==0 && c==0 && d==0) { a = 18; b = 18; c = 18; d = 18; } } digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[d]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[c]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[b]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[a]); digitalWrite(latchPin, HIGH); } void allOff() // turns off all segments { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, 0); shiftOut(dataPin, clockPin, LSBFIRST, 0); shiftOut(dataPin, clockPin, LSBFIRST, 0); shiftOut(dataPin, clockPin, LSBFIRST, 0); digitalWrite(latchPin, HIGH); } void loop() { for (int z=900; z<=1100; z++) { displayNumber(z, false); delay(10); } delay(1000); for (int z=120; z>=0; --z) { displayNumber(z, true); delay(10); } delay(1000); digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[14]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[13]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[12]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[11]); digitalWrite(latchPin, HIGH); delay(1000); digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[16]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[15]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[14]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[13]); digitalWrite(latchPin, HIGH); delay(1000); digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[0]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[1]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[2]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[3]+1); digitalWrite(latchPin, HIGH); delay(1000); digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[7]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[6]+1); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[5]); shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[4]); digitalWrite(latchPin, HIGH); delay(1000); }

After a moment you should see the display spring into action in the same way as in the demonstration video:

How does it work? 

First we define which digital output pins are used for latch, clock and data on lines four to six. On line eight we have created an array which contains values that are sent to the shift registers in the module to display the possible digits and letters. For example, the first – 0xfc – will activate the segments to display a zero, 0x7a for the letter C, and so on. 

From line 20 we’ve created a custom function that is used to send a whole number between zero and 9999 to the display. To do so, simply use:

void displayNumber(value, true/false);

where value is the number to display (or variable containing the number) – and the second parameter of true or false. This controls whether you have a leading zero displayed – true for yes, false for no. 

For example, to display “0123” you would use:

displayNumber(123, true);

… which results with:

four-digit-seven-segment-display-with-enclosure-from-pmdway-0123

or to display “500” you would use:

displayNumber(500, false);

… which results with:

four-digit-seven-segment-display-with-enclosure-from-pmdway-500

To turn off all the digits, you need to send zeros to every bit in the shift register, and this is accomplished with the function in the sketch called 

allOff();

What about the decimal point? 

To turn on the decimal point for a particular digit, add 1 to the value being sent to a particular digit. Using the code from the demonstration sketch to display 87.65 you would use:

 digitalWrite(latchPin, LOW);

 shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[5]);

 shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[6]);

 shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[7]+1); // added one for decimal point

 shiftOut(dataPin, clockPin, LSBFIRST, LED_SEG_TAB[8]);

 digitalWrite(latchPin, HIGH);

… which results with:

four-digit-seven-segment-display-with-enclosure-from-pmdway-87p65

In-depth explanation of how the module is controlled

As shown in the schematic above, each digit is controlled by a 74HC595 shift register. Each shift register has eight digital outputs, each of which control an individual segment of each digit. So by sending four bytes of data (one byte = eight bits) you can control each segment of the display. 

Each digit’s segments are mapped as follows:

7segmentdisplaymap

And the outputs from each shift register match the order of segments from left to right. So outputs 0~7 match A~G then decimal point. 

For example, to create the number seven with a decimal point, you need to turn on segments A, B, C and DP – which match to the shift register’s outputs 0,1,2,8. 

Thus the byte to send to the shift register would be 0b11100001 (or 225 in decimal or 0xE1 in hexadecimal). 

Every time you want to change the display you need to re-draw all four (or more if more than one module is connected) digits – so four bytes of data are sent for each display change. The digits are addressed from right to left, so the first byte send is for the last digit – and the last byte is for the first digit. 

There are three stages of updating the display. 

  1. Set the LCK (latch) line low
  2. Shift out four bytes of data from your microcontroller
  3. Set the LCK (latch) line high

For example, using Arduino code we use:

  digitalWrite(latchPin, LOW);

  shiftOut(dataPin, clockPin, LSBFIRST, 0b10000000); // digit 4

  shiftOut(dataPin, clockPin, LSBFIRST, 0b01000000); // digit 3

  shiftOut(dataPin, clockPin, LSBFIRST, 0b00100000); // digit 2

  shiftOut(dataPin, clockPin, LSBFIRST, 0b00010001); // digit 1

  digitalWrite(latchPin, HIGH);

This would result with the following:

4digit7segmentdisplaymoduletronixlabsbits

Note how the bytes in binary match the map of the digits and their position. For example, the first byte sent was for the fourth digit, and the segment A was turned on. And that’s all there is to it – a neat and simple display. 

This post brought to you by pmdway.com – everything for makers and electronics enthusiasts, with free delivery worldwide.

To keep up to date with new posts at tronixstuff.com, please subscribe to the mailing list in the box on the right, or follow us on twitter @tronixstuff.

 

As a gift for friends that operate tours of Prince William Sound in Alaska, maker ‘rabbitcreek’ decided to make a humongous (4’ diameter) tide clock, controlled by dual Arduino Nanos. 

One Nano operates the adorable—though very large—otter on the clock’s face via a servo and gear reduction setup that holds a kayak paddle to indicate high and low tides. The other board handles the unit’s RGB LED lighting, which shines the appropriate color to indicate the vast swings in daylight time of that region.

An RTC module for each Nano provides accurate timekeeping—thus proper tide and daylight indications—and a small monitor is used for maintenance tasks. It’s a brilliant build that is certain to delight residents and tourists to the area alike!

Michael Koopman wanted to learn piano. However, after finding this pursuit frustrating, he instead decided to assemble his own 3D-printed MIDI jammer keyboard, inspired by the AXiS-49 interface pad. 

His instrument is controlled via an Arduino Due, with 85 buttons arranged in a diagonal pattern. This allows for whole steps on the horizontal axis, fourths on one diagonal, fifths on the other diagonal, and octaves on the vertical axis. 

This configuration enables the device to be used in a variety of ways, and features an additional six buttons and four potentiometers to vary playing style, along with ¼ inch jacks for auxiliary inputs. 

As seen in the video below, while Koopman had a hard time with the piano, apparently that wasn’t case with his MIDI keyboard, as he’s able to play it beautifully—even using two at a time around 8:15!

In the early 1200s, Fibonacci introduced a series of numbers that now bear his name, starting with 0, then 1, and continuing on as the sum of the two preceding numbers. This gives values of 0, 1, 1, 2, 3, 5, 8, and so on, and after being prompted by a friend, “TecnoProfesor” decided to turn this numerical pattern into a clock.

The concept here is that instead of using the conventional 1-12 to display the time, this device uses blocks corresponding to Fibonacci numbers 1-5, with circular icons adding increments of 12 for minute and second values. 

It’s an interesting concept, somewhat akin to the world of binary or even word clocks. The build consists of an Arduino Mega and a DS3231 RTC module for control, a wood and methacrylate housing, and a number of programmable RGB LEDs to indicate numbers.

Nearly any car comes with the proper dashboard to get you from point A to point B, but what if you want something all your own displaying important stats? While there’s not a lot of technical info on the build, Jroobi’s MX5/Miata Arduino-based TFT cockpit project is sure to inspire, whether via the first or second iteration shown below.

The first version puts RPM and KPH values on coaxial sliders in the right circular display. That leaves the second round display for info such as what gear you’re in, along with auxiliary displays for extra data. The second splits up RPM and KPH between the main circles. It also features interesting light-up alerts in the middle, as well as a gauge similar to the first on the top. 

The first iteration—and presumably the second—includes a clever user interface setup, where a rotary encoder surrounds the existing trip reset button for brightness control while still preserving its reset ability.

How we see colors is an interesting concept, and as a conversation starter about the physics of color and sound, maker Marcin Poblocki created his own ‘Color Instrument.’

Poblocki’s device rotates a wheel of colors around under a TCS3200/TCS230 sensor via a continuous rotation-modded SG90 servo motor. An Arduino Nano then spits out the tone corresponding to the color it senses using a small speaker, allowing for simple songs to be produced according to hue arrangements. 

It’s a neat idea that could be taken in many different directions. At the very least, it would certainly spark conversation, perhaps questioning, as noted in the project write-up, why the color pink isn’t included in the natural light spectrum.

Inventor Artist Darcy Whyte wanted a drawing robot that was light enough to carry around, and could quickly produce drawings. Naturally, he turned to an Arduino Uno, along with a CNC shield and a trio of A4988 stepper drivers. These control a NEMA 8 and two NEMA17 stepper motors in a gantry-style artistic setup.

The build is able to drag a marker across a page, apparently varying pressure applied with the z-axis, and thus how much ink is applied. In another mode, a pen can be used, which wobbles back and forth to create volume when needed. 

Both methods, as seen in the clips below, can sketch a very recognizable—though certainly distinct—portrait of Marilyn Monroe, or presumably whatever other image you choose to program in.

Most pools feature a powered pump system to help filter out debris, but what if your water level gets too low? Pumps designed for ‘wet’ operation generally don’t work well when water isn’t present, so Luc Brun came up with an innovative monitoring solution dubbed “BluePump.”

His setup uses an Arduino Nano and an ACS712 sensor to observe both voltage and current, detecting the phase shift between the two. If this shift is too large, this indicates dry operation, and shuts down the pump via a relay until things are resolved. 

To complement this ability, BluePump also includes a temperature sensor, an RTC, and a Bluetooth module, allowing it to schedule cleanings as needed, or work under human control via a custom Android app.



  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook