LED - 3. Let's make a large led display - Part 5 (N X M RGB LED Matrices)

Connect 1 X 2 RGB LED Matrix with 1 chain

In the previous post, I connected several matrices in a single line. This time, we will make an LED display with N X N structure. As before, using daisy chaining is the same. It will just redesign the software to implement the screen.

First let's stack the RGB LED matrices vertically. 


It doesn't matter which of the two pictures above. This post uses the first approach.
  1. First prepare an image of size 64 X 64. 
  2. Devide the image into two parts, the top and the bottom. 
  3. Make a flip image of top part in horizontal, vertical direction. 
  4. Connect the two images horizontally to create a new 128 X 32 image.
  5. Display the image.




This requires splitting, flipping, and merging the image. For this task, I will use OpenCV as well as the PIL. See below for installation of OpenCV.

splitting, flipping, and merging the image



import argparse
import cv2
import numpy as np
from PIL import Image
from PIL import ImageDraw
from rgbmatrix import RGBMatrix, RGBMatrixOptions
import time

# Configuration for the matrix
options = RGBMatrixOptions()
options.cols = 64
options.rows = 32
options.chain_length = 2
options.parallel = 1
#options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'
matrix = RGBMatrix(options = options)

print('Matrix H:%d W:%d'%(matrix.height, matrix.width))


parser = argparse.ArgumentParser(description="OpenCV Example")
parser.add_argument("--file", type=str, help="file name")
args = parser.parse_args()

img = cv2.imread(args.file, cv2.IMREAD_COLOR)
img = cv2.resize(img, (int(matrix.width / 2), matrix.height * 2))
height, width, channels = img.shape
print('H:%d W:%d'%(height, width))
y_end = int(height / 2)
x_end = width

'''
split the image top, bottom
'''
top_img = img[0: y_end, 0:x_end]
bottom_img = img[y_end: y_end * 2, 0:x_end]

'''
flip the image
'''
top_img = cv2.flip(top_img, 0) #vertical
top_img = cv2.flip(top_img, 1) #horizontal

final = np.concatenate((top_img, bottom_img), axis=1)   #stack horizontally 
final = cv2.cvtColor(final, cv2.COLOR_BGR2RGB)  
h, w, c = final.shape
print('final image H:%d W:%d'%(h, w))
im_pil = Image.fromarray(final)


matrix.Clear()
matrix.SetImage(im_pil, 0)
time.sleep(10)


Run the code. Be careful that I'm root user now, so I don't have to use sudo command.


root@raspberrypi:/home/pi/rpi-rgb-led-matrix/bindings/python/samples# python3 twobytwo.py --file=run.jpg 
Matrix H:32 W:128
H:64 W:64
final image H:32 W:128



Connect 2 X 2 RGB LED Matrix with 1 chain

The code above can be used without modification.

<2 X 2 display daisy connection>

  1. First prepare an image of size 128 X 64. 
  2. Devide the image into two parts, the top and the bottom. 
  3. Make a flip image of top part in horizontal, vertical direction. 
  4. Connect the two images horizontally to create a new 256 X 32 image.
  5. Display the image.

More stacking?

The code above divides the image into the top and bottom. But now divide into N images vertically.

<N X M RGB LED matrix>

You do not have to configure the display as shown above. It can be connected from top to bottom, or can be configured to avoid flipping using long Hub 75 cables. The following source code can be used flexibly with the above configuration.

import argparse
import cv2
import numpy as np
from PIL import Image
from PIL import ImageDraw
from rgbmatrix import RGBMatrix, RGBMatrixOptions
import time

parser = argparse.ArgumentParser(description="OpenCV Example")
parser.add_argument("--file", type=str, help="file name")
parser.add_argument("--horizontal", type=int, default = 1, help="horizontal count")
parser.add_argument("--vertical", type=int, default = 1, help="vertical count")
args = parser.parse_args()

# Configuration for the matrix
options = RGBMatrixOptions()
options.cols = 64
options.rows = 32
options.chain_length = args.horizontal * args.vertical
options.parallel = 1
#options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'
matrix = RGBMatrix(options = options)

canvas_w = args.horizontal * options.cols
canvas_h = args.vertical * options.rows

print('Matrix H:%d W:%d'%(matrix.height, matrix.width))
print('Image size H:%d W:%d'%(canvas_h, canvas_w))

img = cv2.imread(args.file, cv2.IMREAD_COLOR)
img = cv2.resize(img, (canvas_w, canvas_h))
img = cv2.cvtColor(final, cv2.COLOR_BGR2RGB)
 
for x in range (args.vertical):
    i = img[options.rows * x: options.rows * (x + 1), 0:canvas_w]
    h, w, c = i.shape
    print(' split image H:%d W:%d'%(h, w))
    if ((args.vertical - x) % 2) == 0:    # -> flip
        i = cv2.flip(i, 0) #vertical
        i = cv2.flip(i, 1) #horizontal
    if(x == 0):
        final = i
    else:
        final = cv2.hconcat([final, i])   #stack horizontally     

h, w, c = final.shape
print('final image H:%d W:%d'%(h, w))
im_pil = Image.fromarray(final)

matrix.Clear()
matrix.SetImage(im_pil, 0)
time.sleep(10)

Run the code.

root@raspberrypi:/home/pi/rpi-rgb-led-matrix/bindings/python/samples# python3 nbyn.py --file=star.jpg --horizontal=2 --vertical=2
Matrix H:32 W:256
Image size H:64 W:128
split image H:32 W:128
split image H:32 W:128
final image H:32 W:256

Now you can see the 128 X 64 size RGB LED Display.
<Vincent van Gogh's The Starry Night>


Henner Zeller suggests maximum 12 modules in one chain, however the maximum number of modules can vary depending on the performance of the Raspberry Pi and the PWM values ​​that determine the number of colors the RGB matrix can represent.


Install OpenCV 4.1.1 to Raspberry Pi

We will install OpenCV in addition to the existing PIL for image processing.

sudo apt-get install -y build-essential cmake pkg-config
sudo apt-get install -y libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev
sudo apt-get install -y libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
sudo apt-get install -y libxvidcore-dev libx264-dev  libgtk2.0-dev libgtk-3-dev  libatlas-base-dev gfortran

sudo apt--get install -y openexr libqtgui4 libqt4-test libhdf5-100
sudo apt-get install -y python3-dev python3-pip
sudo  pip3 install opencv-python
 

Then modify the ~/.bashrc script. Add "export LD_PRELOAD=/usr/lib/arm-linux-gnueabihf/libatomic.so.1" line at the end of the file.


vim ~/.bashrc
source ~/.bashrc

Now verify that it is installed correctly.



pi@raspberrypi:~/rpi-rgb-led-matrix/bindings/python/samples $ python3
Python 3.7.3 (default, Apr  3 2019, 05:39:12) 
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import cv2
>>> exit()
pi@raspberrypi:~/rpi-rgb-led-matrix/bindings/python/samples $ python3
Python 3.7.3 (default, Apr  3 2019, 05:39:12) 
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import cv2
>>> cv2.__version__
'4.1.1'
>>>

We will use sudo to run Python programs with root privileges. If you use sudo command and OpenCV does not run properly due to environment variable problem, modify the root user's bashrc script and work as root instead of sudo.



$sudo su -
#vim ~/.bashrc
#source ~/.bashrc


Wrapping up

In the next post, I'll take an example of extracting a video frame and displaying it on an RGB LED matrix.
You can download the source codes here(https://github.com/raspberry-pi-maker/IoT)






댓글

댓글 쓰기

이 블로그의 인기 게시물

LED-12. Displaying HDMI Contents

이미지
 I recently bought an interesting product. It is a device that converts HDMI data to USB. This device works very much like a webcam. Just as a webcam transmits the video input through the camera lens through USB, this device transmits the video coming through HDMI through USB. Therefore, the host computer to which this device is connected treats it almost the same as a webcam. <HDMI Ccapture device> It's a cheap product you can get for around $10 on Amazon or Ali Express. This product can be usefully used when using SBC (Single Board Computer) such as Raspberry Pi. If you need to check the boot screen because the Raspberry Pi doesn't work properly without a monitor, you can use this device. After connecting the HDMI cable to the Raspberry Pi, connect this device to the other side and then connect the USB port to your laptop. You can check the screen of the Raspberry Pi on the laptop without a monitor. <Raspberry Pi screen output using Window's VLC player> In thi
자세한 내용 보기

LED - 5. Raspberry Pi 4 + DietPi Buster + Electrodragon HAT - Part 1

이미지
This post is related to several posts written to use the RGB LED matrix in Raspberry Pi. If you haven't read the previous posts, it can be hard to understand, in which case you ㅡmight read the previous posts in advance. I've covered in previous post that Rasbian Buster and the RGB Matrix HAT don't fit together. I was able to play the video successfully. However, noise often appeared on the video screen. To solve this problem, I have tried various things such as changing the power and changing the video format, testing various Raspberry Pi models(2B,3B,4B) but I could not improve it. Clues to solving this problem can be found on Henner Zeller's git page . If you read the Troubleshooting section, there is a description of the brightness instability in the latest version of Rasbian, and introduces issue # 483 . This is due to a structural problem in the latest Raspbian kernel. In the contents, the 2016 Jessie version says there are very few problems. So I de
자세한 내용 보기

LED-11. Make a very big size 384 X 512 RGB Matrix #6(final)

이미지
 Finally, it is the day to install the 384X512 size LED signage in the cafe. Up to now, assembly, development, and testing were carried out in my office. Finished installing and testing Node-RED for minor bug fixes and electronic parts management. And to install the cafe, I disassembled the electronic parts again and took it to the cafe. Here we will install it again after reassembly. reassembly All 24 LED panels, aluminum profiles, Hub75 cables and wires were removed and reassembled in the cafe. <Rear view of reassembled LED signage> After reassembly, a simple test was conducted. Confirmed that it works without problems. The next thing to do is to fix the sign structure to the window. <Test screen after reassembly> The black line on the screen is invisible to the human eye. <LED signage installation> Four arms were connected to the LED frame and fixed to the aluminum window frame. And after playing the LED content, I checked it outside the building. <LED signage i
자세한 내용 보기