Help coding for a fade in and out been two colours

Hi guys im trying to code my NeoPixel Ring 44mm 16 LED WS2812 light to fade in and out of 2 colours, For the example we will say Red and Green as these can easily be changed. However using the code from the a site gave me the below.

This issue im having is it states both the direction has not been declared and the ActivePattern = FADE has not been declared in the scope. The error for the direction shas been added below the code.

#include <Adafruit_NeoPixel.h>

#define LED_PIN 4
#define LED_COUNT 16
#define BRIGHTNESS 200

Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_RGB + NEO_KHZ800);

uint32_t color1 = strip.Color(255, 0 , 0);
uint32_t color2 = strip.Color(0, 0, 255);

uint16_t steps = 16;

uint8_t interval = 100;


void setup() {

  strip.begin();         
  strip.show();            
  strip.setBrightness(50); 
}

void loop() {

  void Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD)
  {
    ActivePattern = FADE;
    Interval = interval;
    TotalSteps = steps;
    Color1 = color1;
    Color2 = color2;
    Index = 0;
    Direction = dir;
  }
}
}

Arduino: 1.8.16 (Windows Store 1.8.51.0) (Windows 10), Board: "Arduino Uno"

C:\Users\joshi\OneDrive\Documents\Arduino\fail\fail.ino: In function 'void loop()':

fail:26:81: error: 'direction' has not been declared

void Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD)

                                                                             ^~~~~~~~~

fail:26:97: error: 'FORWARD' was not declared in this scope

void Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD)

                                                                                             ^~~~~~~

fail:27:3: error: a function-definition is not allowed here before '{' token

{

^

C:\Users\joshi\OneDrive\Documents\Arduino\fail\fail.ino: At global scope:

fail:37:1: error: expected declaration before '}' token

}

^

exit status 1

'direction' has not been declared

This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.

Perhaps separating out these 2 functions would be a thing to do. Notice how one function void Fade is nested inside of loop()?

Is this a fix or a guess? In the error there was no mentioned of nested functions. Just as stated, the direction isn't delcared apparently

@joshyboy95 , you do not find a function nested in another function to be incorrect?

Also each { should have a }.

pretty good guess?

Don't worry clearly you just want to state ambiguous hints as to whats wrong and not really help someone starting out

What code from what site? Please post a link to that. Perhaps the full, complete/corrected code is there also. What you posted above is just a broken fragment. If that is how you found it, then the error is not your fault, except that you don't have enough knowledge to realise that the code is incomplete/broken.

You are about as wrong as you can be.
The compiler throws an error when it encounters the first thing it can not understand. It can not look into the mind of someone who wrote the errors and spot what is wrong. So just like a compiler someone will stop when they see something obviously wrong. But unlike a compiler you were given the advice as to where to look for the mistake you made.

If you don't understand an answer ask about what you don't understand. Snide comments are not going to win you many friends here. We are trying to help you learn, not just fix wonky ill conceived code.
That is what help is about.
Basically you can not define a function inside another function, this is one of the fundamentals of this computer language.

If you want to get someone to write the code then post in the "Jobs and paid consultancy" section and say how much you are willing to pay.

1 Like

Part of your problem is that you left out about 90% of the NeoPatterns example:

I think this will be close to what you wanted. I left out the patterns you didn't use: RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, and SCANNER.

#include <Adafruit_NeoPixel.h>

#define LED_PIN 4
#define LED_COUNT 16

// Pattern types supported:
enum  pattern { NONE, FADE };

// Patern directions supported:
enum  direction { FORWARD, REVERSE };

// NeoPattern Class - derived from the Adafruit_NeoPixel class
class NeoPatterns : public Adafruit_NeoPixel
{
  public:

    // Member Variables:
    pattern  ActivePattern;  // which pattern is running
    direction Direction;     // direction to run the pattern

    unsigned long Interval;   // milliseconds between updates
    unsigned long lastUpdate; // last update of position

    uint32_t Color1, Color2;  // What colors are in use
    uint16_t TotalSteps;  // total number of steps in the pattern
    uint16_t Index;  // current step within the pattern

    void (*OnComplete)();  // Callback on completion of pattern

    // Constructor - calls base-class constructor to initialize strip
    NeoPatterns(uint16_t pixels, uint8_t pin, uint8_t type, void (*callback)())
      : Adafruit_NeoPixel(pixels, pin, type)
    {
      OnComplete = callback;
    }

    // Update the pattern
    void Update()
    {
      if ((millis() - lastUpdate) > Interval) // time to update
      {
        lastUpdate = millis();
        switch (ActivePattern)
        {
          case FADE:
            FadeUpdate();
            break;

          default:
            break;
        }
      }
    }

    // Increment the Index and reset at the end
    void Increment()
    {
      if (Direction == FORWARD)
      {
        Index++;
        if (Index >= TotalSteps)
        {
          Index = 0;
          if (OnComplete != NULL)
          {
            OnComplete(); // call the comlpetion callback
          }
        }
      }
      else // Direction == REVERSE
      {
        --Index;
        if (Index <= 0)
        {
          Index = TotalSteps - 1;
          if (OnComplete != NULL)
          {
            OnComplete(); // call the comlpetion callback
          }
        }
      }
    }

    // Reverse pattern direction
    void Reverse()
    {
      if (Direction == FORWARD)
      {
        Direction = REVERSE;
        Index = TotalSteps - 1;
      }
      else
      {
        Direction = FORWARD;
        Index = 0;
      }
    }


    // Initialize for a Fade
    void Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD)
    {
      ActivePattern = FADE;
      Interval = interval;
      TotalSteps = steps;
      Color1 = color1;
      Color2 = color2;
      Index = 0;
      Direction = dir;
    }

    // Update the Fade Pattern
    void FadeUpdate()
    {
      // Calculate linear interpolation between Color1 and Color2
      // Optimise order of operations to minimize truncation error
      uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / TotalSteps;
      uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps;
      uint8_t blue = ((Blue(Color1) * (TotalSteps - Index)) + (Blue(Color2) * Index)) / TotalSteps;

      ColorSet(Color(red, green, blue));
      show();
      Increment();
    }

    // Calculate 50% dimmed version of a color (used by ScannerUpdate)
    uint32_t DimColor(uint32_t color)
    {
      // Shift R, G and B components one bit to the right
      uint32_t dimColor = Color(Red(color) >> 1, Green(color) >> 1, Blue(color) >> 1);
      return dimColor;
    }

    // Set all pixels to a color (synchronously)
    void ColorSet(uint32_t color)
    {
      for (unsigned i = 0; i < numPixels(); i++)
      {
        setPixelColor(i, color);
      }
      show();
    }

    // Returns the Red component of a 32-bit color
    uint8_t Red(uint32_t color)
    {
      return (color >> 16) & 0xFF;
    }

    // Returns the Green component of a 32-bit color
    uint8_t Green(uint32_t color)
    {
      return (color >> 8) & 0xFF;
    }

    // Returns the Blue component of a 32-bit color
    uint8_t Blue(uint32_t color)
    {
      return color & 0xFF;
    }

    // Input a value 0 to 255 to get a color value.
    // The colours are a transition r - g - b - back to r.
    uint32_t Wheel(byte WheelPos)
    {
      WheelPos = 255 - WheelPos;
      if (WheelPos < 85)
      {
        return Color(255 - WheelPos * 3, 0, WheelPos * 3);
      }
      else if (WheelPos < 170)
      {
        WheelPos -= 85;
        return Color(0, WheelPos * 3, 255 - WheelPos * 3);
      }
      else
      {
        WheelPos -= 170;
        return Color(WheelPos * 3, 255 - WheelPos * 3, 0);
      }
    }
};

void StripComplete();

NeoPatterns strip(LED_COUNT, LED_PIN, NEO_RGB + NEO_KHZ800, &StripComplete);

// Initialize everything and prepare to start
void setup()
{
  Serial.begin(115200);


  // Initialize all the pixelStrips
  strip.begin();

  uint32_t color1 = strip.Color(255, 0 , 0);
  uint32_t color2 = strip.Color(0, 0, 255);

  // Kick off a pattern
  strip.Fade(color1, color2, 100, 10);
}

// Main loop
void loop()
{
  strip.Update();
}

//------------------------------------------------------------
//Completion Routines - get called on completion of a pattern
//------------------------------------------------------------

// Strip Completion Callback
void StripComplete()
{
  strip.Reverse();
}