2 January 2024
So I decided to try my hand at making an Arduino work with a Display screen. My plan is to make a small display for my wife as a Valentine’s gift. Let’s see how it goes.
Plan is a simple Seeduino Xiao and I2C driven display. Not unlike what I did at Detechtion. The hard thing is going to be the libraries, but let’s see how this goes.
Basic hookup was straightforward. Pinout is shown at https://wiki.seeedstudio.com/Seeeduino-XIAO/. Just the (I2c) SCK and SDA plus ground and 5V supply. The Arduino IDE did connect to the Xiao natively, but I needed to go through the exercise of adding a udev rule (basically to give my user account permission to use the device). lsusb and dfu-util are invaluable here to tell what the usb values are and what user/root can do. Easiest way to resolve this is to log in as root, try those, verify the devices are accessible and then replicate the issue.
Stumbling block: I ordered the SSD1315… Looks like all the libraries are for the SSD1306.
The ssd1306led library uses what I presume are much older Arduino base libraries, so they will be helpful as a reference.
The ssd1306led library has the init sequence. I can steal that and improvise some code for testing just to make sure everything is working.
BOOM! At least we can turn the thing on. However the init sequence needs some work. A good test is “powercycling”… I found the powerup wasn’t very robust.
What is the difference between the 1306 and the 1315? Looking at the 1306 Datasheet and the 1315 Datasheet, a few things are apparent:
- 1315 is the controller chip number. The display itself is the same and they just named the assembly after the controller chip.
- There is no more memory on the chip than the size of the display. There is a lot of talk about “pages”, but those are columns of 8 pixels. The 128×64 display is a 128-pixel wide group of eight “pages” of 8 bits each (the LSB is the top of the page). That is surely done so you can render text fonts horizontally.
- The differences seem to be in the charge pump control and a couple scrolling commands. Those shouldn’t impact us. A charge pump is used when you need a higher voltage than the supply voltage but only for a very short period of time (such as programming a flash).
Got a basic line pattern but that flickering is annoying:
https://rogerpease.com/Videos/1315DisplayFlicker.mov
Flickering is caused often by (among other things) overscanning and excess power use, etc. I decided to play with the multiplier, divider, contrast and precharge settings.
I changed the PLL multiplication/divide lower:
Looks much better!
https://rogerpease.com/Videos/1315DisplayFlickerFixed.mov
Here are the final settings (well, check my dev repo)
And do a checkerboard to verify all looks well:
And it looks good:
OK, so now I can make it do what I want.
I still have only used about 13% of my (program) memory.
Next steps are to plan the messages. I’ve been working on a case with my cousin Troy who is into 3D printing.
Fonts are easy. I leveraged font8x16.h and built a simple message pretty easily.
Age old question: Do I try to debug the other libraries and offer my solution as a patch or do I build my own library? Since my needs are simple enough (text and hearts) I will do my own quickly then test with the established libraries to see if I can improve them for this case.
Since this is a Valentine’s day gift I’d like to do a Heart. A font character heart is reasonably simple. A larger heart is a little more complicated but I found a simple algorithm and adapted it:
Looking pretty good. Now I need power. I don’t want to power this with a USB plug because of a) cords and b) too much risk of damage if a short occurs. A small voltage regulator https://www.amazon.com/dp/B07CP4P5XJ?ref=ppx_yo2ov_dt_b_fed_asin_title should give me 3.3V which should work for the display and the SAMD21. A small $3 box https://www.amazon.com/gp/product/B07T83B4SW/ref=ppx_yo_dt_b_asin_title_o00_s00?ie=UTF8&psc=1 will provide leads and a switch and a 9V battery holder. Not sure how long it will last but it’s not a 24/7 app.
Now I just need to finish coding my messages and assemble this baby. My cousin Troy and his wife Wendy fortunately own a 3D Printer and have their own small business so I’ve been working with them. They made me a really nice heart shaped box.
Amazon has some 1″x1″ circuit boards so I could put all the parts together. I haven’t soldered in years but I didn’t need to be that accurate.
Things that went surprisingly well:
- Bringup of I2C interface. I2C is pretty robust (although slow, but it has its reasons for that).
- Display bringup was a little more complicated since it’s a 1315 not a 1306 but I made it work reliably.
- The heart and fonts worked very well. Speed of the microcontroller was more than adequate for my needs.
- Using TDD really helped. I have a rule with embedded systems that you test as little of the embedded software on the embedded system as you can.
Other impediments I hit:
- The XIAO SAMD21 bootloader is a bit finicky. I had to short the reset to ground a few times to make it work. I was worried at one point I had corrupted the bootloader but it looks like I am okay.
- When I first got the card the USB cable didn’t work. It turns out the USB cables you get with those earbuds don’t necessarily have the data connections.
- I mentioned the udev above. When you plug in a USB device a new device entry in /dev is created. /dev entries follow the same permissions structure as files but you can’t do chmod/chown on the device until it’s been created and once it’s removed and reinserted you have to do it over again. Hence the udev rules.
- Turned out I had sent my cousin the wrong Amazon link (blasted copy-and-paste). The actual display used was a SSD1106. Minor tweak to the program and I was back in business!