Attiny85 mit FastLed und WS2812 läuft nicht korrekt

[M45t3r 0f H4rdc0r3 (Gast)]

Hallo liebe Elektronik Freunde,

ich habe mir gedacht , nachdem ich meine WS2812 per Arduino wunderschön 
am laufen bekomme, mache ich das ganze etwas kleiner und nehme einen 
Attiny85. Da ich bereits Videos auf Youtube gesehen habe das es Leute am 
laufen bekommen war ich der Meinung , das bekomme ich auch hin.

Leider ein Trugschluss.

Nachdem ich die Timings erst mit Stoppuhr gecheckt habe(mit blinkender 
normaler LED) und erst einmal die Fusebits richtig gesetzt habe auf 
intern 8MHz, habe ich die normale FastLED lib genommen wie beim Arduino 
auch und den Code der ColorPalette auf meinen 8 bit WS2812 LED Ring 
geändert habe (Belegung auf PB0 sprich Port 0) und den Code flashe geht 
der Ring nur an und bleibt bei der 1. Farbe Weiß stehen und es ändert 
sich nichts (kein wechseln wie wenn ich den Ring mit dem gleichen Code 
auf dem Arduino laufen lasse).

Wäre echt froh wenn mir jemand einen Tip geben könnte was ich falsch 
mache. Ich hoffe der ein oder andere liest das und denkt : Mensch was 
ein Honk, das kann ja auch nicht gehen.... ;-)





Hier mal der Code den ich flashe:

#include <FastLED.h>

#define LED_PIN     0
#define NUM_LEDS    8
#define BRIGHTNESS  64
#define LED_TYPE    WS2812
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 100

// This example shows several ways to set up and use 'palettes' of 
colors
// with FastLED.
//
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
//
// USING palettes is MUCH simpler in practice than in theory, so first 
just
// run this sketch, and watch the pretty lights as you then read through
// the code.  Although this sketch has eight (or more) different color 
schemes,
// the entire sketch compiles down to about 6.5K on AVR.
//
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
//
// Some notes on the more abstract 'theory and practice' of
// FastLED compact palettes are at the bottom of this file.



CRGBPalette16 currentPalette;
TBlendType    currentBlending;

extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;


void setup() {
  delay( 3000 ); // power-up safety delay
  FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, 
NUM_LEDS).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness(  BRIGHTNESS );

  currentPalette = RainbowColors_p;
  currentBlending = BLEND;
}


void loop()
{
  ChangePalettePeriodically();

  static uint8_t startIndex = 0;
  startIndex = startIndex + 1; /* motion speed */

  FillLEDsFromPaletteColors( startIndex);

  FastLED.show();
  FastLED.delay(1000 / UPDATES_PER_SECOND);
}

void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
  uint8_t brightness = 255;

  for( int i = 0; i < NUM_LEDS; i++) {
    leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, 
currentBlending);
    colorIndex += 3;
  }
}


// There are several different palettes of colors demonstrated here.
//
// FastLED provides several 'preset' palettes: RainbowColors_p, 
RainbowStripeColors_p,
// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and 
PartyColors_p.
//
// Additionally, you can manually define your own color palettes, or you 
can write
// code that creates color palettes on the fly.  All are shown here.

void ChangePalettePeriodically()
{
  uint8_t secondHand = (millis() / 1000) % 60;
  static uint8_t lastSecond = 99;

  if( lastSecond != secondHand) {
    lastSecond = secondHand;
    if( secondHand ==  0)  { currentPalette = RainbowColors_p; 
currentBlending = BLEND; }
    if( secondHand == 10)  { currentPalette = RainbowStripeColors_p; 
currentBlending = NOBLEND;  }
    if( secondHand == 15)  { currentPalette = RainbowStripeColors_p; 
currentBlending = BLEND; }
    if( secondHand == 20)  { SetupPurpleAndGreenPalette(); 
currentBlending = BLEND; }
    if( secondHand == 25)  { SetupTotallyRandomPalette(); 
currentBlending = BLEND; }
    if( secondHand == 30)  { SetupBlackAndWhiteStripedPalette(); 
currentBlending = NOBLEND; }
    if( secondHand == 35)  { SetupBlackAndWhiteStripedPalette(); 
currentBlending = BLEND; }
    if( secondHand == 40)  { currentPalette = CloudColors_p; 
currentBlending = BLEND; }
    if( secondHand == 45)  { currentPalette = PartyColors_p; 
currentBlending = BLEND; }
    if( secondHand == 50)  { currentPalette = myRedWhiteBluePalette_p; 
currentBlending = NOBLEND;  }
    if( secondHand == 55)  { currentPalette = myRedWhiteBluePalette_p; 
currentBlending = BLEND; }
  }
}

// This function fills the palette with totally random colors.
void SetupTotallyRandomPalette()
{
  for( int i = 0; i < 16; i++) {
    currentPalette[i] = CHSV( random8(), 255, random8());
  }
}

// This function sets up a palette of black and white stripes,
// using code.  Since the palette is effectively an array of
// sixteen CRGB colors, the various fill_* functions can be used
// to set them up.
void SetupBlackAndWhiteStripedPalette()
{
  // 'black out' all 16 palette entries...
  fill_solid( currentPalette, 16, CRGB::Black);
  // and set every fourth one to white.
  currentPalette[0] = CRGB::White;
  currentPalette[4] = CRGB::White;
  currentPalette[8] = CRGB::White;
  currentPalette[12] = CRGB::White;

}

// This function sets up a palette of purple and green stripes.
void SetupPurpleAndGreenPalette()
{
  CRGB purple = CHSV( HUE_PURPLE, 255, 255);
  CRGB green  = CHSV( HUE_GREEN, 255, 255);
  CRGB black  = CRGB::Black;

  currentPalette = CRGBPalette16(
    green,  green,  black,  black,
    purple, purple, black,  black,
    green,  green,  black,  black,
    purple, purple, black,  black );
}


// This example shows how to set up a static color palette
// which is stored in PROGMEM (flash), which is almost always more
// plentiful than RAM.  A static PROGMEM palette like this
// takes up 64 bytes of flash.
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
{
  CRGB::Red,
  CRGB::Gray, // 'white' is too bright compared to red and blue
  CRGB::Blue,
  CRGB::Black,

  CRGB::Red,
  CRGB::Gray,
  CRGB::Blue,
  CRGB::Black,

  CRGB::Red,
  CRGB::Red,
  CRGB::Gray,
  CRGB::Gray,
  CRGB::Blue,
  CRGB::Blue,
  CRGB::Black,
  CRGB::Black
};



// Additionl notes on FastLED compact palettes:
//
// Normally, in computer graphics, the palette (or "color lookup table")
// has 256 entries, each containing a specific 24-bit RGB color.  You 
can then
// index into the color palette using a simple 8-bit (one byte) value.
// A 256-entry color palette takes up 768 bytes of RAM, which on Arduino
// is quite possibly "too many" bytes.
//
// FastLED does offer traditional 256-element palettes, for setups that
// can afford the 768-byte cost in RAM.
//
// However, FastLED also offers a compact alternative.  FastLED offers
// palettes that store 16 distinct entries, but can be accessed AS IF
// they actually have 256 entries; this is accomplished by interpolating
// between the 16 explicit entries to create fifteen intermediate 
palette
// entries between each pair.
//
// So for example, if you set the first two explicit entries of a 
compact
// palette to Green (0,255,0) and Blue (0,0,255), and then retrieved
// the first sixteen entries from the virtual palette (of 256), you'd 
get
// Green, followed by a smooth gradient from green-to-blue, and then 
Blue.

[M45t3r 0f H4rdc0r3 (Gast)]

Oh verdammt. Sorry der Finger war wieder schneller als das Auge.

Tut mir leid das ich den Sourcecode nicht als Dateianhang abgelegt 
habe.... bitte verzeiht mir , kommt bestimmt nicht noch einmal vor...

[M45t3r 0f H4rdc0r3 (Gast)]

Für alle die das gleiche Problem haben und nicht weiter wissen habe ich 
in einem englischsprachigem Forum etwas gefunden.

Es gibt wohl generell echt Timing Unterschiede zwischen einem Tiny und 
dem Arduino wenn ich das richtig verstanden habe und es ist etwas 
tricky. Bitte korrigiert mich falls ich falsch liege.

An dieser Stelle findet man passende libraries:

https://github.com/cpldcpu/light_ws2812

Der Code soll kompakter und optimiert für die Tinys sein. Kann den Code 
jetzt leider grade nicht testen da ich auf der Arbeit bin , werde aber 
berichten ob es geklappt hat sobald ich es getestet habe.

Ich hoffe es funktioniert und ich konnte dem einen oder anderen helfen.

Schönen Start ins Wochenende allen zusammen...

[Draco (Gast)]

Ach du meine Güte... eine unübersichtlichkeit... Teile mal diese 
FastLED.h - das ist hier der Ansatzpunkt. Welchen Compiler nutzt du?

Und gerne nochmal: Ein Arduino ist (normalerweiße, vom CM3 mal 
abgesehen) auch "bloß" ein normaler Atmel AVR - sie laufen halt mit 
einem Bootloader und einem eigenen Compiler auf dem Rechner. Tu dir 
einen Gefallen! Lös dich komplett davon... such dir eine der tausenden 
RGB Librariers für die AVRs aus und leg mit AVR Studio, Atmel Studio 
oder dem Texteditor deiner Wahl in einem normalen C los!

[M45t3r 0f H4rdc0r3 (Gast)]

Hallo Draco,

erst einmal danke für die schnelle Antwort. Die FastLed.h kann ich 
nachher mal uploaden kein Problem.

Bis vorgestern habe ich den Tiny ausschließlich über die Arduino IDE 
geproggt. Habe aber seit gestern auch das aktuelle Atmel Studio 
installiert. Werde mal deinen Rat beherzigen mit ne passende lib suchen 
und es in c versuchen. Dann über einen usb isp programmer.

[bianchifan (Gast)]

Zur WS2812 gibt es einen Artikel -> 
http://www.mikrocontroller.net/articles/WS2812_Ansteuerung

Ich habe hier einige CJMCUs auf Vorrat rumliegen, eines hatte ich mal 
testweise mit irgendeinem Code an einen Tiny gekoppelt, lief auf Anhieb.

Als lib kam die Neopixel von Adafruit zum Einsatz.
Ein 24er-Ringlicht von banggood ist im Zulauf, ich plane damit ein 
weiteres Ringlicht für Makroaufnahmen, als Startbasis habe ich wiederum 
eiige Fetzen aus dem Netz gefischt, ebenfalls mit Neopixel-Lib, siehe 
Anhang.

Atmel Studio sagt mir nicht zu, ich benutze z.Zt. auch noch die 
Arduino-IDE, klappert 1a.
Programmiert wie seit eh und jeh über USBASP.

[M45t3r 0f H4rdc0r3 (Gast)]

bianchifan schrieb:
> Zur WS2812 gibt es einen Artikel ->
> http://www.mikrocontroller.net/articles/WS2812_Ansteuerung
>
> Ich habe hier einige CJMCUs auf Vorrat rumliegen, eines hatte ich mal
> testweise mit irgendeinem Code an einen Tiny gekoppelt, lief auf Anhieb.
>
> Als lib kam die Neopixel von Adafruit zum Einsatz.
> Ein 24er-Ringlicht von banggood ist im Zulauf, ich plane damit ein
> weiteres Ringlicht für Makroaufnahmen, als Startbasis habe ich wiederum
> eiige Fetzen aus dem Netz gefischt, ebenfalls mit Neopixel-Lib, siehe
> Anhang.
>
> Atmel Studio sagt mir nicht zu, ich benutze z.Zt. auch noch die
> Arduino-IDE, klappert 1a.
> Programmiert wie seit eh und jeh über USBASP.

Danke das wars!!! Alles geklappt mein Fehler war wohl das ich die 
falsche lib hatte. Danke an alle beteiligten. Bin echt froh das es genug 
Leute gibt die richtig was aufm Kasten haben!!

Danke und allen beteiligten und Mitlesern ein schönes WE ......

[bianchifan (Gast)]

M45t3r 0f H4rdc0r3 schrieb:
> und den Code flashe geht
> der Ring nur an und bleibt bei der 1. Farbe Weiß stehen und es ändert
> sich nichts (kein wechseln wie wenn ich den Ring mit dem gleichen Code
> auf dem Arduino laufen lasse).

Nur noch mal zur Vollständigkeit.. genau das gleiche ist mir gaestern 
abend auch passiert, als ich die FastLED mal antesten wollte wegen der 
vordefinierten Farb"profile".
Verwendet hatte ich eine FastLED 3.0.3.
Nachdem ich eine andere Version verwendet hatte 
https://github.com/FastLED/FastLED, funzte alles bestens.
Seit zwei Tagen lautet die aktuelle Version 3.1