having problems with addressable led sample code

Hi this is a problem thats probably going to be answered simply but I keep getting errors when trying to run example codes for addressable leds, picture attached. the code is from libraries people have shown off on youtube so i know it works and i also have the same problem with a Pololu library. I can not for the life of me figure out what wrong with it. it looks like that first error line is causing the problems (and yes the files in the library). If you could help me that would be great, and thank you

Would you like a tiny picture for an answer? Don't post pictures of text. Copy and paste the text!

sorry I didn't think it would show up tiny.

code:

#include "FastLED.h"

// How many leds in your strip?
#define NUM_LEDS 6

// For led chips like Neopixels, which have a data line, ground, and power, you just
// need to define DATA_PIN. For led chipsets that are SPI based (four wires - data, clock,
// ground, and power), like the LPD8806 define both DATA_PIN and CLOCK_PIN
#define DATA_PIN 3
#define CLOCK_PIN 13

// Define the array of leds
CRGB leds[NUM_LEDS];

void setup() {
// Uncomment/edit one of the following lines for your leds arrangement.
// FastLED.addLeds<TM1803, DATA_PIN, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<TM1804, DATA_PIN, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<TM1809, DATA_PIN, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS);
FastLED.addLeds<NEOPIXEL, DATA_PIN, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<UCS1903, DATA_PIN, RGB>(leds, NUM_LEDS);

// FastLED.addLeds<WS2801, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<SM16716, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<LPD8806, RGB>(leds, NUM_LEDS);

// FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
// FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
}

void loop() {
// Turn the LED on, then pause
leds[0] = CRGB::Red;
FastLED.show();
delay(500);
// Now turn the LED off, then pause
leds[0] = CRGB::Black;
FastLED.show();
delay(500);
}

errors:

Blink.ino:2:21: error: FastLED.h: No such file or directory
Blink:14: error: 'CRGB' does not name a type
Blink.ino: In function 'void setup()':
Blink:24: error: 'FastLED' was not declared in this scope
Blink:24: error: 'NEOPIXEL' was not declared in this scope
Blink:24: error: 'RGB' was not declared in this scope
Blink:24: error: 'leds' was not declared in this scope
Blink.ino: In function 'void loop()':
Blink:38: error: 'leds' was not declared in this scope
Blink:38: error: 'CRGB' has not been declared
Blink:39: error: 'FastLED' was not declared in this scope
Blink:42: error: 'CRGB' has not been declared

Blink.ino:2:21: error: FastLED.h: No such file or directory

The compiler is unable to find your library, where did you put it?

i went arduino>libraries> and then dragged it in there.
i also tried deleting them and then going through sketch>import library...> add library... and then selected the FastLED file off my desktop

Make sure it is not double foldered.

well i figured it be something stupid haha thank you, got it working.

Got the same issue, what was your fix?

hi having problem with fastled keeps coming up with errors eg crgb does not name a type#define NUM_LEDS 60
//The pin that controls the LEDs
#define LED_PIN 6
//The pin that we read sensor values form
#define ANALOG_READ 0

//Confirmed microphone low value, and max value
#define MIC_LOW 0.0
#define MIC_HIGH 737.0
/** Other macros */
//How many previous sensor values effects the operating average?
#define AVGLEN 5
//How many previous sensor values decides if we are on a peak/HIGH (e.g. in a song)
#define LONG_SECTOR 20

//Mneumonics
#define HIGH 3
#define NORMAL 2

//How long do we keep the "current average" sound, before restarting the measuring
#define MSECS 30 * 1000
#define CYCLES MSECS / DELAY

/*Sometimes readings are wrong or strange. How much is a reading allowed
to deviate from the average to not be discarded? **/
#define DEV_THRESH 0.8

//Arduino loop delay
#define DELAY 1

float fscale( float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve);
void insert(int val, int *avgs, int len);
int compute_average(int *avgs, int len);
void visualize_music();

//How many LEDs to we display
int curshow = NUM_LEDS;

/Not really used yet. Thought to be able to switch between sound reactive
mode, and general gradient pulsing/static color
/
int mode = 0;

//Showing different colors based on the mode.
int songmode = NORMAL;

//Average sound measurement the last CYCLES
unsigned long song_avg;

//The amount of iterations since the song_avg was reset
int iter = 0;

//The speed the LEDs fade to black if not relit
float fade_scale = 1.2;

//Led array
CRGB leds [NUM_LEDS];

/*Short sound avg used to "normalize" the input values.
We use the short average instead of using the sensor input directly */
int avgs[AVGLEN] = {-1};

//Longer sound avg
int long_avg[LONG_SECTOR] = {-1};

//Keeping track how often, and how long times we hit a certain mode
struct time_keeping {
unsigned long times_start;
short times;
};

//How much to increment or decrement each color every cycle
struct color {
int r;
int g;
int b;
};

struct time_keeping high;
struct color Color;

void setup() {
Serial.begin(9600);
//Set all lights to make sure all are working as expected
FastLED.addLeds<NEOPIXEL, LED_PIN>(leds, NUM_LEDS);
for (int i = 0; i < NUM_LEDS; i++)
leds = CRGB(0, 0, 255);

  • FastLED.show();*

  • delay(1000); *

  • //bootstrap average with some low values*

  • for (int i = 0; i < AVGLEN; i++) { *

  • insert(250, avgs, AVGLEN);*

  • }*

  • //Initial values*

  • high.times = 0;*

  • high.times_start = millis();*

  • Color.r = 0; *

  • Color.g = 0;*

  • Color.b = 1;*
    }
    /*With this we can change the mode if we want to implement a general
    lamp feature, with for instance general pulsing. Maybe if the
    sound is low for a while? */
    void loop() {

  • switch(mode) {*

  • case 0:*

  • visualize_music();*

  • break;*

  • default:*

  • break;*

  • }*

  • delay(DELAY); // delay in between reads for stability*
    }
    /**Funtion to check if the lamp should either enter a HIGH mode,
    or revert to NORMAL if already in HIGH. If the sensors report values
    that are higher than 1.1 times the average values, and this has happened
    more than 30 times the last few milliseconds, it will enter HIGH mode.
    TODO: Not very well written, remove hardcoded values, and make it more
    reusable and configurable. */
    void check_high(int avg) {
    if (avg > (song_avg/iter * 1.1)) {

  • if (high.times != 0) {*

  • if (millis() - high.times_start > 200.0) {*

  • high.times = 0;*

  • songmode = NORMAL;*

  • } else {*

  • high.times_start = millis(); *

  • high.times++; *

  • }*

  • } else {*

  • high.times++;*

  • high.times_start = millis();*

  • }*

  • }*

  • if (high.times > 30 && millis() - high.times_start < 50.0)*

  • songmode = HIGH;*

  • else if (millis() - high.times_start > 200) {*

  • high.times = 0;*

  • songmode = NORMAL;*

  • }*
    }
    //Main function for visualizing the sounds in the lamp
    void visualize_music() {

  • int sensor_value, mapped, avg, longavg;*

  • //Actual sensor value*

  • sensor_value = analogRead(ANALOG_READ);*

  • //If 0, discard immediately. Probably not right and save CPU.*

  • if (sensor_value == 0)*

  • return;*

  • //Discard readings that deviates too much from the past avg.*

  • mapped = (float)fscale(MIC_LOW, MIC_HIGH, MIC_LOW, (float)MIC_HIGH, (float)sensor_value, 2.0);*

  • avg = compute_average(avgs, AVGLEN);*
    if (((avg - mapped) > avgDEV_THRESH)) //|| ((avg - mapped) < -avgDEV_THRESH))

  • return;*

  • //Insert new avg. values*

  • insert(mapped, avgs, AVGLEN); *

  • insert(avg, long_avg, LONG_SECTOR); *

  • //Compute the "song average" sensor value*

  • song_avg += avg;*

  • iter++;*

  • if (iter > CYCLES) { *

  • song_avg = song_avg / iter;*

  • iter = 1;*

  • }*

  • longavg = compute_average(long_avg, LONG_SECTOR);*

  • //Check if we enter HIGH mode*

  • check_high(longavg); *

  • if (songmode == HIGH) {*

  • fade_scale = 3;*

  • Color.r = 5;*

  • Color.g = 3;*

  • Color.b = -1;*

  • }*

  • else if (songmode == NORMAL) {*

  • fade_scale = 2;*

  • Color.r = -1;*

  • Color.b = 2;*

  • Color.g = 1;*

  • }*

  • //Decides how many of the LEDs will be lit*

  • curshow = fscale(MIC_LOW, MIC_HIGH, 0.0, (float)NUM_LEDS, (float)avg, -1);*
    _ /*Set the different leds. Control for too high and too low values._

  • Fun thing to try: Dont account for overflow in one direction,*
    _ some interesting light effects appear! */_

  • for (int i = 0; i < NUM_LEDS; i++)*

  • //The leds we want to show*

  • if (i < curshow) {*
    _ if (leds*.r + Color.r > 255)_
    _ leds.r = 255;
    else if (leds.r + Color.r < 0)
    leds.r = 0;
    else*

    leds.r = leds*.r + Color.r;*_

_ if (leds*.g + Color.g > 255)
leds.g = 255;
else if (leds.g + Color.g < 0)
leds.g = 0;
else*

leds.g = leds*.g + Color.g;
if (leds.b + Color.b > 255)
leds.b = 255;
else if (leds.b + Color.b < 0)
leds.b = 0;
else*

leds.b = leds*.b + Color.b; *_

* //All the other LEDs begin their fading journey to eventual total darkness*
* } else {*
leds = CRGB(leds.r/fade_scale, leds.g/fade_scale, leds*.b/fade_scale);
_ }
FastLED.show();
}
//Compute average of a int array, given the starting pointer and the length*

int compute_average(int *avgs, int len) {
* int sum = 0;
for (int i = 0; i < len; i++)
sum += avgs;
return (int)(sum / len);
}
//Insert a value into an array, and shift it down removing*

//the first value if array already full
void insert(int val, int *avgs, int len) {
* for (int i = 0; i < len; i++) {
if (avgs == -1) {
avgs = val;
return;
}
}
for (int i = 1; i < len; i++) {
avgs[i - 1] = avgs;
}
avgs[len - 1] = val;
}
//Function imported from the arduino website.
//Basically map, but with a curve on the scale (can be non-uniform).
float fscale( float originalMin, float originalMax, float newBegin, float
newEnd, float inputValue, float curve){
float OriginalRange = 0;
float NewRange = 0;
float zeroRefCurVal = 0;
float normalizedCurVal = 0;
float rangedValue = 0;
boolean invFlag = 0;
// condition curve parameter*

* // limit range*
* if (curve > 10) curve = 10;
if (curve < -10) curve = -10;
curve = (curve * -.1) ; // - invert and scale - this seems more intuitive - postive numbers give more weight to high end on output_

_ curve = pow(10, curve); // convert linear scale into lograthimic exponent for other pow function*
* // Check for out of range inputValues*
* if (inputValue < originalMin) {
inputValue = originalMin;
}
if (inputValue > originalMax) {
inputValue = originalMax;
}
// Zero Refference the values*

* OriginalRange = originalMax - originalMin;
if (newEnd > newBegin){
NewRange = newEnd - newBegin;
}
else*

* {
NewRange = newBegin - newEnd;
invFlag = 1;
}
zeroRefCurVal = inputValue - originalMin;
normalizedCurVal = zeroRefCurVal / OriginalRange; // normalize to 0 - 1 float*

* // Check for originalMin > originalMax - the math for all other cases i.e. negative numbers seems to work out fine*
* if (originalMin > originalMax ) {
return 0;
}
if (invFlag == 0){
rangedValue = (pow(normalizedCurVal, curve) * NewRange) + newBegin;
}
else // invert the ranges*

* {
rangedValue = newBegin - (pow(normalizedCurVal, curve) * NewRange);
}
return rangedValue;
}*_