Tag Archives: Pi4J

Raspberry Pi Helidon 14 segment display

How goes the battle?
2021/02/22

This post is to show how I created a Helidon demo with a Raspberry PI. A simple web application to control a 14 segments display. This is another blog about Java on Raspberry PI.

Originally named J4C (Java for Cloud), Helidon was designed to be simple and fast, and the framework supports two programming models for writing microservices: Helidon SE and Helidon MP. Helidon SE is designed to be a microframework that supports the reactive programming model, it features three core APIs to create a microservice; a web server, configuration, and security. Helidon MP, on the other hand, is an Eclipse MicroProfile runtime that allows the Jakarta EE community to run microservices in a portable way; supports the MicroProfile 1.1 specification for building microservices-based applications.
But in both cases, a Helidon microservice is a Java SE application that starts a tinny HTTP server from the main method.


Helidon architecture


Microservices frameworks categories


Helidon 2.0 adds significant improvements for both Helidon SE and Helidon MP programming styles

Fun Facts
Helidon is a Greek word for swallow, a type of bird that according to Wikipedia has “a slender, streamlined body and long pointed wings, which allow great maneuverability and very efficient flight”. Perfect for darting through the clouds.

Idea

A simple Helidon example that shows a 14 segments display and control in real-time a real one with a Raspberry Pi 3 B.

I have the “5421AG” model. 14 segments display – 5421AG

The PI4J uses a different GPIO number.

Note: Pi4J (by default) uses an abstract pin numbering scheme to help insulate software from hardware changes. Pi4J implements the same pin number scheme as the Wiring Pi

http://wiringpi.com/pins/

PIN 11 -> GPIO 11
PIN16 -> GPIO 25

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
    static Routing createRouting() {
        List<Class<? extends Encoder>> encoders = Collections.singletonList(UppercaseEncoder.class);

        return Routing.builder()
                .register("/rest", component)
                .register("/websocket",
                        TyrusSupport.builder().register(
                                ServerEndpointConfig.Builder.create(MessageBoardEndpoint.class, "/board")
                                        .encoders(encoders).build())
                                .build())
                .register("/web", StaticContentSupport.builder("/WEB").build())
                .build();
    }

Disclaimer – I use the same CSS that I used in my Quarkus Qute example and I started this demo using this WebSocket sample

You can get the full code on my GitHub.

Links

https://helidon.io

https://github.com/oracle/helidon

https://www.youtube.com/channel/UChg00-uTTrCMmPsuzUNaZsA

https://medium.com/helidon

https://twitter.com/helidon_project

https://www.jetbrains.com/help/idea/helidon.html

https://microprofile.io/

Raspberry Pi Vert.X web potentiometer

How’s the form?
2021/01/15

After I wrote my motivation resolutions post I came with the idea that it is possible to do a lot of Raspberry Pi projects without a wait or by any new component.
“Invest your time before you invest your money and build something before you buy the component.”
Just create a virtual one.

For example, If you don’t have a 7 segment display you can follow this;
If you don’t have an 8×8 Led Matrix you can follow this and so on.

You can go ahead and use this idea to start your project without waiting more time and without buying anything.

Today I want to show a way to play with a potentiometer.

From Wikipedia
A potentiometer is a three-terminal resistor with a sliding or rotating contact that forms an adjustable voltage divider. If only two terminals are used, one end and the wiper, it acts as a variable resistor or rheostat.

From Google
An instrument for measuring an electromotive force by balancing it against the potential difference produced by passing a known current through a known variable resistance.

From Youtube

And More
potentiometers basic principles

Idea

A simple web application that I can use as a potentiometer.

This time I decided to do it with Vert.X.

Vert.x is an open-source, reactive and polyglot software development toolkit from the developers of Eclipse. Vert.x is a tool-kit for building reactive applications on the JVM
It is called polyglot due to its support for multiple JVM and non-JVM languages like Java, Groovy, Ruby, Python, and JavaScript.

Being reactive, verticles remain dormant until they receive a message or event. Verticles communicate with each other through the event bus. The message can be anything from a string to a complex object. Message handling is ideally asynchronous, messages are queued to the event bus, and control is returned to the sender. Later it’s dequeued to the listening verticle. The response is sent using Future and callback methods and with that, I can create something that calls the REST several times in a sequence without care about the answer and with no blocks.

If I use setPwm(), my LED can be any value between 0 and 100, and using an input range will only call one time to change the value. This will jump the value from current to select and not will create a potentiometer style.

But I can add some CSS style and create a knob and simulate a real potentiometer. Now I can call my REST interface for each value and simulate a real use of a potentiometer.

I can combine this with my Duke robot and control the Duke’s arm.
I can combine it with my Christmas hats and create a nice fade effect.

I can do a simple Led example.

Code

I just used the Vert.X web start hello world example.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    private void changePwmValue(RoutingContext routingContext) {
        String range = routingContext.pathParam("id");
       
        System.out.println(range); //just to see calls
       
        final GpioController gpio = GpioFactory.getInstance();
        Gpio.pwmSetMode(Gpio.PWM_MODE_MS);
        Gpio.pwmSetRange(100);
        Gpio.pwmSetClock(500);
       
        GpioPinPwmOutput led01 = gpio.provisionSoftPwmOutputPin(RaspiPin.GPIO_15, "LeftGreen");
        led01.setPwm(Integer.parseInt(range));

        routingContext.response()
                .putHeader("content-type", "application/json")
                .setStatusCode(200)
                .end(Json.encodePrettily(range));
    }

Disclaimer – I got the CSS from here

You can get the full code on my GitHub.

Links

https://vertx.io/

https://github.com/eclipse-vertx/vert.x

https://passive-components.eu/resistors-potentiometers-basic-principles/

https://pi4j.com/

Raspberry Christmas Hat

What’s the story Rory?
2020/12/24

Today I want to show some Christmas project ideas using Hats. Yes, another blog about Raspberry PI.

Thanks to their GPIO headers, most Pi computers can connect to devices called HATs, which stands for Hardware Attached on Top.

Theses are the Hats that I have and they came from ThePiHut

Christmas Tree Programmable KitLink

I think this hat comes in 3 different sets, one just with white LEDs, one with just red LEDs and one with mixed white and red LEDs and you can find the Pre-soldered version as well.
From the Python API you can get the GPIO numbers to use with PI4j

SnowPiLink

The SnowPi is a discontinued item, but you can find it in ThePiHut.
From the Python API you can get the GPIO numbers to use with PI4j

During 2020 there was another successful Kickstarter project for the SnowPi RGB. This is a new version of the Snowman. There is no soldering required and it now has color NeoPixels instead of single color LEDs.

3D Xmas Tree for Raspberry PiLink

After a while, they release an RGB version as well. Like all the others you can find the Pre-soldered version as well.
From the code sample, you can get the GPIO numbers to use with PI4j

Raspberry Pi Christmas Tree StarLink

From the Python API you can get the GPIO numbers to use with PI4j

The idea here is that all hats are just boards with some LEDs, and this makes the project like an electronics project for blinking LEDs.
We can use the PWM idea, “Pulse Width Modulation” that I already explained here, but let me explain from the LEDs perspective.

From Wikipedia

The term duty cycle describes the proportion of ‘on’ time to the regular interval or ‘period’ of time; a low duty cycle corresponds to low power because the power is off for most of the time. Duty cycle is expressed in percent, 100% being fully on. When a digital signal is on half of the time and off the other half of the time, the digital signal has a duty cycle of 50% and resembles a “square” wave. When a digital signal spends more time in the on state than the off state, it has a duty cycle of >50%. When a digital signal spends more time in the off state than the on state, it has a duty cycle of <50%. Here is a pictorial that illustrates these three scenarios.

You can find examples and samples for all Hats in Python, but because I support the #JavaOnRaspberryPi idea, let’s see how to use them with Java.
Remember to use the hashtag #JavaOnRaspberryPi on Twitter to show the world Raspberry Pi with Java.

PI4J
You can check my post to start with PI4J but for these hats what you need to understand is the Pwm Example

1
2
3
com.pi4j.wiringpi.Gpio.pwmSetMode(com.pi4j.wiringpi.Gpio.PWM_MODE_MS);
com.pi4j.wiringpi.Gpio.pwmSetRange(100);
com.pi4j.wiringpi.Gpio.pwmSetClock(500);

The idea is that “setPwm()” can be 0, to turn off, 100, to turn on and any value between 0 and 100 to create a fade.

1
2
3
setPwm(0)
setPwm(100)
setPwm(value);

Now you can not just turn on and off, but you can also pulse, blink and add a fade effect.

Here is my forest project from 2018.

Of course, you can do some Christmas ideas with any other hat.

Sensehat http://www.igfasouza.com/blog/sense-hat/

You can create your Christmas tree using my Micronaut example. GitHub Or just using this.

E-ink display

I know that 4tronix has some Christmas Micro Bit hats and people did some hack around to use with a Raspberry PI, But If you know any other Christmas Hat, please let me know in the comments.

As a good developer, I always get confused about Christmas and Halloween as 25 Dec is equal to 31 Oct

PumpkinPi https://thepihut.com/products/halloween-pumpkinpi-for-raspberry-pi

Some other Christmas ideas
https://www.raspberrypi.org/blog/tag/christmas/

Raspberry Pi Servo Java Duke Robot

What’s up?
2020/10/12

This post is to show how I created a Java Duke Servo demo with a Raspberry Pi. This is another blog about Java on Raspberry Pi.

Interfacing a Servo Motor with Raspberry Pi is an interesting topic as Servo Motors are the main components of a Robot and with the help of Raspberry Pi, you can have endless opportunities in Robotics.

Because today we celebrate children’s day in Brazil, I came with the idea to show this simple robot example using a servo motor and a Raspberry Pi. And nothing better than a Java Duke servo demo to show Java on Raspberry Pi.

Components

  • SG90 Micro-servo motor
  • Jumper wires (generic)
  • Raspberry Pi 3b or Arduino

Idea

Using a cardboard and Duke image to create a servo demo where Duke moves his arm.


I used this image to create my demo.

Control a Servo Motor

To control a Servo Motor, you need to use a technique called Pulse Width Modulation or PWM. In PWM technique, you will be sending a pulse of variable width and the position of the Servo Motor’s shaft will be set by the width or length of the Pulse.

Nice “Pulse Width Modulation” explanation here

The frequency of the PWM signal is a fixed value and is dependent on the type of Servo Motor.
At 50Hz i.e. a period of 20ms, the minimum pulse width is 1ms and the maximum pulse width is 2ms. Most servo motors can have a swept area of 180 degrees i.e. 90 degrees on either side of the neutral position.

When the pulse width of the PWM Signal is 1ms, the position of the servo is the left. The Duty Cycle of this position is (1ms/20ms) x 100 = 5%.

Similarly, for pulse widths of 1.5ms and 2ms, the position of the servo is middle (with a duty cycle of 7.5%) and far right (with a duty cycle of 10%).

  • so for 50hz, one frequency is 20ms
  • duty cycle for 0 degree = (1/20)*100 = 5%
  • duty cycle for 90 degree = (1.5/20)*100 = 7.5%
  • duty cycle for 180 degree = (2/20)*100 = 10%

Note: Be aware here that you need to test and check your servo. You might need to calibrate this number for you.

Schematics

I’m using the SG90 servo motor and you can check the Datasheet here.

The Tower Pro SG90 Servo Motor Consists of three Pins: PWM (Orange or Yellow), VCC (Red), and GND (Brown). The VCC and GND pins must be connected to +5V and GND of the power supply.

PWM or Signal Pin of the Servo Motor must be connected to the PWM Output of the Controller (Raspberry Pi). Based on the width of the Pulses from the PWM signal, the angle of the Servo Motor’s shaft will vary.

1ms pulse for 0 degree (LEFT)
1.5ms pulse for 90 degree (MIDDLE)
2ms pulse for 180 degree (RIGHT)

PI4J

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinPwmOutput;
import com.pi4j.io.gpio.Pin;
import com.pi4j.io.gpio.RaspiPin;
import com.pi4j.util.CommandArgumentParser;


public class TestPwmServoMotor {

    public static void main(String[] args) throws InterruptedException {
        pwm(args);
    }

    /**
     * @param args
     * @throws InterruptedException
     */

    public static void pwm(String[] args) throws InterruptedException{

        final GpioController gpio = GpioFactory.getInstance();

        Pin pin = CommandArgumentParser.getPin(
        RaspiPin.class,    
        RaspiPin.GPIO_00,  
        args);            
        GpioPinPwmOutput pwm = gpio.provisionSoftPwmOutputPin(pin);
        pwm.setPwmRange(100);

        int sleep = 1000;
        for(int i = 0 ;i<10;i++){
             pwm.setPwm(25);
            System.out.println("PWM rate is: " + pwm.getPwm());
            Thread.sleep(sleep);

            pwm.setPwm(15);
            System.out.println("PWM rate is: " + pwm.getPwm());
            Thread.sleep(sleep);

            pwm.setPwm(6);
            System.out.println("PWM rate is: " + pwm.getPwm());
            Thread.sleep(sleep);
        }
        gpio.shutdown();        
        System.out.println("pwm end");

    }
}

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import RPi.GPIO as GPIO
import time


control = [5,5.5,6,6.5,7,7.5,8,8.5,9,9.5,10]
servo = 22
GPIO.setmode(GPIO.BOARD)
GPIO.setup(servo,GPIO.OUT)
p=GPIO.PWM(servo,50)
p.start(2.5)

try:
       while True:
           for x in range(11):
             p.ChangeDutyCycle(control[x])
             time.sleep(0.03)
             print x
           
           for x in range(9,0,-1):
             p.ChangeDutyCycle(control[x])
             time.sleep(0.03)
             print x
           
except KeyboardInterrupt:
    GPIO.cleanup()

Arduino

And of course, you can do this demo with an Arduino as well.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <Servo.h>


Servo servo

void setup() {
  servo.attach(9);
 
}
void loop() {
  servo.write(0);
  delay(500);
  delay(10000);
  servo.write(90);
  delay(500);
  delay(10000);
  servo.write(180);
  delay(500);
  delay(10000);
  servo.write(90);
  delay(500);
  delay(10000);
  servo.write(0);
  delay(500);
  delay(10000);
}

Results

The next steps are to create a code that transforms text into the flag language

Links

https://pi4j.com/1.2/index.html

https://github.com/Pi4J/pi4j

http://www.ee.ic.ac.uk/pcheung/teaching/DE1_EE/stores/sg90_datasheet.pdf

https://en.wikipedia.org/wiki/Pulse-width_modulation

https://www.electronics-tutorials.ws/blog/pulse-width-modulation.html

https://en.wikipedia.org/wiki/Flag_semaphore

Quarkus Qute with Raspberry PI

Hey you!
2020/09/22

This post is to show how I created a Quarkus Qute demo with a Raspberry PI. This is another blog about Java on Raspberry PI.

Quarkus is a full-stack, Kubernetes-native Java framework made for Java virtual machines (JVMs) and native compilation, optimizing Java specifically for containers and enabling it to become an effective platform for serverless, cloud, and Kubernetes environments.

Qute is a templating engine designed specifically to meet the Quarkus needs. The usage of reflection is minimized to reduce the size of native images. The API combines both the imperative and the non-blocking reactive style of coding. The engine is based on RESTEasy/JAX-RS. As such, Qute web applications are implemented by defining resource types with methods answering to specific HTTP verbs and accept headers. The only difference being, that HTML pages are returned instead of JSON as in your typical REST-ful data API. The individual pages are created by processing template files.

If you’ve worked with other templating engines before, like me, this will look very familiar to you.

Note: Qute is an experimental feature.

Idea

A simple Quarkus Qute example that shows a 7 segments display and control in real-time a real one with a Raspberry Pi 3 B.
When I was googling about a 7 segment display this site appeared in my result and I came up with the idea.

I suggest you check out my 7 segment display blog before looking at the code.

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package com.igor;

import io.quarkus.qute.Template;
import io.quarkus.qute.TemplateInstance;
import javax.inject.Inject;
import javax.transaction.Transactional;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import org.jboss.resteasy.annotations.providers.multipart.MultipartForm;
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;

@Path("hello")
public class HelloResource {

    @Inject
    Template hello;
   
    final GpioController gpio = GpioFactory.getInstance();
    GpioPinDigitalOutput pin01 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_26, "1", PinState.HIGH);
    GpioPinDigitalOutput pin02 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_22, "2", PinState.HIGH);
    GpioPinDigitalOutput pin04 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_07, "3", PinState.HIGH);
    GpioPinDigitalOutput pin05 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_09, "4", PinState.HIGH);
    GpioPinDigitalOutput pin06 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_08, "5", PinState.HIGH);
    GpioPinDigitalOutput pin07 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_15, "6", PinState.HIGH);
    GpioPinDigitalOutput pin09 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_16, "7", PinState.HIGH);
    GpioPinDigitalOutput pin10 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_21, "8", PinState.HIGH);

    @GET
    @Produces(MediaType.TEXT_HTML)
    public TemplateInstance get() {

        return hello.data("field1", "Test").data("field2", "Igor");
    }

    @POST
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    @Transactional
    @Path("/segment")
    public TemplateInstance segmentDisplay(@MultipartForm MessageForm messageForm) {
       
        if(messageForm.segment1 == null && messageForm.segment2 == null &&
                messageForm.segment3 == null && messageForm.segment4 == null &&
                messageForm.segment5 == null && messageForm.segment6 == null &&
                messageForm.segment7 == null && messageForm.segment8 == null) {
            pin01.setShutdownOptions(true, PinState.HIGH);
            pin02.setShutdownOptions(true, PinState.HIGH);
            pin04.setShutdownOptions(true, PinState.HIGH);
            pin05.setShutdownOptions(true, PinState.HIGH);
            pin06.setShutdownOptions(true, PinState.HIGH);
            pin07.setShutdownOptions(true, PinState.HIGH);
            pin09.setShutdownOptions(true, PinState.HIGH);
            pin10.setShutdownOptions(true, PinState.HIGH);
            pin01.high();
            pin02.high();
            pin04.high();
            pin05.high();
            pin06.high();
            pin07.high();
            pin09.high();
            pin10.high();
        }

        display(messageForm);

        return hello.data("field1", "Test").data("field2", "Igor")
                .data("segment1", messageForm.segment1)
                .data("segment2", messageForm.segment2)
                .data("segment3", messageForm.segment3)
                .data("segment4", messageForm.segment4)
                .data("segment5", messageForm.segment5)
                .data("segment6", messageForm.segment6)
                .data("segment7", messageForm.segment7)
                .data("segment8", messageForm.segment8);
    }

    public void display(MessageForm messageForm) {

        if(messageForm.segment1 != null && messageForm.segment1.equals("on")) {
            pin01.low();
        }else {
            pin01.high();
        }
        if(messageForm.segment2 != null && messageForm.segment2.equals("on")) {
            pin02.low();
        }else {
            pin02.high();
        }
        if(messageForm.segment3 != null && messageForm.segment3.equals("on")) {
            pin04.low();
        }else {
            pin04.high();
        }
        if(messageForm.segment4 != null && messageForm.segment4.equals("on")) {
            pin05.low();
        }else {
            pin05.high();
        }
        if(messageForm.segment5 != null && messageForm.segment5.equals("on")) {
            pin06.low();
        }else {
            pin06.high();
        }
        if(messageForm.segment6 != null && messageForm.segment6.equals("on")) {
            pin07.low();
        }else {
            pin07.high();
        }
        if(messageForm.segment7 != null && messageForm.segment7.equals("on")) {
            pin09.low();
        }else {
            pin09.high();
        }
        if(messageForm.segment8 != null && messageForm.segment8.equals("on")) {
            pin10.low();
        }else {
            pin10.high();
        }
    }
}

Disclaimer – I got the CSS from here

You can get the full code on my GitHub.

Links

https://quarkus.io/

https://quarkus.io/guides/qute

https://quarkus.io/guides/qute-reference

https://propjockey.github.io/bcd7sdd/

https://pi4j.com/1.2/index.html

7 Segment Display

What’s the crack jack?
2020/09/20

Table of contents

1. 7-Segment Display
2. Cathode vs Anode
3. Components
4. Schematics
5. Code
6. PI4J
7. Links

1. 7-Segment Display

The 7-segment display, also written as “seven segment display”, consists of seven LEDs (hence its name) arranged in a rectangular fashion as shown. Each of the seven LEDs is called a segment because when illuminated the segment forms part of a numerical digit (both Decimal and Hex) to be displayed. An additional 8th LED is sometimes used within the same package thus allowing the indication of a decimal point (DP).


A 7-segment is a packaged set of 8 LEDs (7 number-segments & 1 decimal point).

I have the “hdsp-c1g1” model and it is a Common-Anode.

2. Cathode vs Anode

Common anode means that the anode (positive) side of all of the LEDs is electrically connected at one pin, and each LED cathode has its own pin. So turning on any particular segment will involve running a current from this common anode (positive) pin to the particular cathode (negative) pin for the desired segment.

Common cathode means that the cathodes of all of the LEDs are common and connected to a single pin. The anode for each LED has its own pin. So driving one of these means running a current from the particular anode (positive) pin for the desired segment to the common cathode pin.

The way that you are diving the 7-segment involves using a separate pin to drive each segment, so you use 8 pins of the Arduino to drive the display.

3. Components

  • 1x Arduino
  • 1x Raspberry Pi
  • 1x Common-Anode 7-segment display
  • 8x Resistor 221 ohm
  • 10x Jumper wires (generic)

4. Schematics

Common-Anode 7-segment display

My 7-segment display has its common pins (COM) connected to the +5V pin.
If a pin turns off, the corresponding segment will turn on. It’s because when the pin is on, the voltage difference between the pin and the +5V is 0. It is the same if the +5V was replaced by 0V. We can’t connect the COM to the GND because the LEDs are like diodes so they wouldn’t light up at all.

For Raspberry PI you need to check the GPIO numbers. Note that the pin number is not the same thing as the GPIO number.

For my example here I create a table to map:

5. Code

Arduino

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
void setup()
{
  init();
  /*your setup code here*/
}

void loop()
{
  /*
   * your loop code here
   *
   * use display(num, dp) to display num (0123456789ABCDEF)
   * and the dot (if dp).
   *
   * you can turn off all the leds by writing display().
   */

}

void init()
{
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
}

void display(int n=-1, boolean dp)
{
  digitalWrite(9, !dp);
  if(num == 0)
  {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 1);
  } else if(num == 1) {
    digitalWrite(2, 1);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 1);
  } else if(num == 2) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 1);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 1);
    digitalWrite(8, 0);
  } else if(num == 3) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 0);
  } else if(num == 4) {
    digitalWrite(2, 1);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 5) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 1);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 6) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 7) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 1);
  } else if(num == 8) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 9) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 1);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 10) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 1);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 11) {
    digitalWrite(2, 1);
    digitalWrite(3, 1);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 12) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 1);
  } else if(num == 13) {
    digitalWrite(2, 1);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 1);
    digitalWrite(8, 0);
  } else if(num == 14) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 15) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 1);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else {
    digitalWrite(2, 1);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 1);
  }
}

Raspberry PI – Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from gpiozero import LED
from time import sleep

pin01 = LED(2)
pin02 = LED(3)
pin04 = LED(4)
pin05 = LED(5)
pin06 = LED(6)
pin07 = LED(12)
pin09 = LED(14)
pin10 = LED(15)


def clear():
    pin01.on()
    pin02.on()
    pin04.on()
    pin05.on()
    pin06.on()
    pin07.on()
    pin09.on()
    pin10.on()


def display(number):
    if number == 0:
        pin01.off()
        pin02.off()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.off()
        pin10.on()
    if number == 1:
        pin01.on()
        pin02.on()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.on()
        pin09.on()
        pin10.on()
    if number == 2:
        pin01.off()
        pin02.off()
        pin04.on()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.on()
        pin10.off()
    if number == 3:
        pin01.on()
        pin02.off()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.on()
        pin10.off()
    if number == 4:
        pin01.on()
        pin02.on()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.on()
        pin09.off()
        pin10.off()
    if number == 5:
        pin01.on()
        pin02.off()
        pin04.off()
        pin05.on()
        pin06.on()
        pin07.off()
        pin09.off()
        pin10.off()
    if number == 6:
        pin01.off()
        pin02.off()
        pin04.off()
        pin05.off()
        pin06.on()
        pin07.off()
        pin09.off()
        pin10.off()
    if number == 7:
        pin01.on()
        pin02.on()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.on()
        pin10.on()
    if number == 8:
        pin01.off()
        pin02.off()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.off()
        pin10.off()
    if number == 9:
        pin01.on()
        pin02.on()
        pin04.off()
        pin05.off()
        pin06.off()
        pin07.off()
        pin09.off()
        pin10.off()


clear()
sleep(1)
while True:
    for x in range(10):
        display(x)
        sleep(1)

6. PI4J

PI4J provides a friendly object-oriented I/O API and implementation libraries for Java programmers to access the full I/O capabilities of the Raspberry Pi platform. This project abstracts the low-level native integration and interrupts monitoring to enable Java programmers to focus on implementing their application business logic.

Note: Pi4J (by default) uses an abstract pin numbering scheme to help insulate software from hardware changes.Pi4J implements the same pin number scheme as the Wiring Pi

http://wiringpi.com/pins/

This is the Number for the PI 3 B model.

Because the PI4J use a different GPIO number I add a new column in my table;

Raspberry PI – Java – Pi4j

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
package led.example;

import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;

public class SevenSegmentsDisplay {

    static GpioPinDigitalOutput pin01 = null;
    static GpioPinDigitalOutput pin02 = null;
    static GpioPinDigitalOutput pin04 = null;
    static GpioPinDigitalOutput pin05 = null;
    static GpioPinDigitalOutput pin06 = null;
    static GpioPinDigitalOutput pin07 = null;
    static GpioPinDigitalOutput pin09 = null;
    static GpioPinDigitalOutput pin10 = null;

    public static void display(int number) {

        if(number == 0) {
            pin01.low();
            pin02.low();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.low();
            pin10.high();
        }
        if(number == 1) {
            pin01.high();
            pin02.high();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.high();
            pin09.high();
            pin10.high();
        }
        if(number == 2) {
            pin01.low();
            pin02.low();
            pin04.high();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.high();
            pin10.low();
        }
        if(number == 3) {
            pin01.high();
            pin02.low();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.high();
            pin10.low();
        }
        if(number == 4) {
            pin01.high();
            pin02.high();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.high();
            pin09.low();
            pin10.low();
        }
        if(number == 5) {
            pin01.high();
            pin02.low();
            pin04.low();
            pin05.high();
            pin06.high();
            pin07.low();
            pin09.low();
            pin10.low();
        }
        if(number == 6) {
            pin01.low();
            pin02.low();
            pin04.low();
            pin05.low();
            pin06.high();
            pin07.low();
            pin09.low();
            pin10.low();
        }
        if(number == 7) {
            pin01.high();
            pin02.high();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.high();
            pin10.high();
        }
        if(number == 8) {
            pin01.low();
            pin02.low();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.low();
            pin10.low();
        }
        if(number == 9) {
            pin01.high();
            pin02.low();
            pin04.low();
            pin05.low();
            pin06.low();
            pin07.low();
            pin09.low();
            pin10.low();
        }

    }

    public static void main(String[] args) {

        final GpioController gpio = GpioFactory.getInstance();

        pin01 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_08);
        pin02 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_09);
        pin04 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_07);
        pin05 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_21);
        pin06 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_22);
        pin07 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_26);
        pin09 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_15);
        pin10 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_16);

        pin01.setShutdownOptions(true, PinState.HIGH);
        pin02.setShutdownOptions(true, PinState.HIGH);
        pin04.setShutdownOptions(true, PinState.HIGH);
        pin05.setShutdownOptions(true, PinState.HIGH);
        pin06.setShutdownOptions(true, PinState.HIGH);
        pin07.setShutdownOptions(true, PinState.HIGH);
        pin09.setShutdownOptions(true, PinState.HIGH);
        pin10.setShutdownOptions(true, PinState.HIGH);

        try {
            while(true) {
                for (int i = 0; i < 10; i++) {
                    display(i);
                    System.out.println("Number " + i);
                    Thread.sleep(2000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            gpio.shutdown();
        }
    }

}

Results

7. Links

https://en.wikipedia.org/wiki/Cathode

https://en.wikipedia.org/wiki/Anode

https://pi4j.com/1.2/index.html

https://github.com/Pi4J/pi4j