Skip to content

Instantly share code, notes, and snippets.

@wolph

wolph/sj1221.ino

Created April 2, 2018 11:19
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save wolph/0c78bb9b18ef88764244f63f1c5c9ee6 to your computer and use it in GitHub Desktop.
Save wolph/0c78bb9b18ef88764244f63f1c5c9ee6 to your computer and use it in GitHub Desktop.
Download ZIP
SJ1221 led strip test
Raw
sj1221.ino
/* vim: ts=8
Example code for the SJ1221 control protocol
Based on: http://wp.josh.com/2014/05/11/ws2812-neopixels-made-easy/
*/
// Change this to be at least as long as your pixel string (too long will work fine, just be a little slower)
#define PIXELS 96*11 // Number of pixels in the string
// color multiplier since we've got 0-4096 instead of 0-256
#define CM 16
// These values depend on which pin your string is connected to and what board you are using
// More info on how to find these at http://www.arduino.cc/en/Reference/PortManipulation
// These values are for the pin that connects to the Data Input pin on the LED strip. They correspond to...
// Arduino Yun: Digital Pin 8
// DueMilinove/UNO: Digital Pin 12
// Arduino MeagL PWM Pin 4
// You'll need to look up the port/bit combination for other boards.
// Note that you could also include the DigitalWriteFast header file to not need to to this lookup.
#define PIXEL_PORT PORTB // Port of the pin the pixels are connected to
#define PIXEL_DDR DDRB // Port of the pin the pixels are connected to
#define PIXEL_BIT 4 // Bit of the pin the pixels are connected to
// These are the timing constraints taken mostly from the WS2812 datasheets
// These are chosen to be conservative and avoid problems rather than for maximum throughput
#define T0H 350 // Width of a 0 bit in ns
#define T1H 700 // Width of a 1 bit in ns
#define T0L 950 // Width of a 0 bit in ns
#define T1L 600 // Width of a 1 bit in ns
#define RES 250000 // Width of the low gap between bits to cause a frame to latch
// Here are some convience defines for using nanoseconds specs to generate actual CPU delays
#define NS_PER_SEC (1000000000L) // Note that this has to be SIGNED since we want to be able to check for negative values of derivatives
#define CYCLES_PER_SEC (F_CPU)
#define NS_PER_CYCLE ( NS_PER_SEC / CYCLES_PER_SEC )
#define NS_TO_CYCLES(n) ( (n) / NS_PER_CYCLE )
// Actually send a bit to the string. We must to drop to asm to enusre that the complier does
// not reorder things and make it so the delay happens in the wrong place.
inline void sendBit( bool bitVal ) {
if ( bitVal ) { // 0 bit
asm volatile (
"sbi %[port], %[bit] \n\t" // Set the output bit
".rept %[onCycles] \n\t" // Execute NOPs to delay exactly the specified number of cycles
"nop \n\t"
".endr \n\t"
"cbi %[port], %[bit] \n\t" // Clear the output bit
".rept %[offCycles] \n\t" // Execute NOPs to delay exactly the specified number of cycles
"nop \n\t"
".endr \n\t"
::
[port] "I" (_SFR_IO_ADDR(PIXEL_PORT)),
[bit] "I" (PIXEL_BIT),
[onCycles] "I" (NS_TO_CYCLES(T1H) - 2), // 1-bit width less overhead for the actual bit setting, note that this delay could be longer and everything would still work
[offCycles] "I" (NS_TO_CYCLES(T1L) - 2) // Minimum interbit delay. Note that we probably don't need this at all since the loop overhead will be enough, but here for correctness
);
} else { // 1 bit
// **************************************************************************
// This line is really the only tight goldilocks timing in the whole program!
// **************************************************************************
asm volatile (
"sbi %[port], %[bit] \n\t" // Set the output bit
".rept %[onCycles] \n\t" // Now timing actually matters. The 0-bit must be long enough to be detected but not too long or it will be a 1-bit
"nop \n\t" // Execute NOPs to delay exactly the specified number of cycles
".endr \n\t"
"cbi %[port], %[bit] \n\t" // Clear the output bit
".rept %[offCycles] \n\t" // Execute NOPs to delay exactly the specified number of cycles
"nop \n\t"
".endr \n\t"
::
[port] "I" (_SFR_IO_ADDR(PIXEL_PORT)),
[bit] "I" (PIXEL_BIT),
[onCycles] "I" (NS_TO_CYCLES(T0H) - 2),
[offCycles] "I" (NS_TO_CYCLES(T0L) - 2)
);
}
// Note that the inter-bit gap can be as long as you want as long as it doesn't exceed the 5us reset timeout (which is A long time)
// Here I have been generous and not tried to squeeze the gap tight but instead erred on the side of lots of extra time.
// This has thenice side effect of avoid glitches on very long strings becuase
}
inline void sendColorBits( unsigned int byte ) {
for( unsigned char bit = 0 ; bit < 12 ; bit++ ) {
sendBit( bitRead( byte , 11 ) ); // Neopixel wants bit in highest-to-lowest order
// so send highest bit (bit #7 in an 8-bit byte since they start at 0)
byte <<= 1; // and then shift left so bit 6 moves into 7, 5 moves into 6, etc
}
}
/*
The following three functions are the public API:
ledSetup() - set up the pin that is connected to the string. Call once at the begining of the program.
sendPixel( r g , b ) - send a single pixel to the string. Call this once for each pixel in a frame.
show() - show the recently sent pixel on the LEDs . Call once per frame.
*/
// Set the specified pin up as digital out
void ledsetup() {
bitSet( PIXEL_DDR , PIXEL_BIT );
}
inline void sendPixel( unsigned int r, unsigned int g , unsigned int b ) {
sendColorBits(g); // Neopixel wants colors in green then red then blue order
sendColorBits(r);
sendColorBits(b);
}
// Just wait long enough without sending any bots to cause the pixels to latch and display the last sent frame
void show() {
_delay_us( (RES / 1000UL) + 1); // Round up since the delay must be _at_least_ this long (too short might not work, too long not a problem)
}
/*
That is the whole API. What follows are some demo functions rewriten from the AdaFruit strandtest code...
https://github.com/adafruit/Adafruit_NeoPixel/blob/master/examples/strandtest/strandtest.ino
Note that we always turn off interrupts while we are sending pixels becuase an interupt
could happen just when we were in the middle of somehting time sensitive.
If we wanted to minimize the time interrupts were off, we could instead
could get away with only turning off interrupts just for the very brief moment
when we are actually sending a 0 bit (~1us), as long as we were sure that the total time
taken by any interrupts + the time in our pixel generation code never exceeded the reset time (5us).
*/
// Display a single color on the whole string
void showColor( unsigned int r , unsigned int g , unsigned int b ) {
cli();
for( int p=0; p<PIXELS; p++ ) {
sendPixel( r , g , b );
}
sei();
show();
}
// Fill the dots one after the other with a color
// rewrite to lift the compare out of the loop
void colorWipe(unsigned int r , unsigned int g, unsigned int b, unsigned char wait ) {
for(unsigned int i=0; i<PIXELS; i+= (PIXELS/60) ) {
cli();
unsigned int p=0;
while (p++<=i) {
sendPixel(r,g,b);
}
while (p++<=PIXELS) {
sendPixel(0,0,0);
}
sei();
show();
delay(wait);
}
}
// Theatre-style crawling lights.
// Changes spacing to be dynmaic based on string size
#define THEATER_SPACING (PIXELS/20)
void theaterChase( unsigned int r , unsigned int g, unsigned int b, unsigned char wait ) {
for (int j=0; j< 3 ; j++) {
for (int q=0; q < THEATER_SPACING ; q++) {
unsigned int step=0;
cli();
for (int i=0; i < PIXELS ; i++) {
if (step==q) {
sendPixel( r , g , b );
} else {
sendPixel( 0 , 0 , 0 );
}
step++;
if (step==THEATER_SPACING) step =0;
}
sei();
show();
delay(wait);
}
}
}
// I rewrite this one from scrtach to use high resolution for the color wheel to look nicer on a *much* bigger string
void rainbowCycle(unsigned char frames , unsigned int frameAdvance, unsigned int pixelAdvance ) {
// Hue is a number between 0 and 3*256 than defines a mix of r->g->b where
// hue of 0 = Full red
// hue of 128 = 1/2 red and 1/2 green
// hue of 256 = Full Green
// hue of 384 = 1/2 green and 1/2 blue
// ...
unsigned int firstPixelHue = 0; // Color for the first pixel in the string
for(unsigned int j=0; j<frames; j++) {
unsigned int currentPixelHue = firstPixelHue;
cli();
for(unsigned int i=0; i< PIXELS; i++) {
if (currentPixelHue>=(3*256)) { // Normalize back down incase we incremented and overflowed
currentPixelHue -= (3*256);
}
unsigned char phase = currentPixelHue >> 8;
unsigned char step = currentPixelHue & 0xff;
switch (phase) {
case 0:
sendPixel( ~step * CM, step * CM, 0 );
break;
case 1:
sendPixel( 0 , ~step * CM , step * CM);
break;
case 2:
sendPixel( step * CM,0 , ~step * CM);
break;
}
currentPixelHue+=pixelAdvance;
}
sei();
show();
firstPixelHue += frameAdvance;
}
}
// I added this one just to demonstrate how quickly you can flash the string.
// Flashes get faster and faster until *boom* and fade to black.
void detonate( unsigned int r , unsigned int g , unsigned int b , unsigned int startdelayms) {
while (startdelayms) {
showColor( r , g , b ); // Flash the color
showColor( 0 , 0 , 0 );
delay( startdelayms );
startdelayms = ( startdelayms * 4 ) / 5 ; // delay between flashes is halved each time until zero
}
// Then we fade to black....
for( int fade=256; fade>0; fade-- ) {
showColor( (r * fade) / 256 ,(g*fade) /256 , (b*fade)/256 );
}
showColor( 0 , 0 , 0 );
}
void setup() {
ledsetup();
}
void loop() {
// Some example procedures showing how to display to the pixels:
colorWipe(255 * CM, 0, 0, 0); // Red
colorWipe(0, 255 * CM, 0, 0); // Green
colorWipe(0, 0, 255 * CM, 0); // Blue
// Send a theater pixel chase in...
theaterChase(127 * CM, 127 * CM, 127 * CM, 0); // White
theaterChase(127 * CM, 0, 0, 0); // Red
theaterChase( 0, 0, 127 * CM, 0); // Blue
rainbowCycle(1000 , 20 , 5 );
detonate( 255 * CM, 255 * CM, 255 * CM, 1000);
return;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment