I am unsure of how to communicate with my Arduino Uno with Jinx. I made a 15 x 15 LED matrix, uploaded the strand test program, but am unable to send any output to my board through Jinx. Is there a standby code that I need to upload from the Arduino IDE so that it can receive instructions from Jinx?
You want your Uno to communicate with "a person or thing that brings bad luck" ?
1 Like
Where you upload the test program to?
To the Uno, I assume. We don't know if it worked, only that it was uploaded, presumably successfully.
What did you mean by "standby code"? Can you tell us what this code would do, if anything?
1 Like
A code that could accept instructions from Jinx. The strand test program is currently running on the arduino, so I assume that this program needs to be replaced with something else.
I want to Uno to receive instructions from the Jinx LED control software. The strand test worked perfectly when I uploaded it from Arduino IDE.
What is "strand test" program? Could you show it code?
It's one of the example sketches that is installed with either Neopixel or FastLED libraries. It's a good way to test that the strip is working and connected.
We are not familiar with this software. When I googled for "jinx" all I got was a page of definitions of the word jinx and it's meaning. So I posted that in post #2, and hoped that you would explain better. So far, you have improved your explanation from "jinx" to "the jinx software". Can you think of a way to improve it in a way that would help us to help you?
1 Like
How do you intend to connect jinx and arduino?
I haven't worked with jinx for a long time and maybe something has changed, but earlier jinx used an Art-net protocol that required a network connection between the program (jinx) and the receiver - your Uno. As far as I know jinx does not support USB connection. Thus, in order to connect the Uno to the jinx, you need a network adapter.
In addition, I doubt very much that Uno will have enough resources to simultaneously receive data from the network and display them on the matrix, given that the jinx updates the image at a speed of 24 frames per second and this speed cannot be reduced. I think that you should take another board for this project, preferably with built-in network or wifi.
I have seen jinx and esp32 connection projects on the net.
The original instructions for my project recommended using Glediator, but I heard it was unavailable.
The Jinx software was found here http://www.live-leds.de/
The strand test program is here:
// A basic everyday NeoPixel strip test program.
// NEOPIXEL BEST PRACTICES for most reliable operation:
// - Add 1000 uF CAPACITOR between NeoPixel strip's + and - connections.
// - MINIMIZE WIRING LENGTH between microcontroller board and first pixel.
// - NeoPixel strip's DATA-IN should pass through a 300-500 OHM RESISTOR.
// - AVOID connecting NeoPixels on a LIVE CIRCUIT. If you must, ALWAYS
// connect GROUND (-) first, then +, then data.
// - When using a 3.3V microcontroller with a 5V-powered NeoPixel strip,
// a LOGIC-LEVEL CONVERTER on the data line is STRONGLY RECOMMENDED.
// (Skipping these may work OK on your workbench but can fail in the field)
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif
// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN 6
// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 225
// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 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)
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
// setup() function -- runs once at startup --------------------------------
void setup() {
// These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
// Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
// END of Trinket-specific code.
strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
strip.show(); // Turn OFF all pixels ASAP
strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)
}
// loop() function -- runs repeatedly as long as board is on ---------------
void loop() {
// Fill along the length of the strip in various colors...
colorWipe(strip.Color(255, 0, 0), 50); // Red
colorWipe(strip.Color( 0, 255, 0), 50); // Green
colorWipe(strip.Color( 0, 0, 255), 50); // Blue
// Do a theater marquee effect in various colors...
theaterChase(strip.Color(127, 127, 127), 50); // White, half brightness
theaterChase(strip.Color(127, 0, 0), 50); // Red, half brightness
theaterChase(strip.Color( 0, 0, 127), 50); // Blue, half brightness
rainbow(10); // Flowing rainbow cycle along the whole strip
theaterChaseRainbow(50); // Rainbow-enhanced theaterChase variant
}
// Some functions of our own for creating animated effects -----------------
// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
strip.setPixelColor(i, color); // Set pixel's color (in RAM)
strip.show(); // Update strip to match
delay(wait); // Pause for a moment
}
}
// Theater-marquee-style chasing lights. Pass in a color (32-bit value,
// a la strip.Color(r,g,b) as mentioned above), and a delay time (in ms)
// between frames.
void theaterChase(uint32_t color, int wait) {
for(int a=0; a<10; a++) { // Repeat 10 times...
for(int b=0; b<3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in steps of 3...
for(int c=b; c<strip.numPixels(); c += 3) {
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
}
// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {
// Hue of first pixel runs 5 complete loops through the color wheel.
// Color wheel has a range of 65536 but it's OK if we roll over, so
// just count from 0 to 5*65536. Adding 256 to firstPixelHue each time
// means we'll make 5*65536/256 = 1280 passes through this loop:
for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
// strip.rainbow() can take a single argument (first pixel hue) or
// optionally a few extras: number of rainbow repetitions (default 1),
// saturation and value (brightness) (both 0-255, similar to the
// ColorHSV() function, default 255), and a true/false flag for whether
// to apply gamma correction to provide 'truer' colors (default true).
strip.rainbow(firstPixelHue);
// Above line is equivalent to:
// strip.rainbow(firstPixelHue, 1, 255, 255, true);
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {
int firstPixelHue = 0; // First pixel starts at red (hue 0)
for(int a=0; a<30; a++) { // Repeat 30 times...
for(int b=0; b<3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in increments of 3...
for(int c=b; c<strip.numPixels(); c += 3) {
// hue of pixel 'c' is offset by an amount to make one full
// revolution of the color wheel (range 65536) along the length
// of the strip (strip.numPixels() steps):
int hue = firstPixelHue + c * 65536L / strip.numPixels();
uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGB
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
}
}
}
A lot of time was spent building the board, I wouldn't make another one. Perhaps I can find another software that would be compatible.
building the Uno?
In case you use the Uno only as addition to your own pcb, it shouldn't be a problem to replace it to ESP32.
But if you make a custom pcb with atmega328 mcu, the situation is worse. In this case I recommend you to spent a some time to figure out how to connect jinx to your existing board - may be with external network shield or dmx interface...
Could you share a link to original project?
Why do you want UNO to communicate with Jinx!(?), since the UNO doesnt have a WiFi chip, you have no way to connect it to your computer..?
I've used NodeMCU to control a 30x17 (WxH) matrix and it works great.
By installing Wled it can handle the information from Jinx. And the board are able to handle a big chunk of information, so that i can use one chip to three universes on my Matrix.
But if you DO have a WiFi chip connected somehow, try finding some other sketch to make a Art-Net device.
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.