Pi Controlled NeoPixel Ring

Leave a Reply

OK, so not 100% accurate; a Pi controlled Adafruit Trinket controlled NeoPixel ring 😀

I got the idea from seeing Dave Whale’s serial based Arduino interface with the Pi. The Trinket doesn’t have serial so I had to use something else to talk to it.

Enter I²C;  on the Trinket side I’m using the TinyWireS library, on the Pi side I’m calling smBus.writeList() with a list of the bytes I wish to send.  You’ll notice in the video there’s an extra breakout in the circuit, this is a bi-directional level converter to allow the 5v Trinket to talk to the 3.3v Pi without releasing any magic smoke.

My aim is to implement the commands in the Neopixel library however at the moment it just calls setPixelColor with the 4 values (LED, Red, Green, Blue) provided by the Pi. I have a special case of LED==0xFF which lights all LEDs the specified colour (a concept I have pinched from David).  I have included the code below in it’s current (probably hacky) state.

One problem I did find is that the Pi randomly “loses” the I²C address of the Trinket and reports it as 0x03 for a second or two.  I’m not sure if the problem is the Pi or Trinket end but it seems to be an issue with Arduinos in general.  The basis of the work around I used in my Python code can be found here. If anyone knows the reason for this I would be most grateful; it’s a horrible hack

Arduino 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

#include <TinyWireS.h>
#include <Adafruit_NeoPixel.h>
 
#define PIN 1
#define I2C_SLAVE_ADDRESS 0x04
 
// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, PIN, NEO_GRB + NEO_KHZ800);
 
// The default buffer size, Can't recall the scope of defines right now
#ifndef TWI_RX_BUFFER_SIZE
#define TWI_RX_BUFFER_SIZE ( 16 )
#endif
 
int rxIndex = 0; 
 
volatile uint8_t i2c_regs[] =
{
    0x0, // RegisterID
    0x0, // Pin
    0x1, // R
    0x0, // G 
    0x0, // B
};
const byte reg_size = sizeof(i2c_regs);
 
//Handles receiving i2c data.
void receiveEvent(uint8_t howMany)
{
    if (TinyWireS.available()){  
      if (howMany < 1)
      {   // Sanity-check
          return;
      }
      if (howMany > TWI_RX_BUFFER_SIZE)
      {   // Also insane number
          return;
      }
 
      if (howMany == 1)
      {   // This write was only to set the buffer for next read
          return;
      }
      rxIndex = 0;
      while(howMany--)
      {   //Gets i2c data. 
          i2c_regs[rxIndex] = TinyWireS.receive();
          rxIndex++;
          if (rxIndex >= reg_size){
            if (i2c_regs[1] == 0xFF) {
              for (uint8_t p=0;p<strip.numPixels();p++){
                strip.setPixelColor(p,strip.Color(i2c_regs[2], i2c_regs[3], i2c_regs[4]));
              }
            }
            else {
              strip.setPixelColor(i2c_regs[1], strip.Color(i2c_regs[2], i2c_regs[3], i2c_regs[4]));    
            }
            strip.show();
            rxIndex = 0;
          } 
      }
 
    }
}
 
void setup() {
  TinyWireS.begin(I2C_SLAVE_ADDRESS);
  TinyWireS.onReceive(receiveEvent);
 
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}
 
void loop() {
  TinyWireS_stop_check();
}

Pi 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

import time
import smbus
import os
import subprocess
 
i2cBus = 0
i2cAddr = 0x04
bus = smbus.SMBus(i2Bus)
debug = False
 
def writeList(reg, list):
    sent = False
    attempt = 0
    while sent==False:
        if debug:
            print "I2C: Writing list to register 0x%02X:" % reg
            print list
        try:
            bus.write_i2c_block_data(i2cAddr, reg, list)
            sent = True
        except IOError:
            #a 'hack' to catch the Arduino disappearing at random intervals
            #runs i2cdetect to refresh the i2c interface, output to /dev/null so we don't see the output
            FNULL = open(os.devnull, 'w')
            retcode = subprocess.call(['i2cdetect', '-y', str(i2cBus)], stdout=FNULL, stderr=subprocess.STDOUT)
            time.sleep(0.1)
            attempt += 1
            if attempt == 10:
                raise Exception('Unable to connect via I2C')
 
def setLED(led, red, green, blue):
    bytes= [led, red, green, blue]
    writeList(0x01, bytes)
 
setLED(0xFF, 0, 0, 0)
time.sleep(0.5)
setLED(0xFF, 32, 32, 32)
time.sleep(0.5)
setLED(0xFF, 0, 0, 0)
 
try:
    while True:
        for p in range(0, 16):
            setLED(p, 32, 0, 0)
            time.sleep(0.1)
        for p in range(0, 16):
            setLED(p, 0, 32, 0)
            time.sleep(0.1)
        for p in range(0, 16):
            setLED(p, 0, 0, 32)
            time.sleep(0.1)
        for p in range(0, 16):
            setLED(p, 0, 0, 0)
            time.sleep(0.1)
except KeyboardInterrupt:
        pass
 
setLED(0xFF, 0, 0, 0)

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.