Radio Controlled Electronic Basketball Scoreboard

Hello fellow Makers!

This is my first Instructables article, so bear with me if I stumble a bit. I'm not a seasoned pro, just a DIY enthusiast with a passion for building (and sometimes breaking) things.

My latest project was a digital scoreboard for our basketball games. Let's face it, those dusty, manually operated analog scoreboards just don't cut it anymore. It's time to level up the game night with a scoreboard worthy of a buzzer-beater moment.

I will go through the design process, from the initial idea to the final product, with maybe a little bit of self-deprecating commentary along the way.

Supplies

Electronics
Arduino Nano Every microcontroller (link)
LCD Screen 16x2 characters w/ I2C adapter (link)
DS3231 real-time clock module (link)
RF 433MHz radio receiver/transmitter (link)
Rotary Encoder (link)
Power Supply 12V DC (link) with 5.5mm plug connection
LED stripes 2835-diode-type, three colors
74HC595 serial register chip (10x)
ULN2003 Darlington transistor array chip (10x)
DIP16 sockets (20x)
Capacitors 100nF/50V ceramic (10x)
Resistors 1k, 2k
IDC 6P angle headers/sockets (link) + connectors (10x)
IDC ribbon cable
ARK 2-pin connector (3x)
Prototype boards
Angle pin headers and sockets
HC-05 Bluetooth Module (optional)
Mechanical
M2/M3/M4 nuts, bolts and washers
Semi-transparent diffusing acrylic/Perspex, 2mm thickness for 7-segment displays
PLA filament for 3D-printing
Plywood or HDF sheets, 3mm thickness for scoreboard housing
14x20mm wooden strips for scoreboard housing frame
Black spray paint, 400ml can
Hinge (2x) + a couple of wood screws

Step 1: Assumptions and Requirements

Before I dive into the hands-on design and implementation process I should describe the assumptions and requirements the scoreboard shall meet.

Functionality:
Keep 3-digits score for two teams.
Display gametime & daytime clock.
While in-game, be controllable via a small remote with a 20-30 meters of range.
Have the options to run various types of games (score only, timed quarters, time alert).
Have a menu system for control & configuration.
Technical:
Use Arduino as the microcontroller.
Utilize large 7-segment displays for displaying score and time.
Incorporate an LCD screen for menu navigation.
Include a rotary encoder with a push button for user input.
Design:
Be relatively compact & easy to transport.
Have clear and bright displays that can be seen from a distance and in a bright indoor light.
Allow further flexibility in the number of 7-segment displays used.
Reasonable cost for components, prioritizing affordability.
Modularity to ease design, construction, testing and changes.

These assumptions and requirements served as the foundation for the scoreboard's design and development. They helped me guide decisions about component selection, circuit design, and software functionality.

Step 2: Architecture & Top-level Design

Top-level design

From the very beginning I knew there would be blind paths, mistakes and failures. I wanted the design to allow me to learn as I go and fix the issues, both software and hardware, with the minimal cost and rework effort. That’s why the concept of the mainboard is decoupled into three separate components: mainboard (Arduino + components), power distribution and LCD display.

One of the assumptions was to allow flexibility in the number of 7-segment displays.

One can easily imagine building the scoreboard with a full score display (2 x 3 digits) and full time display (4 digits), which will take ten 7-segment displays. But it should be equally easy to rebuild (or build the next version) the scoreboard into the ‘just the score’ version, where you need only 6 digits or maybe even less, say 2 x 2 digits and no time display at all.

That’s why I’ve designed the digit displays to be connected with the chain topology, rather than the star topology, where each and every digit would have to be connected to the mainboard. Any change would require redesign of the mainboard PCB and that’s what I wanted to avoid if I change my mind and try to build the scoreboard that is even more compact and small. The chain topology to connect 7-segment displays allows to extend or shrink the number of displays easily.

Choosing Arduino Nano Every

I’ve started some initial proof-of-concept designs with a regular Arduino Nano, but quickly it became apparent it will not handle the total amount of Arduino libraries and source code required to handle multiple hardware components like LCD screen, radio and clock. There were also a lot of other libraries planned to be used, like for in-game state machine, non-busy waiting timers or button debouncing.

I’ve ended up going with Arduino Nano Every, mainly because of the extended memory it offers over Arduino Nano. The slightly faster clock speed of Every does not count as much as the memory - 6 KB for Arduino Nano Every compared to 2 KB from the regular Arduino Nano.

Links: Arduino Nano, Arduino Nano Every

Nice thing is both boards have pretty much the same footprint and pinouts, so you can easily switch them while prototyping or checking individual components.

Choosing Arduino mainboard components

Selecting other mainboard components was relatively simple compared to the Arduino type itself.

I’ve selected standard components like battery-supported DS3231 real-time clock or 16x2 LCD screen with I2C adapter. There are tons of examples and tutorials through the Internet you can follow to get yourself started with these components.

Selecting the LCD screen type was additionally a good choice, because it’s supported by theforntoh/LcdMenulibrary, which is brilliant for menu operations and out-of-the-box it supports rotary encoder.

Make sure your LCD display is equipped with an I2C adapter - it will save you the headache of connecting ‘raw’ LCD display to Arduino. Wiring those two both together using I2C protocol is as easy as providing VCC/GND and SDA/SCL, so 4 wires only.

I did not avoid the headaches of trying to be cheap on components. For radio module, I’ve started with selecting something very cheap, like this one, for just a couple of bucks:

I was unable to control it, it wasn’t stable enough and it wasn’t reliable enough over the distances like 10-15 meters you would normally expect between you and your scoreboard in the basketball court.

I went for something more expensive (QIACHIP RF 433 MHz transmitter and receiver) and it turned out to be very reliable and stable.

Real-time clock was also a no-brainer. Widely and commonly used with Arduino is the DS3231. It does support I2C protocol, saving Arduino pins and it’s super easy to operate using existing libraries.

Choosing LEDs

When designing larger scale displays, you can go with something out-of-the-shelf, like individual LEDs boards, to build a reasonably big digit that can be visible from longer distances (source Alibaba):

But that’s expensive. You can build something similar on your own, but it would be too much work.

I’ve selected to go with something way more simpler - the LED strips:

They can be easily cut into shorter segments, with the minimum of three diodes per 5 cm segment. They come with the built-in LED resistors and can be easily soldered with the wires to connect to the power supply. To power these LED strips we need 12V. It does not look like Arduino can deliver 12 V through the output pins, as its operating voltage is 5V only. We need something more powerful to deliver 12V.

We also need to resolve yet another problem: Arduino has 22 output digital pins. We need… 70 :)

Scoreboard displays ten digits: 4 for time and 6 for score. Each digit (7-segment display) consists of 7 light sections that need to be managed individually. That makes 70 individual control points for Arduino to turn the light on & off.

Choosing 7-segment digit LED driver (74HC595 + ULN2003)

We need at least 70 digital output pins to control each of the 70 LED segments for the digits.

Compared to the number of Arduino Nano Every digital pins that we can use (say - there are 22 pins available), it’s way too much to handle.

We also have to make Arduino communicate with radio, clock, LCD screen, pretty much each of these components consuming 2-3 pins. That makes the number of the output pins available to power up the 7-segment digit diodes even smaller.

The easiest way to magically ‘multiply’ the number of the Arduino output pins is to use shift registers like 74HC595. Using 74HC595 shift registers allow control of multiple 7-segment displays with fewer Arduino pins. You can find a detailed tutorial on using 74HC595 with Arduino here.

The 74HC595 chip itself is mighty in speed, but it cannot handle much of the current needed to power the LED strips. Remember: it still operates with the same logic voltage as Arduino itself which is 5V.

What’s more: the maximum current per 74HC595 output pin is 35mA. The maximum current you can pass through 74HC595’s VCC or GND pins is 70mA. This means you can't draw 35mA from all 8 outputs simultaneously.

Back to LED strips, as per the datasheets, each 1 meter of these SMD 2835 EPISTAR LED strips consists of 60 diodes. It is powered by a 12V DC power supply and each 1 meter of the strip draws 4,8W of power with a current of 0.4 Amps.

Now, for the scoreboard, for each 7-segment digit we need 7 short segments of 3 diodes each, cut out of the longer LED strip.

Quickly calculating for a single 7-segment digit display:

7 x 3 diodes = 21 diodes
60 diodes draw 0.4 amps
21 diodes draw 0.14 amps

To power an individual 7-segment digit we need 0.14 amps with 12 V. We have 10 digits, thus the maximum current we need for all of them, in the worst case scenario displaying digit ‘8’ (meaning: all LEDs are on) is around 1.4 amps.

This is where ULN2003 microchip comes into play.

The official code name of this chip, as designated by Texas Instruments (the original manufacturer), is ULN2003A. The 'A' suffix typically denotes an improved or updated version of the original IC. However, 'ULN2003' is often used generically to refer to this IC family, even including those made by other manufacturers. So, while technically 'ULN2003A' is the most accurate code name, you'll often see it referred to simply as 'ULN2003' in datasheets, tutorials, and online discussions. Long and sophisticated name for this chip is 'Darlington Transistor Array', but what we only need to know is that it serves the function of a transistor (should I say - an array of transistors) to control the high voltage and current by low voltage and current.

Extracting from the ULN2003 specification we can learn:

Maximum load of a single output pin: 500mA (instantaneous 600mA)
Maximum output voltage: 50V
Logic voltage: 5V
It’s possible to connect outputs to multiply power

Looks like it can control powerful LEDs, stepper motors and DC motors, etc. The ULN2003 Darlington transistor array can support the necessary current and voltage to drive the LED segments, protecting the Arduino and 74HC595 from obvious overload. And damage.

Step 3: Designing the Electronics & PCBs

For the electronics, I used KiCad. Now, I'm no PCB design wizard, but KiCad made it relatively painless.

I created the schematics, designed the PCB layout, and prayed to the electronics gods that I didn't mess anything up.

Just to reduce my chances of failure, before I came out with this final design, I’ve experimented and tested a lot with smaller Arduino setups, learning my way through connecting each component individually and making sure my breadboard prototypes are working reliably and stable for each component.

Here is how the schematics for the mainboard looks like:

Image: Mainboard electronics schematics

I’ve done some experiments with Bluetooth LE connectivity and incorporated the connector for Bluetooth HC-05 module, just to have the mainboard and Arduino hardware-ready.

Image: Mainboard PCB design

Image: Mainboard PCB KiCad render

7-segment digit display electronic design is based on combined operations of 74HC595 shift register and ULN2003 transistor array. 74HC595 receives serial data from Arduino and with its outputs it triggers on-and-off the inputs of the ULN2003, which then outputs 12V to respective LED segments of the 7-segment digit.

This 7-segments LED custom made driver receives the input signals from Arduino via Digit_IN connector. Digit_OUT connector makes the daisy-chaining of the multiple LED drivers possible.

Some of the 74HC595 serial register input signals are simply passed through down the chain of LED drivers (like Serial Clock or Register Clock, plus of course VCC and GND), because these signals are common to all LED drivers, driving consecutive digits on the scoreboard.

Each 74HC595 chip has the QH’ output pin, which serves the purposes of the shift register output, a.k.a. carryover the serial data to the next 74HC595 chip in a chain, if you plan to have multiple of these in a series. And I do plan :)

You can find an excellent tutorial here to learn more on using 74HC595 chip with Arduino.

Image: 7-segment digit LED driver schematics

Image: 7-segment digit LED driver PCB design (top and bottom layers)

Image: 7-segment digit LED driver PCB render

Once the PCB designs were finalized (fingers crossed for not missed grounds…), I sent them off to PCBWay for manufacturing. Let me just say, these guys are amazing. The boards arrived quickly, and the quality was top-notch. Plus, they have a cool online viewer that lets you inspect your design before it's made. PCBway is also making sure your ideas do meet the manufacturing standards before your PCB gets into the production line, so it’s nice to know there is a second line of defense before making mistakes. No strings attached, I can honestly recommend their services.

Image: before-manufacturing preview of the mainboard PCB

Image: before-manufacturing preview of the 7-segment digit LED driver PCB

Step 4: Designing the 3D-printed Parts

This is where things got interesting (and by interesting, I mean slightly chaotic) as I entered the real world of mechanical designs. I used Onshape for the 3D design of the 7-segment digits, mainboard housing and some auxiliary parts like wire holders.

I’ve started with a frame to hold the 7-segment LED strips and the per-digit PCB. Along it came the digit front cover. While assembling, those two will sandwich a piece of acrylic. Acrylic nicely dispels the light from the LED strips and the top cover… covers the areas where the light should not be visible.

Image: Onshape CAD model of a 7-segment digit frame

Image: 3D-printed and ready-to-be assembled 7-segment digit frame

Image: Prototype and wired 7-segment digit frame with LED strips

And yes, you’ve guessed it right. This little tiny-tiny red wire jumper…this is the missing ground connection…But don’t you worry, it’s already corrected within the electronic design schematics and PCBs.

Step 5: Software (PlatformIO and Arduino)

With the hardware sorted out, it was time to write some coding. I used PlatformIO, which is a fantastic IDE for Arduino development (and other platforms too). It's way more organized and stable than the standard Arduino IDE in my humble opinion.

I'll spare you the gory details of the entire codebase, but it essentially does the following:

Handles menu navigation via the rotary encoder and LCD screen.
Manages and sets the time to the real-time clock.
Controls the state (machine) logic.
Reads input from the RF 433MHz remote (score up/down while in-game).
Updates the 7-segment displays through pushing bit sequences to the 74HC595 shift registers to turn on/off the LED segments.

After trying and testing many available Arduino libraries my final set of chosen ones was:

For real-time clock (DS3231): https://github.com/NorthernWidget/DS3231
For radio buttons operations (including debouncing): https://github.com/mickey9801/ButtonFever
For LCD screen: https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
For LCD menu: https://github.com/forntoh/LcdMenu
For state machine: https://github.com/cotestatnt/YA_FSM
For logging: https://github.com/thijse/Arduino-Log
For non-busy-waiting timers: https://github.com/sstaub/TickTwo

The most interesting part to share here would be the way to send 74HC595 shift register on/off bits for 7-segment displays. By the wisdom of Internet, here is how it's look like:

// Arduino pins to control shift registers

#define PIN_SHIFT_REGISTER_CLOCK 2

#define PIN_SHIFT_REGISTER_LATCH 3

#define PIN_SHIFT_REGISTER_DATA 4

...

// global variables to store characters to be displayed

const byte MAX_DISPLAYS = 10; // maximum number of 7-segment displays

char g_values[MAX_DISPLAYS]; // N single digits to be displayed

byte g_registerArray[MAX_DISPLAYS]; // array of numbers to pass to shift registers

...

// 7 segments of the digit

const byte __ = 0;

const byte A_ = 1;

const byte B_ = 2;

const byte C_ = 4;

const byte D_ = 8;

const byte E_ = 16;

const byte F_ = 32;

const byte G_ = 64;

// 0-9 digits composed of individual segments of the 7-segment digit

CHARACTERS[0] = A_ + B_ + C_ + D_ + E_ + F_ + __; // '0'

CHARACTERS[1] = __ + B_ + C_ + __ + __ + __ + __; // '1'

CHARACTERS[2] = A_ + B_ + __ + D_ + E_ + __ + G_; // '2'

CHARACTERS[3] = A_ + B_ + C_ + D_ + __ + __ + G_; // '3'

CHARACTERS[4] = __ + B_ + C_ + __ + __ + F_ + G_; // '4'

CHARACTERS[5] = A_ + __ + C_ + D_ + __ + F_ + G_; // '5'

CHARACTERS[6] = A_ + __ + C_ + D_ + E_ + F_ + G_; // '6'

CHARACTERS[7] = A_ + B_ + C_ + __ + __ + __ + __; // '7'

CHARACTERS[8] = A_ + B_ + C_ + D_ + E_ + F_ + G_; // '8'

CHARACTERS[9] = A_ + B_ + C_ + D_ + __ + F_ + G_; // '9'

...

void sendSerialData(byte registerCount, byte *pValueArray) {

digitalWrite(PIN_SHIFT_REGISTER_LATCH, LOW);

for (byte reg = registerCount; reg > 0; reg--) {

byte value = pValueArray[reg - 1];

for (byte bitMask = 128; bitMask > 0; bitMask >>= 1) {

digitalWrite(PIN_SHIFT_REGISTER_CLOCK, LOW);

digitalWrite(PIN_SHIFT_REGISTER_DATA, value & bitMask ? HIGH : LOW);

digitalWrite(PIN_SHIFT_REGISTER_CLOCK, HIGH);

}

digitalWrite(PIN_SHIFT_REGISTER_LATCH, HIGH);

}

void pushShiftRegisters() {

for (byte i = 0; i < MAX_DISPLAYS; i++) {

if (g_values[i] != -1)

g_registerArray[i] = CHARACTERS[g_values[i]];

else

g_registerArray[i] = 0;

}

sendSerialData(MAX_DISPLAYS, g_registerArray);

}

Step 6: Assembly & Integration

Here are some pictures from the integration part of the job. The final scoreboard housing is 39x70cm and weights exactly 2.7kg + the 12V power supply which is 300g. In total, additional 3kg to carry with me to the basketball court.

Foldable with the hinges, it nicely fits into the car boot along my game gear.

Step 7: The Future

Here are some ideas for future improvements:

Battery Power: Because outlets aren't always conveniently located on basketball courts a pack of 18650s shall do the job for 2 hours of battery operation.
Bluetooth connectivity & mobile app control: It's XXI century, everything should have a mobile app! This is where that Bluetooth module will come in handy. Mainboard PCB is already prepared to host the HC-05 BT module to be out-of-the-box connected with Arduino.
Sound Effects: Imagine a game-end buzzer or a break time horn!

Step 8: Lessons Learned

Here are some of the things I learned the hard way:

Prototype, Prototype, Prototype: Seriously, build a small-scale version of your PCB before committing to the final design. It will save you time, money, and headaches.
Test Components Individually: Don't wait until everything is assembled to find out that a component is faulty.
Read the Datasheets: They're there for a reason. Understanding the specifications of your components is crucial.
Printed Schematics are a Lifesaver: Print the crucial parts of the documentation and schematics and have them quickly available. Having a hard copy of your schematics at hand during assembly and troubleshooting is incredibly helpful.
Decoupling Capacitors are Your Friends: Use them liberally, especially around ICs and microcontrollers. They help to smooth out power fluctuations and prevent weird behavior.
Arduino Nano Pin D13 has its purpose: I mistakenly used it for the purpose of enabling/disabling 74HC595 shift register output, but it is connected to the internal LED. You cannot have both at the same time. I’ve ended up just manually breaking the PCB connection of Arduino pin 13 with the rest of the mainboard and luckily for me, the default state of the 74HC595’s OE is active-low, thus no further changes were needed to the PCB and I could continue with this design error and the already printed PCBs. So, be mindful if you use this actual pin anyhow in your project.
Quality Parts Matter: Don't cheap out on quality electronic components. It's not worth the hassle in the long run.
Tolerances are Important: When designing mechanical parts, always leave some wiggle room.
Easy Assembly/Disassembly: Make your design modular and easy to take apart. Go with the simplest solutions possible. You'll thank yourself later if you need to troubleshoot or make changes.
PCB Design is an Art: Learn about things like VCC/GND distribution, star vs. daisy chain topologies (I opted for a star topology for power distribution), etc.

Step 9: Android Mobile App

Having a software developer background, with a little bit of a help from AI-assisted Android Studio I've enjoyed myself building an Android mobile app to configure the scoreboard, start and stop games, adjust the scores and timers, etc. The app interface is still a bit work-in-progress state, but the it does the job to reduce the need to touch the scoreboard apart from connecting the power source to the wall.

This was a whole brand new area of learning for myself, mainly mastering Bluetooth LE connectivity and refreshing myself Android app design patterns.

Please let me know in the comments if you want to know more about this part.

Step 10: Conclusion

Building this scoreboard was a challenging, but incredibly rewarding project. I learned a ton about electronics, programming, 3D printing, and PCB design. And the best part? Our basketball games are now a little bit more epic with the seconds ticking fast near the end of the close game :)

I hope this article inspires you to tackle your own DIY projects. Remember, it's okay to make mistakes along the way as long as you learn from them. Now, go forth and build something awesome!

If you have any questions, do not hesitate to ask in the comments section below!

Introduction: Radio Controlled Electronic Basketball Scoreboard