Close
0%
0%

GPIO: Displaying currency exchange rate

This tutorial demonstrates the control of 7-segment LED indicators using a single Tibbit #00_1 and several shift register ICs.

Similar projects worth following
86 views
0 followers
7-segment indicators are reliable and cheap LED devices which can display decimal digits and some characters. Every segment of the indicator is monitored through an allocated input. To drive all these inputs from the LPTS, you need many wires (32 lines for a 4-digit display). A more pragmatic solution is to use shift registers.

Simply put, a shift register is a converter between parallel and serial interfaces. This tutorial uses 74HC595 — a very common 8-bit shift register. This IC is monitored by three lines (clock, data, and latch) and has eight outputs to drive one indicator. Shift registers can be daisy-chained to maximize the number of outputs. To drive such a chain, only three control lines are required.

The project uses four shift registers connected to four 7-segment indicators to print currency exchange rates granted by the fixer.io JSON API.

The app has a plain web interface for selecting the currency to be display

Onboard Software

  • Node.js V6.x.x (pre-installed during production)

External Services


GitHub Repository

Name: gpio-indicators

Repository page: https://github.com/tibbotech/gpio-indicators

Clone URL: https://github.com/tibbotech/gpio-indicators.git

Updated At: Tue Oct 18 2016

The Hardware

  • Configure the LTPS (see the Tibbit layout diagram below).
  • Assemble the shift register chain and 7-segment indicators in accordance with the wiring diagram below (wires connecting the 2nd, 3rd, and the 4th resistor blocks to their respective indicators are not shown).

Note: when the power is first applied the indicators may display a random pattern.

Node.js Application

  • The app utilizes the Request package to fetch data from fixer.io, the Express package to serve static files, and socket.io to enable the link between the onboard app and the web interface.
  • The app requests USD exchange rates for a number of currencies. Requests are performed every ten minutes. The rates at Fixer.io are updated daily, around 4 pm CET.
  • The USDEUR rate will be displayed on the indicators by default.
  • The App's web server listens on port 3000.

Web Interface

The web interface files can be found in the -/static folder.

  • The web interface app requests data from fixer.io independently from the onboard app.
  • The Angular toolset is utilized to display an exchange rates table.
  • The Socket.IO library is used to identify the board's status (the table is hidden if the board is offline) and send the currency data to the board.

To lear more, click here

  • 1 × Tibbit #10 (power supply)
  • 1 × #00_1 Tibbit (4 direct I/O Lines) Electronic Components / Misc. Electronic Components
  • 1 × Linux TPS3 (LTPS3) board
  • 1 × TBP3 enclosure Optionally
  • 1 × Tibbit #18 (power jack)

View all 9 components

  • 1
    Step 1

    Configuration and Installation

    git clone https://github.com/tibbotech/gpio-indicators.git
    cd gpio-indicators
    npm install .
  • 2
    Step 2
    • Launch:

    node rates
  • 3
    Step 3

    Controlling shift registers

    The code that controls 7-segment indicators can be found in /modules/indicate.js.

    Comments in the code explain how it works:

    const gpio = require("@tibbo-tps/gpio");
    
    class indicator {
        constructor(socket, length){
            this.length = length;
            this.digits = {
                1: [0,1,0,0,1,0,0,0],
                2: [0,0,1,1,1,1,0,1],
                3: [0,1,1,0,1,1,0,1],
                4: [0,1,0,0,1,0,1,1],
                5: [0,1,1,0,0,1,1,1],
                6: [0,1,1,1,0,1,1,1],
                7: [0,1,0,0,1,1,0,0],
                8: [0,1,1,1,1,1,1,1],
                9: [0,1,1,0,1,1,1,1],
                0: [0,1,1,1,1,1,1,0],
                N: [0,0,0,0,0,0,0,1], // Dash symbol
                B: [0,0,0,0,0,0,0,0] // Blank symbol
            };
    
            // Sets up pins
            this.dataPin = gpio.init(socket+"A");
            this.dataPin.setDirection("output");
            this.dataPin.setValue(0);
    
            this.clockPin = gpio.init(socket+"B");
            this.clockPin.setDirection("output");
            this.clockPin.setValue(0);
    
            this.latchPin = gpio.init(socket+"C");
            this.latchPin.setDirection("output");
            this.latchPin.setValue(0);
        }
    
        indicate(number){
            var inst = this;
    
            // Converts number to the array of signals to be sent
            const numberToSignals = function(number){
                var output =[];
                number
                    .toString()
                    .split("")
                    .forEach(function(current, index, array){
                        if(current !== "."){
                            var symbol = inst.digits[current];
                            if (symbol === undefined){
                                symbol = Array.from(inst.digits["N"])
                            }else if(array[index+1] === "."){
                                symbol = Array.from(symbol);
                                symbol[0] = 1;
                            }
                            output.unshift(symbol);
                        }
                    },[]);
    
                // crops number to the first "length" digits, if needed
                output = output.slice(-inst.length);
    
                // pads the number with spaces if it's shorter than 4 digits
                while (output.length < inst.length){
                    output.push(inst.digits["B"])
                }
    
                return output.reduce(function(prev, current){
                    return prev.concat(current)
                });
            };
    
            var signals = numberToSignals(number);
    
            // Sets ST_CP (latch) to LOW
            // This operation sets shift registers into "programming" mode.
            // When latch is LOW, shift register doesn't change output states,
            // but reads and "remembers" data from DS pin.
            inst.latchPin.setValue(0);
    
            signals.forEach(function(value){
                // sets value to be pushed into the register on DS pin
                inst.dataPin.setValue(value);
    
                // sets SH_CP (clock) to HIGH and then to LOW
                // on rising edge of the clock shift register reads state from DS pin, and prepares it for setting on Q0 output.
                // Each of the previously SET values will be shifted to the next pin.
                inst.clockPin.setValue(1);
                inst.clockPin.setValue(0);
            });
    
            // then all signals are sent, sets ST_CP (latch) to HIGH
            // If latch is HIGH, all the read values will be simultaneously set to the outputs.
            inst.latchPin.setValue(1);
        };
    }
    
    module.exports = indicator;


View all 3 instructions

Enjoy this project?

Share

Discussions

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates