RTC met adafruit neopixel ringen

[Koepel Profiel Privébericht]

In dit forum maakt de knop "Code" zogenaamde "code tags" : [ code ] en [ /code ] (maar dan zonder spaties).
Bij het drop-down menu "Select a Syntax" kun je "C++" kiezen voor [ code2=cpp ] en [ /code2 ]
Als je een van de twee kiest, en daar je code tussen zet, dan kan ik het inspringen zien.

Dit is wat je nu hebt:

Code: Alles selecteren

  for (uint8_t i = 0; i < pixels_c.numPixels(); i++)
  {
    {
      {
        if (i <= hourval)
        {
          // calculates a faded arc from low to maximum brightness
          pixelColorRed = (i) * (255);
        }
        else
        {
          pixelColorRed = 0;
        }
        pixels_c.setPixelColor(i, pixels_c.Color(pixelColorRed, pixelColorGreen, pixelColorBlue));
      }
      pixels_c.show();
    }
  }


De pixels_c.show(); staat nog steeds binnen de for-loop. Die kan daar buiten:

Code: Alles selecteren

  // --------------------------------------
  // The led strip for the hours
  // --------------------------------------
  for (int i = 0; i < pixels_c.numPixels(); i++)
  {
    if (i <= hourval)
    {
      // calculates a faded arc from low to maximum brightness
      pixelColorRed = (i) * (255);
    }
    else
    {
      pixelColorRed = 0;
    }
    pixels_c.setPixelColor(i, pixels_c.Color(pixelColorRed, pixelColorGreen, pixelColorBlue));
  }
  pixels_c.show();


In de taal 'c' en 'c++' mag je meerdere statements combineren met '{' en '}'. Je mag zoveel '{' en '}' gebruiken als je wilt, maar als het niet nodig is, dan maakt het de code minder goed te lezen.

Ik heb commentaar boven de for-loop gezet, misschien staat het leuk als je dat ook voor seconden en minuten doet.

En de 'i' voor de loop heb ik gewijzigd van "uint8_t" naar "int". Je kunt gewoon een "int" gebruiken. Laat het optimaliseren maar aan de compiler over. Wanneer je een grote buffer declareert of een interrupt routine schrijft, die tot het uiterste geoptimaliseerd moet worden, dan kun dat soort dingen gaan doen.

Kijk eens naar de broncode van .setPixelColor (die functie zit drie keer in de broncode) : https://github.com/adafruit/Adafruit_NeoPixel/blob/master/Adafruit_NeoPixel.cpp
De eerste parameter is een "uint16_t". Dus dat betekent dat jouw "uint8_t" van één byte wordt omgezet naar twee bytes, en die twee bytes worden op de stack gezet. Dus van jouw slim gebruik van variabelen of een optimalisatie blijft zo weinig over Vandaar dat gewoon een "int" heel gewoon is en dus net zo goed
Kun je nog meer aan ? Dus jij dacht dat de compiler twee bytes op de stack zette ? Arduino heeft sinds kort de "lto" optimalisatie van de compiler aangezet. Daarbij kijkt de compiler/linker nog eens goed naar de hele code en kijkt wat er nog verbeterd kan worden.

Zat er fading in ? Waar ? Wil je dat nog toevoegen ?

[Randy93 Profiel Privébericht]

ik heb de code nu als volgt :

Code: Alles selecteren

 //project arduino klok 2.1
//Written by: Randy Kesselmans
//Date: 27-12-2016
//Arduino Board: Uno



// include the library code:
#include <Wire.h>
#include <RTClib.h>
#include <Adafruit_NeoPixel.h>

// The Arduino pin for the led strip of the seconds.
const int secondsPin = 4;
// The Arduino pin for the led strip of the minutes.
const int minutesPin = 7;
// The Arduino pin for the led strip of the hours.
const int hoursPin = 2;

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS_a      60
// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS_b      60
// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS_c      12

// set max brightness 0-255
#define BRIGHTNESS 100

// Establish clock object
RTC_DS1307 RTC;

// Holds current clock time
DateTime Clock;

// set neopixelring for seconds
Adafruit_NeoPixel pixels_a = Adafruit_NeoPixel(NUMPIXELS_a, secondsPin, NEO_GRB + NEO_KHZ800);
// set neopixelring for minutes
Adafruit_NeoPixel pixels_b = Adafruit_NeoPixel(NUMPIXELS_b, minutesPin, NEO_GRB + NEO_KHZ800);
// set neopixelring for hours
Adafruit_NeoPixel pixels_c = Adafruit_NeoPixel(NUMPIXELS_c, hoursPin, NEO_GRB + NEO_KHZ800);

// holds the time
byte hourval, minuteval, secondval;

// holds color values
byte pixelColorRed, pixelColorGreen, pixelColorBlue;

void setup () {
  // Begin I2C
  Wire.begin();   
 
  // begin clock
  RTC.begin();   

Serial.begin(9600);

 
 if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    //RTC.adjust(DateTime(2016, 10, 14, 11, 59, 0));
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
 
  //strip.show(); // Initialize all pixels to 'off'
    pixels_a.begin();
  //strip.show(); // Initialize all pixels to 'off'
    pixels_b.begin();
  //strip.show(); // Initialize all pixels to 'off'
    pixels_c.begin();
 
  // set brightness
pixels_a.setBrightness(BRIGHTNESS);
  // set brightness
pixels_b.setBrightness(BRIGHTNESS);
// set brightness
pixels_c.setBrightness(BRIGHTNESS);

}

void loop () {

  // get time
  Clock = RTC.now(); // get the RTC time
 
  // get seconds
  secondval = Clock.second(); 
  // get minutes
  minuteval = Clock.minute(); 
  // get hours
  hourval = Clock.hour(); 
  //This clock is 12 hour, if 13-23, convert to 0-11   
  if (hourval > 11) hourval -= 12;




// Set colors.
  pixelColorRed = 0;
  pixelColorGreen = 0;
  pixelColorBlue = 0;
 
// --------------------------------------
  // The led strip for the seconds
  // --------------------------------------
  for (int i = 0; i < pixels_a.numPixels(); i++)
  {
    if (i <= hourval)
    {
      // calculates a faded arc from low to maximum brightness
      pixelColorBlue = (i + 1) * (255);
    }
    else
    {
      pixelColorBlue = 0;
    }
    pixels_a.setPixelColor(i, pixels_c.Color(pixelColorRed, pixelColorGreen, pixelColorBlue));
  }
  pixels_a.show();



 
 // Set colors.
  pixelColorRed = 0;
  pixelColorGreen = 0;
  pixelColorBlue = 0;
 
// --------------------------------------
  // The led strip for the minutes
  // --------------------------------------
  for (int i = 0; i < pixels_b.numPixels(); i++)
  {
    if (i <= hourval)
    {
      // calculates a faded arc from low to maximum brightness
      pixelColorGreen = (i) * (255);
    }
    else
    {
      pixelColorGreen = 0;
    }
    pixels_b.setPixelColor(i, pixels_b.Color(pixelColorRed, pixelColorGreen, pixelColorBlue));
  }
  pixels_b.show();




 
 // Set colors.
  pixelColorRed = 0;
  pixelColorGreen = 0;
  pixelColorBlue = 0;
 
  // --------------------------------------
  // The led strip for the hours
  // --------------------------------------
  for (int i = 0; i < pixels_c.numPixels(); i++)
  {
    if (i <= hourval)
    {
      // calculates a faded arc from low to maximum brightness
      pixelColorRed = (i) * (255);
    }
    else
    {
      pixelColorRed = 0;
    }
    pixels_c.setPixelColor(i, pixels_c.Color(pixelColorRed, pixelColorGreen, pixelColorBlue));
  }
  pixels_c.show();

}

 

Met de fading bedoelde ik dat de led bij de secondes steeds lichter ging branden op het begin van de ring naarmate hij naar de 60 seconde toe loopt alleen vond ik het niet goed zichtbaar als je er een beetje scheef voor stond dus dat heb ik eruit gehaald.

[Koepel Profiel Privébericht]

Ziet er goed uit
Bewaar deze sketch, zodat je er op terug kunt vallen als je iets gaat wijzigen.

Je hebt RGB leds, maar de uren zijn alleen maar rood, de minuten alleen maar groen en de seconden alleen maar blauw. Is dat niet een beetje saai

[Randy93 Profiel Privébericht]

Ja vond ik ook al maar zo snapte ik het tenminste nog een beetje. Heb er wel een ring achter de klok zitten die op de muur schijnt. Die kun je verandere van kleur met de Bluetooth module en terminal. Heb een programma ervoor gemaakt voor een aantal kleuren.

Maar heb jij nog ideeën om het wat spectaculaire te maken?

[Koepel Profiel Privébericht]

Bij de seconden en minuten doe je ook if (i <= hourval), daar is het vanzelfsprekend nodig om te testen op minuteval en secondval.

De helderheid die je gebruikt vind ik een beetje merkwaardig.
Je gebruikt nu bijvoorbeeld i * 255, maar het zou beter zijn om zelf precies te bepalen wat je wilt.
Dat is dus het 'faden' dat je bedoelde, nu begrijp ik het

De maximale helderheid zou ik met een variabele doen, dan kun je bijvoorbeeld het dimmen als het donker is.
Dus deze #define BRIGHTNESS 100 een variabele int brightness = 100;.

Stel lineair faden met een kwart cirkel. Dan ga je vanaf maximum tot nul met bijvoorbeeld een kwart van het aantal leds. Dat faden moet vanzelfsprekend ook doorlopen links van de 12 uur. Als dat is wat je wilt.
Daarvoor zou ik de for-loop veranderen. Ik zou beginnen met de led van de huidige seconde die het helderste is, en dan de leds invullen terwijl je terug gaat (linksom).

Code: Alles selecteren

For-loop met aantal leds (60 voor seconden) die optelt.
Daarmee een formule die de helderheid berekend.
Tweede variabele binnen de for-loop die terug telt en onder de nul verspringt naar de laatste led.


Het is gemakkelijk om iets te bedenken dat lelijk knippert of helemaal los gaat met de leds, maar het is lastig om iets te bedenken dat nog steeds mooi is.
Misschien met een bewegingssensor (PIR sensor). Wanneer iemand voorbij loopt, dan met de helderheid of met andere kleuren een soort drum beat laten zien.
Of de mogelijkheid om de tijd in een ander deel van de wereld laten zien, en daar met een vloeiende overgang naar toe gaan.
Een wekker functie, de maanstand, en of het zomer- of wintertijd is zou misschien toegevoegd kunnen worden. Maar ik weet niet hoe dat er mooi bij past.
Je kunt natuurlijk helemaal los gaan en andere functies bedenken, zoals een stopwatch of een rad van fortuin.
Of koppelen aan een website of een app, zodat je hetzelfde op een scherm kan zien.