Lightboard Number One (4x8) - for Teaching, Streaming, Ideation...

6,680

133

15

Introduction: Lightboard Number One (4x8) - for Teaching, Streaming, Ideation...

About: I teach computers

I teach - online now, and unlikely to change for a while - and often use my iPad with Explain Everything to write down examples or thoughts as I do. It's a great way to answer questions live and to make a more personal recorded lecture. Using OBS you can bring yourself into the frame too. But it's not perfect because it's Picture in Picture and some of the fidelity is lost.

Lightboards are a way to bring that back. They're not new – they use Total Internal Reflection, or TIR, (light bounces around) in a sheet of glass or (in this case) plexiglass and if you write on the glass with a suitable pen (like the Expo Neon pens) the TIR is "frustrated" and some of the light escapes where the pen writing is. It makes it look like it is glowing, which is pretty cool. The most interesting thing about the lightboard though is that you are part of it - you are actually in the frame as you write and talk. It's a highly direct and surprisingly personal mode of communication between you and the listener. Tons of body language is caught and the writing happens as you think and speak. Now that's perfect.

But light boards cost a lot of money - the cheapest I could find was around $2,500 Canadian for one which was 54 inches across the diagonal. Anything larger gets really expensive and I wanted BIG.

So I decided to make one. The lightboard I made here is 4 feet by 8 feet plexiglass, lit by LED strips and uses LED strips to light me up too. The rest of the material, apart from the plexiglass, is a few bolts and some spruce 2x4s (which at the moment of writing are getting ever more expensive!). I use two Raspberry Pi Picos to run the LED lights and have a transformer to power them because there are around 200 to power for each strip.

This Instructable takes you through the process. I have drawn pictures where there is a need, and there are also a few photos to help.

Supplies

1 - 4x8 sheet of plexiglass. I called my local store and they had one in stock for around $400 CAD. A friend's truck is also useful to pick this up...

2 - LED strips (there will be some cutting and soldering required) - I used BTF Lighting's WS2812B RGB (https://www.amazon.ca/gp/product/B01CDTELBE). The LEDs are individually addressable (not that it matters overmuch here) with 60 pixels per metre. It would be possible to in fact do the project with one strip cut in half, so bear that in mind as I go.

2 - Raspberry Pi Picos (if you don't know what they are, they're microcontrollers you can program in C or Python, amongst other things (I used Python)

2 - Waveshare 1.14 inch displays for the Pico (https://www.amazon.ca/gp/product/B08VRDF27G) - neat little displays with just enough space to display things nicely, and 4 handle little buttons. A cardboard box (right now - it will be 3D printed later) to house the electronics.

A transformer (I used https://www.amazon.ca/gp/product/B01D8FLWGE) to power the lights and the Picos

Solder, soldering Iron, some cable to tie in the lights

7 - 4x8 spruce

48 1/4 inch bolts, approximately 4 inches long should do it (I overshot and got far too long and ended up cutting off a lot)

48 1/4 inch lock washers and nuts

(You can get away with fewer probably, but it's your call on how secure you want that plexiglass to be)

A drill, 1/4 inch wood bit, socket set and a few screws

Step 1: Prepare the Big Stuff

Having ordered and picked up the plexiglass and lumber find a suitably large space (I used part of my garage floor) and make sure it's clean (-ish). The frame you want to build looks a bit like the picture I drew nicely for this section.

So, first things first, decide how tall you want this beast to be. I'm 5'8" and an 8 foot tall lightboard would make me look silly. I measured so that the top would be a few inches above my head (or for context, the bottom would be just below my hips) and cut four of the 2x4s to size (mine are 6 feet in length). These will be the legs (A in the picture above).

Next, but 7 inches from four more 2x4s. These will be the top and bottom.

Lay out one uncut 2x4, this will be the top of the board (B in the picture above). Put the one each of the legs on each side, like in the picture are the bottom and top of the plexiglass and the legs. The bottom 2x4 (C in the picture) lays down basically 4 feet down the legs.

Lay the plexiglass on top. Here's a tip: if you want to look a little more professional (I figured this out too late!) put the plexiglass a little below the top of the top 2x4. This creates a channel that the LED strip can pop into nicely.

You should have something that looks a bit like the picture!

Repeat the 2x4s so that you sandwich the plexiglass. It'll be something like the picture above (which has one leg missing).

Now it's time to do a bit of drilling... Safety glasses please!

Step 2: Drill the Holes

Get yourself a drill and a 1/4 inch drill bit for wood. If the bolts you are using are wider in diameter than 1/4 inch, well, you know what to do.

You are going to drill through the top 2x4, the plexiglass, and the bottom 2x4. My garage floor is concrete so I didn't fancy drilling into that with a wood drill bit, so I put a stop on the bit with the result that the drill went down 3 and 1/8 of an inch. This requires a bit of fiddling later, but it wasn't that big off a deal. If you have a better idea, feel free to share/use it.

The plexiglass is flexible. If you have a spare bit of 2x4 (you should from the cuts you made in the first step) you can put it in the middle of all of this while you drill so that it doesn't sag. It does make a difference, yes.

Here's what I should probably have done:

  • Drill a hole in the top right corner (the top of the right leg) around 1 3/4 inches down and 1 3/4 inches from the edge
  • Do the same for the right leg
  • Measure 6 inches in from these holes and drill two more. You should have 4 which you can drop bolts into. There's no need to fix them, they are just there to keep things straight...
  • Now, measure along the top, evenly distributing the holes so that it looks nice (!) and head to the Legs!

This is what I did:

  • At all times, make sure the plexiglass doesn't move for this step!
  • Measure the length of the top. It should be 8 feet but it never hurts to measure
  • Divide along the top by the number of bolts you would like to put in. In my board there are 17 across the top, so the distance between them is around 6 inches (since that gets me to 96, but I fudged a bit at the ends - it all works out in the end!
  • Mark where you are going to drill at each spot along the top of the board.
  • Drill your holes along the top. You will drill through wood, then crush as you drill through plexiglass, then the wood underneath
  • Proceed, having learnt something (like, do what I suggest above instead)

The procedure for the bottom and legs is similar. The best way to do it is to drill 2 inches in at the bottom of the plexiglass (see picture), plop in a temporary bolt, and then drill every 6 inches up to the top. Do this on both sides, and you should have something that has top and sides all drilled.

At this point, you can drill holes along the bottom edge. I would do this like the top - a hole at each end, put bolts through to hold in place, then holes every six inches all the way along. The next bit involves a bit of dismantling, sorry!

There is probably a much better way to do this. Apologies and all suggestions welcome.


If you put the drill stop correctly, you will have drilled through the top stud, the plexiglass and most of the bottom stud. Of course, the hole needs to go all the way through, so I took the top 2x4s off – remember the orientation! – and put the plexiglass in a safe position. Then you can pick up the studs from the bottom and safely drill holes all the way through. Then put them back down on the ground in the right position. It's time to put the bolts in properly!

Step 3: Bolts!

The holes you just drilled are for a lot of bolts to hold the structure together. I used carriage bolts, and they need to be around 3.75 inches long (2 1.5 inch studs and a 1/8 inch piece of plexiglass). Lay the studs down in the correct orientation first, so that when you put the plexiglass down it will lie on something other than the floor

Start with the bottom edge. For each hole in the bottom stud, insert a bolt *from the bottom* (see the picture for the rough idea). Then put a bolt in from the bottom at the bottom hole of each leg.

Lay the plexiglass down carefully, and if you have the studs and glass oriented the same as you drilled before, you should be able to thread the bolts through the corresponding holes in the glass.

Plexiglass is pretty flexible, so the next bit is okay... Put holes through from the bottom for both legs, and pass them through the plexiglass. Then do the same for the top edge. I do it in this order because it is easier to get at the top edge than the bottom when putting the bolts in at that last bit.

You should have something resembling this:

Now you can put the top layer of studs on and thread the bolts through their appropriate holes. Pop on the washers for each bolt. Screw on the nuts and tighten them appropriately.

Give yourself a hand, the hard bit is mostly done!

Step 4: Leg Base

It is best if you have someone to help you for this - the beast is big and heavy!

Stand it up straight. Take a couple of lengths of wood and screw them into the base of each of the legs as in the picture, so that it doesn't fall over – in the diagram above they are the blue things at the base. (I used the cut offs from the leg lengths for this. It's not as strong as it could be but it works (and I was able to secure the board to the ceiling/wall afterwards anyway).)

The construction part is done!

Step 5: Attach the Lights

Lightboards work with TIR, so you need a string of LED lights across the top edge of the glass, shining down into the glass, to make this bit work.

We'll worry about the electronics in a moment, let's just put the LED strip on.

If you followed the advice in the previous steps, you should have a small groove between the studs at the top of the lightboard, in which the glass is. You can lie the LED strip into this groove. I put the data line at the left because it made sense to me. Your call where you put it. Likewise for power. Note, this is a long strip so you will need more power than the micro-controller can give you to make it work. The materials section has the transformer I used. Cut the strip at the proper place - preferably where there is a solder joint. You will use the leftover bits shortly. The first diagram above shows where the strip goes – the line that is black (neg) in the diagram is white on the LED strip I used.

Route the power and data cables to the side of the board and leave them there a while.

You will need lights to light yourself up as you talk. It's possible to use the lightboard without but that kind of ruins the point, since the point is to see both you and the writing as you write!

I used the rest of the LED strip. I cut it into 2 pieces - one has a length almost as long as the top of the board, the other a much shorter length. If you have the controllers on the left, as I did, solder in data and power wires for the top strip, and a data wire from the top long strip to the bottom shorter one. You can attach these strips to the board as in the picture. The bottom of the strips can have its own power lines since you can power LED strips from pretty much anywhere along the line – see the second diagram...

Step 6: Power

Do be careful when wiring this up... It's really not a good idea to be electrocuted.

I attached the transformer to the left hand side of the board, on the lower edge of the left leg). This transformer has 2 different outputs for LED lights but I only used one. Fortunately the electronics are happy with 5 volts if you use a Pi Pico, so that's kind of nice.

Connect all the power lines together - red with red and white with white. Tie in a spare red and white cable, you will need this to power the electronics. Leave the data lines hanging for a second.

You should be left with what I have in the conceptual drawing for the wires, above.

You can wire up the transformer, just don't plug it in yet. Next, wire in the power wire bundle to the transformer. You should now have:

  • LED strip facing into the glass of the board
  • LED strips facing you (one top and one bottom)

With power lines connected to the transformer. You also have a spare set of power lines (lucky!) and 2 data lines - one for the board itself and one for the lights facing you. If you are not sure refer to the conceptual drawing for the wires above.

Step 7: Control! Part 1: Solder Your Picos!

This requires:

  • 2 Raspberry Pi Picos, 2 sets of headers for the Picos
  • 2 sets of 3 pin headers (you will see)
  • 2 one pin headers (you will see for those too!)
  • 2 Waveshare 1.14 inch displays (which have 4 tiny little happy buttons)
  • Data cables leading from the LED strips
  • Power cables leading from the transformer.

Picture:

Picos come without pins attached. You will need a full set to plug into the displays, even if they only use a few. There are plenty of places that show you how to solder so I don't need to. Make sure you do it safely, with plenty of ventilation. Use a breadboard to hold the headers while you solder.

You need to power these little beasties. Fortunately you can power the Pico with 5V at pins Here's what I did to allow that to happen whilst the Waveshare displays were plugged in... The pinout diagram is here, courtesy of https://www.raspberrypi-spy.co.uk/2021/01/pi-pico...

You can power the Pico without plugging in a USB cable. I got this from here: https://www.raspberrypi.org/forums/viewtopic.php?...

Pin 39 (VSYS) takes 5 Volts in to power the Pico. You need to carefully solder a single pin to this one on the opposite side (the top) of the Pico from the headers. It will begin to resemble a small hedgehog...

Pin 1 (GPIO 0) will be used to control the LED strips (their data lines). Pin 3 (GND) is a ground pin. We can use that. With some care, solder the three pin headers to the *top* of the pico at pin 0, 1 and 2. We won't use pin 1, but whatever.

There is almost certainly a way to control all this with one Pico but I wanted to have all 4 buttons available for each set of LED strips which, as it happens, was a good idea.

You should have something that looks a lot like the picture for this step.

Now we are cooking with gas...

Step 8: Control! Part 2: Coding the Lightboard Lights

For controlling the LED strips I used pretty basic MicroPython code. To get the Pico to run MicroPython code you will need to flash firmware onto it. This is pretty straightforward and documented here: https://www.raspberrypi.org/documentation/rp2040/...

In the interests of completeness, I repeat much of it below.

Holding the BOOTSEL button on the Pico (see the diagram here: https://www.raspberrypi-spy.co.uk/2021/01/pi-pico... plug it into your computer. This computer can be pretty much anything - a Raspberry Pi is actually a good one. The Pico will appear as a USB drive on the system.

You can download the latest firmware image from here: https://micropython.org/download/rp2-pico/ . Download the latest version and drag the uf2 file to the Pico USB drive. Once this is done the Pico will automatically drop the USB connection (and your computer will undoubtedly tell you this is a bad idea, but it's okay here).

You will need to write a bit of code, so the next step is to install the Thonny editor on your system. Thonny is a great little IDE for this purpose, and has the library built in to connect properly to the Pico. You can grab it from here: https://thonny.org/. Install it on your system, fire it up, click on Run and Select Interpreter. Choose MicroPython (Raspberry Pi Pico). Connect to the Pico and if Thonny doesn't spot it right away, click the Stop button and all should be well. You're ready to code the MicroPython too control the LEDs.

I adapted code from here: https://core-electronics.com.au/tutorials/how-to-... because it is always good to use sensible code from elsewhere! The trick is to use correct timing to control the LEDs, since there is one data line. The Pico has some State Machines to provide perfect timing whilst not stressing the CPU. The code for that looks like this (don't ask me what it is really doing)

@asm_pio(sideset_init=PIO.OUT_LOW, out_shiftdir=PIO.SHIFT_LEFT,
autopull=True, pull_thresh=24)
def ws2812():
    T1 = 2
    T2 = 5
    T3 = 3
    label("bitloop")
    out(x, 1) .side(0) [T3 - 1]
    jmp(not_x, "do_zero") .side(1) [T1 - 1]
    jmp("bitloop") .side(1) [T2 - 1]
    label("do_zero")
    nop() .side(0) [T2 - 1]

# Create the StateMachine with the ws2812 program, outputting on Pin(0).
sm = StateMachine(0, ws2812, freq=8000000, sideset_base=Pin(0))
# Start the StateMachine, it will wait for data on its FIFO.
sm.active(1)<br>

The LCD display from Waveshare has its own Class to control what it does and looks like, which is also in the file below. The Waveshare Wiki for the display is here: https://www.waveshare.com/wiki/Pico-LCD-1.14. Click on Resources for demo code that was used and adapted below.

The entire code for the lightboard contains the above. You can copy and paste into the Thonny IDE. Save it on your desktop computer for a backup, then save it to the Pico as "main.py" - anything called main.opy will automatically run when the Pico is powered up, which is what we want.

Before you finish, mark the Pico with an L someplace in permanent marker. You will thank me later.

You can download this from http://stephenmarsh.wikidot.com/local--files/ligt...

## Code to control lightboard. Configure using the right number of LEDS is NUM_LEDS, 
## and change the text for the LCD display below. 
## Uses Pi Pico microcontroller 
## https://www.raspberrypi.org/products/raspberry-pi-pico/
## Uses Waveshare 1.14 inch LCD display for Pico
## https://www.waveshare.com/pico-lcd-1.14.htm 
## (there are different versions, the one used here is the one with 4 buttons, 
## 2 to each side, you may have to change the code for different configurations)
## Waveshare wiki for display: https://www.waveshare.com/wiki/Pico-LCD-1.14 
## has sample code which is adapted here.
## Other code for LED controls from 
## https://core-electronics.com.au/tutorials/how-to-use-ws2812b-rgb-leds-with-raspberry-pi-pico.html
## Unless otherwise enoted in other code, this is licensed Creative Commons 
## Attribution NonCommercial ShareAlike
## https://creativecommons.org/licenses/by-nc-sa/4.0/
##
## Version 0.1, pretty basic!
## Steve Marsh, 2021: stephen.marsh.2008@gmail.com


from machine import Pin,SPI,PWM
import framebuf
import array, time
import rp2
from rp2 import PIO, StateMachine, asm_pio

# Configure the number of WS2812 LEDs.
NUM_LEDS = 287 ## You need to change this for the number of LEDS in your own strip
# LED brightness from 0 to 1
brightness=1

@asm_pio(sideset_init=PIO.OUT_LOW, out_shiftdir=PIO.SHIFT_LEFT,
autopull=True, pull_thresh=24)
def ws2812():
    T1 = 2
    T2 = 5
    T3 = 3
    label("bitloop")
    out(x, 1) .side(0) [T3 - 1]
    jmp(not_x, "do_zero") .side(1) [T1 - 1]
    jmp("bitloop") .side(1) [T2 - 1]
    label("do_zero")
    nop() .side(0) [T2 - 1]

# Create the StateMachine with the ws2812 program, outputting on Pin(0).
sm = StateMachine(0, ws2812, freq=8000000, sideset_base=Pin(0))
# Start the StateMachine, it will wait for data on its FIFO.
sm.active(1)

# Display a pattern on the LEDs via an array of LED RGB values.
pixel_array = array.array("I", [0 for _ in range(NUM_LEDS)])


############################################
# Functions for RGB Coloring
############################################

def updatePixel(brightness): # dimming colors and updating state machine (state_mach)
    dimmer_array = array.array("I", [0 for _ in range(NUM_LEDS)])
    for ii,cc in enumerate(pixel_array):
        r = int(((cc >> 8) & 0xFF) * brightness) 
        g = int(((cc >> 16) & 0xFF) * brightness) 
        b = int((cc & 0xFF) * brightness) 
        dimmer_array[ii] = (g<<16) + (r<<8) + b 
    sm.put(dimmer_array, 8) # update the state machine with new colors
    
def set_led_color(color):
    for ii in range(len(pixel_array)):
        pixel_array[ii] = (color[1]<<16) + (color[0]<<8) + color[2]

#Color based on RGB (R,G,B)
red = (255,0,0)
green = (0,255,0)
blue = (0,0,255)
white = (255,255,255)

#########################################
# Class for the Waveshare display
#########################################
BL = 13
DC = 8
RST = 12
MOSI = 11
SCK = 10
CS = 9

LEDPIN=25

KEY_PRESSED=0

led_onboard = machine.Pin(LEDPIN, machine.Pin.OUT)


class LCD_1inch14(framebuf.FrameBuffer):
    def __init__(self):
        self.width = 240
        self.height = 135
        
        self.cs = Pin(CS,Pin.OUT)
        self.rst = Pin(RST,Pin.OUT)
        
        self.cs(1)
        self.spi = SPI(1)
        self.spi = SPI(1,1000_000)
        self.spi = SPI(1,10000_000,polarity=0, phase=0,sck=Pin(SCK),mosi=Pin(MOSI),miso=None)
        self.dc = Pin(DC,Pin.OUT)
        self.dc(1)
        self.buffer = bytearray(self.height * self.width * 2)
        super().__init__(self.buffer, self.width, self.height, framebuf.RGB565)
        self.init_display()
        
        self.red   =   0x07E0
        self.green =   0x001f
        self.blue  =   0xf800
        self.white =   0xffff
        
    def write_cmd(self, cmd):
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)

    def write_data(self, buf):
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(bytearray([buf]))
        self.cs(1)

    def init_display(self):
        """Initialize dispaly"""  
        self.rst(1)
        self.rst(0)
        self.rst(1)
        
        self.write_cmd(0x36)
        self.write_data(0x70)

        self.write_cmd(0x3A) 
        self.write_data(0x05)

        self.write_cmd(0xB2)
        self.write_data(0x0C)
        self.write_data(0x0C)
        self.write_data(0x00)
        self.write_data(0x33)
        self.write_data(0x33)

        self.write_cmd(0xB7)
        self.write_data(0x35) 

        self.write_cmd(0xBB)
        self.write_data(0x19)

        self.write_cmd(0xC0)
        self.write_data(0x2C)

        self.write_cmd(0xC2)
        self.write_data(0x01)

        self.write_cmd(0xC3)
        self.write_data(0x12)   

        self.write_cmd(0xC4)
        self.write_data(0x20)

        self.write_cmd(0xC6)
        self.write_data(0x0F) 

        self.write_cmd(0xD0)
        self.write_data(0xA4)
        self.write_data(0xA1)

        self.write_cmd(0xE0)
        self.write_data(0xD0)
        self.write_data(0x04)
        self.write_data(0x0D)
        self.write_data(0x11)
        self.write_data(0x13)
        self.write_data(0x2B)
        self.write_data(0x3F)
        self.write_data(0x54)
        self.write_data(0x4C)
        self.write_data(0x18)
        self.write_data(0x0D)
        self.write_data(0x0B)
        self.write_data(0x1F)
        self.write_data(0x23)

        self.write_cmd(0xE1)
        self.write_data(0xD0)
        self.write_data(0x04)
        self.write_data(0x0C)
        self.write_data(0x11)
        self.write_data(0x13)
        self.write_data(0x2C)
        self.write_data(0x3F)
        self.write_data(0x44)
        self.write_data(0x51)
        self.write_data(0x2F)
        self.write_data(0x1F)
        self.write_data(0x1F)
        self.write_data(0x20)
        self.write_data(0x23)
        
        self.write_cmd(0x21)

        self.write_cmd(0x11)

        self.write_cmd(0x29)

    def show(self):
        self.write_cmd(0x2A)
        self.write_data(0x00)
        self.write_data(0x28)
        self.write_data(0x01)
        self.write_data(0x17)
        
        self.write_cmd(0x2B)
        self.write_data(0x00)
        self.write_data(0x35)
        self.write_data(0x00)
        self.write_data(0xBB)
        
        self.write_cmd(0x2C)
        
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(self.buffer)
        self.cs(1)
  

def show_LED(value):
    led_onboard.value(value)
    
def hide_LED():
    led_onboard.value(0)
    

if __name__=='__main__':
    pwm = PWM(Pin(BL))
    pwm.freq(1000)
    pwm.duty_u16(32768)#max 65535
    
    led_val = 0
    brightness = 1 ## As bright as it can be
    set_led_color(white) ## The white LED is best for the lightboard
    updatePixel(brightness) ## Turn on the LED strip for the lightboard
 
    ## Set up the LCD display
    LCD = LCD_1inch14()
    #color BRG
    LCD.fill(LCD.white)
 
    LCD.show()
    ## Simple user instructions. 
    ## Each key does a separate thing - tun on or off, increase or decrease brightness
    LCD.text("Lightboard!",25,40,LCD.red)
    LCD.text("Key 0=Off Key 1=On",25,60,LCD.green)
    LCD.text("Key 2=Dim Key3=Brighten",25,80,LCD.blue)
    
    
    
    LCD.hline(10,10,220,LCD.blue)
    LCD.hline(10,125,220,LCD.blue)
    LCD.vline(10,10,115,LCD.blue)
    LCD.vline(230,10,115,LCD.blue)
    
    
    LCD.rect(12,12,20,20,LCD.red)
    LCD.rect(12,103,20,20,LCD.red)
    LCD.rect(208,12,20,20,LCD.red)
    LCD.rect(208,103,20,20,LCD.red)
    
    LCD.show()

    ## The Keys are connected to the following pins
    key0 = Pin(15,Pin.IN)
    key1 = Pin(17,Pin.IN)
    key2 = Pin(2 ,Pin.IN)
    key3 = Pin(3 ,Pin.IN)

    ## The main loop.
    while(1):
        if(key0.value() == KEY_PRESSED): ## Turn off the LED strips (0 brightness)
            LCD.fill_rect(12,12,20,20,LCD.red)
            brightness = 0
            updatePixel(brightness)
        else :
            LCD.fill_rect(12,12,20,20,LCD.white)
            LCD.rect(12,12,20,20,LCD.red)
            
        if(key1.value() == KEY_PRESSED): ## Max brightness for LEDs
            LCD.fill_rect(12,103,20,20,LCD.red)
            brightness = 1
            updatePixel(brightness)
        else :
            LCD.fill_rect(12,103,20,20,LCD.white)
            LCD.rect(12,103,20,20,LCD.red)

        if(key2.value() == KEY_PRESSED): ## Decrease brightness by 10%
            LCD.fill_rect(208,12,20,20,LCD.red)
            brightness -= 0.1
            if brightness < 0:
                brightness = 0
            updatePixel(brightness)
        else :
            LCD.fill_rect(208,12,20,20,LCD.white)
            LCD.rect(208,12,20,20,LCD.red)
            
        if(key3.value() == KEY_PRESSED): ## Increase brightness by 10%
            LCD.fill_rect(208,103,20,20,LCD.red)
            brightness = brightness + 0.1
            if brightness > 1 :
                brightness = 1
            updatePixel(brightness)
        else :
            LCD.fill_rect(208,103,20,20,LCD.white)
            LCD.rect(208,103,20,20,LCD.red)
        LCD.show()
        ## end of main loop. Basically, unplugging everything turns it all off
        ## A proper on/off switch would be nice, for sure...
       
    time.sleep(1)
    LCD.fill(0xFFFF) ## clear the screen<br>

Step 9: Control1 Part 3: Coding the Lighting to Light You Up!

The second Pico controls the lights on you, the "talent". The code is basically a copy of the control code for the LED strip for the lightboard. The only change is the text on the LCD display. Set up the second Pico as the previous step, copy and paste the code in via Thonny and save as main.py. Be sure to change the NUM_LEDs value to the total count of LEDs in the top and bottom strips facing you. You can change the text where it says "Lightboard" to something like "Talent" at this line:

<pre>    LCD.text("Lightboard!",25,40,LCD.red)

Step 10: Control! Part 4: a Box to Hold It All

Unplug the Picos from the desktop if you haven't already. They are ready to run!

You will need something in which to hold the Picos on the side of the board so that you can control it as you stand there - basically increase, decrease brightness... I'm sure I will addd extra functionality as time goes by, but this will do for now.

You can 3D print a box. I used a cardboard box and cut out holes the same size ad the headers on the LCD displays, so that they could tightly fit through. You will need 2 such holes. Plug in the Picos from the back, and they should all fit snugly - the picture shows how.

Put in another hole for the power and data lines. Run them through. You will need to splice the power lines for the 2 Picos, and then plug the red cables into the pin at 39, the white ones into the pin at 3, and the data (green) to pin 1 (GPIO 0). Remember which one is for which LED strip. I put the lightboard one at the top and the talent one at the bottom. This is where that "L" you marked comes in useful!

The whole looks a bit like the picture, except for some reason the red wires are purple (I remember! It's the cable I had!).

I used a bit of electrical tape to hold the cables on the pins as they were a bit loose... Sure, it's not pretty. When I 3D print the box I will upload a nicer picture!

Close up the box, you're done.

Step 11: Turn It On

You should just be able to plug in the transformer, which will power Picos and LED strips. All being well, the lightboard will light up!

How do you write on it? Use Expo Neon markers. They are a little greasy so be careful when you are wiping them off. Plexiglass scratches fairly easily too. I found that a screen cleaning cloth was great at keeping scratches down when erasing. The Expo whiteboard eraser, for me, created microscratches I didn't like at all (you can see them in the picture, but in the lectures and so on they don't show up much at all).

The next steps cover cameras and sound. If you just wanted a Lightboard you could stop here but I needed something to teach with, which involves cameras and OBS. Here we go, if you want to follow along...

Step 12: To Lecture With, You Need a Camera

This bit is actually pretty straightforward.

I use an iPhone for a camera – the picture quality is far superior to a webcam. First, I needed a place to mount it. And a means to do so. Fortunately on Thingiverse there is a wonderful modular mounting system I was able to use bits of – see https://www.thingiverse.com/thing:219427

For this I printed a phone clamp, an arm (straight) and then got stuck cos I needed put it on the wall. Thingiverse to the rescue again with https://www.thingiverse.com/thing:4409006

And then, to make it so that the camera was infinitely adjustable, this: https://www.thingiverse.com/thing:4791004

The final assembly, attached to the wall behind the lightboard (on the opposite side from the LED strips facing you) looks like the picture above.

Step 13: And You Need a Computer, Because You Are Writing Backwards!

The camera faces your, and you are on the other side of the lightboard (see my beautiful drawing!). This naturally means that when you write, the camera will see the words backwards. You can fix this in OBS.

OBS studio (https://obsproject.com) is a must have for anyone who even thinks of streaming stuff, but I should say it is probably a must have for anyone who video conferences. It's a free download, so go grab it and install on your device, which by now should also have an iPhone camera (or whatever camera you use) attached to it via a USB cable. You can download the Camera for OBS Studio app (see https://obs.camera) if you are using an iPhone in order to get the best quality, and install on the phone you are using for the camera.

You will need sound too. I use this: https://www.amazon.ca/gp/product/B08DV5NJJM – it works well with the Mac and OBS and it lets me walk around and talk, which I like to do.

Start up OBS, create a new scene, connect the camera and the microphone in OBS (an example scene looks like the picture above).

When that's set up. you will have your lightboard finished... You can stream or use the OBS Virtual Camera in order to feed the OBS output through to Zoom, Meets, or pretty much any video-conferencing service you please.

You will need a green screen or a dark curtain behind you. OBS will chromakey the green screen out for you and you can put whatever you like on it. I tried this and had mixed results because it wasn't great at showing the text on the lightboard if I wasn't careful, so I settled for a black curtain, which is shown in the drawing.

I needed something to put the markers in, so I designed and printed the attached clip (penclip2.stl) which simply slides on to the 2x4 at the bottom (see the image for the Marker Holder). If you would prefer to attach that to the wall, the attached pen-wall-smile.stl file will be the one you need.

And it looks like the picture at the top of this Instructable (yes, that's me!)

You are done. Enjoy and if you have any questions, please ask. This is my first Instructable, so all suggestions welcome.

My next project is to make it smaller, and to make a big one that just attaches to the wall – I have a whiteboard but the lightboard for some reason helps me bring out ideas better...

Be the First to Share

    Recommendations

    • Meatless Challenge

      Meatless Challenge
    • Fabric Challenge

      Fabric Challenge
    • Eggs Challenge

      Eggs Challenge

    15 Comments

    0
    andrea biffi
    andrea biffi

    1 year ago on Step 13

    Awesome and really useful project! I also teach online and I would have had this before!

    0
    smarsh123456789
    smarsh123456789

    Reply 1 year ago

    Thanks Andrea! I'd love to hear more about the kinds of tools you use in your practice. I'm currently building a small light board (which is much easier and cheaper) and if you are interested can let you know how it goes.

    0
    andrea biffi
    andrea biffi

    Reply 1 year ago

    I'm teaching physics in middle and high Waldorf schools. I had to show experiments, write descriptions, discuss the process, and I obviously try to remain always visible to students. Sharing screen is not always the better solution, since my face will be probably seen quite small. Your transparent board will be great!
    And mirroring the screen will solve the difficult to write backwards! Yes, please let me know how it will work.

    0
    Andrewest93
    Andrewest93

    Question 1 year ago on Introduction

    But the only thing is "How fast can I learn to write in Mirror Image?"
    It is fairly easy to do (I've now discovered), but numbers confuse me at times!
    Just need to practice. Any ideas on how to traverse the learning curve quickly?

    0
    BreakingTheExpectations
    BreakingTheExpectations

    Answer 1 year ago

    what about using a mirror just behind the lightboard (stuck to it)?!? I would not like at all having to think about writting sidewards or reversed...

    0
    smarsh123456789
    smarsh123456789

    Reply 1 year ago

    No need - as my reply below says, OBS will flip the image for you so you can write normally and the image sent out from the camera is reversed (therefore people see the right way round writing)

    0
    smarsh123456789
    smarsh123456789

    Answer 1 year ago

    Hi Andrew
    If you use OBS, you can flip the image (I am sorry, I may have missed that bit in the Instructable) - just write normally and the software does the rest. I use iOS camera (the link is above) but any webcam would do, and OBS will do the rest. At a rough guess there are likely other bits of software out there which will do the same thing though, if you need something less complex (to be honest OBS is pretty straightforward though). Happy to help if you need it!

    0
    EricK106
    EricK106

    1 year ago

    Great idea - couple of thoughts though, why couldn't you just use pwm led dimmers to control brightness?
    Also try using headlight restorer as your screen cleaner, not only will it not scratch the plexi over time it will polish the plexi to make it even clearer and take out the minor scratches that are there. I use this on both my airplane and boat windscreen and they look great after 50+ year on them. I forget the name of the stuff I use but it is in the black bottle with blue top (think it's mothers.)

    0
    smarsh123456789
    smarsh123456789

    Reply 1 year ago

    Hi Eric
    Could do it that way with the LEDs, yep. I am sure I've made it far too complex (which is a fault of mine!) - I have been thinking about potential since the first time I was asked this question and I have a couple of ideas for a completely different use of the board that might be interesting with individually controlled LEDs. Less teaching and more art, possibly.

    I'll have a look for the restorer, it sounds like exactly what I need (also for my motorcycle windshield!)

    0
    abenn666
    abenn666

    1 year ago

    I don't know if I missed it in the article, but how come you used the addressable LED strips which need a microcontroller, and not just a simple LED strip and on/off switches ?

    0
    smarsh123456789
    smarsh123456789

    Reply 1 year ago

    Hi,
    You didn’t miss it. It is entirely possible to do this with switchable LEDs. The microcontroller allows me to adjust the brightness of all the LEDs, which is useful for me when I am lecturing - there are occasions when I want to dim the light on me to allow better focus on the board’s content. Plus I find them very bright when on full (my eyes get tired!). I did have some thoughts about adjusting hue also, since it may be interesting. To be honest, your call :-) it would make the process a little simpler.

    As to if the board itself needs to be dimmable, again that’s really a preference thing. I sometimes find dimming it easier on the eyes too.

    Plus, I had some addressable LEDs so wanted to have a bit of fun and an interesting experiment with the Picos… the end result is simple enough to work and controllable enough to be interesting for me.

    0
    smarsh123456789
    smarsh123456789

    Reply 1 year ago

    Nice! Thanks for the idea! I may very well use that.

    0
    smarsh123456789
    smarsh123456789

    Reply 1 year ago

    Thanks! I had fun making it. It's become a really natural way for me to teach now too. Almost (!) like being in the lecture theatre. I will check out the YouTube channel though, it sounds really interesting.