Elektroda.pl
Elektroda.pl
X
PCBway
Proszę, dodaj wyjątek dla www.elektroda.pl do Adblock.
Dzięki temu, że oglądasz reklamy, wspierasz portal i użytkowników.

Vu meter arduino - dwa vu meter na jednym pasku led.

06 Wrz 2015 09:17 1377 12
  • Poziom 10  
    Witam. Zabawę z arduino zacząłem parę tygodni temu. Zrobiłem proste "programy" sterujące paskiem led RGB. Znalazłem gotowy kod do vu meter. Działa fajnie, jednak gdzieś znalazłem film na którym da się zrobić dwa takie wskaźniki na jednym pasku led. Moje pytanie do was brzmi: jak połączyć dwa wskazniki na jednym pasku. Głowie się i nic nie wychodzi. :/
  • PCBway
  • Specjalista - Mikrokontrolery
    Biorąc pod uwagę ilość informacji, jaką dostarczyłeś, jest to pytanie do wróżki, a nie do inżynierów, a to jest forum dla inżynierów, a nie dla wróżek.
  • PCBway
  • Poziom 10  
    Arduino uno.
    Pasek LED WS2812B sygnał zbierany jest z mikrofonu. Co jeszcze podać?
  • Specjalista - Mikrokontrolery
    Czyli mamy nieznany program i znany pasek LED o nieznanym podłączeniu i mamy Ci pomóc zmodyfikować ten nieznany program?

    Ok, spróbujemy. Znajdź fragment programu, który zamienia wartość na obraz wyświetlany na LED i powiel ten fragment, a potem zmień tak, żeby modyfikował dalszy ciąg tablicy zawierającej kolory LED.

    ;)
  • Poziom 10  
    Mam obecnie taki kod- są w nim 3 działające vu metry i jeden nie bardzo i dołożyłem kilka zwyklych schematów.

    Spoiler:

    #include <Adafruit_NeoPixel.h>
    #include <FastLED.h>
    #define PIN 4
    #define LED_DT 4
    #define LED_PIN 4 // NeoPixel LED strand is connected to this pin
    #define NUM_LEDS 27
    #define N_PIXELS 27
    #define Pixels 27
    #define BG 0
    // Number of pixels in strand
    #define COLOR_ORDER GRB // Try mixing up the letters (RGB, GBR, BRG, etc) for a whole new world of color combinations
    #define BRIGHTNESS 255 // 0-255, higher number is brighter.
    #define LED_TYPE WS2812B
    #define MIC_PIN A5 // Microphone is attached to this analog pin
    #define DC_OFFSET 0 // DC offset in mic signal - if unusure, leave 0
    #define NOISE 10 // Noise/hum/interference in mic signal
    #define SAMPLES 60 // Length of buffer for dynamic level adjustment
    #define TOP (N_PIXELS + 2) // Allow dot to go slightly off scale
    #define PEAK_FALL 40 // Rate of peak falling dot
    #define N_PIXELS_HALF (N_PIXELS/2)
    #define GRAVITY -9.81 // Downward (negative) acceleration of gravity in m/s^2
    #define h0 1 // Starting height, in meters, of the ball (strip length)
    #define NUM_BALLS 3 // Number of bouncing balls you want (recommend < 7, but 20 is fun in its own way)
    #define SPEED .20 // Amount to increment RGB color by each cycle
    //config for balls
    float h[NUM_BALLS] ; // An array of heights
    float vImpact0 = sqrt( -2 * GRAVITY * h0 ); // Impact velocity of the ball when it hits the ground if "dropped" from the top of the strip
    float vImpact[NUM_BALLS] ; // As time goes on the impact velocity will change, so make an array to store those values
    float tCycle[NUM_BALLS] ; // The time since the last time the ball struck the ground
    int pos[NUM_BALLS] ; // The integer position of the dot on the strip (LED index)
    long tLast[NUM_BALLS] ; // The clock time of the last ground strike
    float COR[NUM_BALLS] ; // Coefficient of Restitution (bounce damping)

    float
    greenOffset = 30,
    blueOffset = 150;

    byte
    peak = 0, // Used for falling dot
    dotCount = 0, // Frame counter for delaying dot-falling speed
    volCount = 0; // Frame counter for storing past volume data
    int
    vol[SAMPLES], // Collection of prior volume samples
    lvl = 10, // Current "dampened" audio level
    minLvlAvg = 0, // For dynamic adjustment of graph low & high
    maxLvlAvg = 512;


    Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

    // FOR SYLON ETC
    uint8_t thisbeat = 23;
    uint8_t thatbeat = 28;
    uint8_t thisfade = 2; // How quickly does it fade? Lower = slower fade rate.
    uint8_t thissat = 255; // The saturation, where 255 = brilliant colours.
    uint8_t thisbri = 255;

    //FOR JUGGLE
    uint8_t numdots = 4; // Number of dots in use.
    uint8_t faderate = 2; // How long should the trails be. Very low value = longer trails.
    uint8_t hueinc = 16; // Incremental change in hue between each dot.
    uint8_t thishue = 0; // Starting hue.
    uint8_t curhue = 0;
    uint8_t thisbright = 255; // How bright should the LED/display be.
    uint8_t basebeat = 5;
    uint8_t max_bright = 255;

    // Twinkle
    float redStates[Pixels];
    float blueStates[Pixels];
    float greenStates[Pixels];
    float Fade = 0.96;

    // Vu meter 4
    const uint32_t Red = strip.Color(255, 0, 0);
    const uint32_t Yellow = strip.Color(255, 255, 0);
    const uint32_t Green = strip.Color(0, 255, 0);
    const uint32_t Blue = strip.Color(0, 0, 255);
    const uint32_t White = strip.Color(255, 255, 255);
    const uint32_t Dark = strip.Color(0, 0, 0);
    unsigned int sample;

    CRGB leds[NUM_LEDS];

    int myhue = 0;


    // constants used here to set pin numbers:
    const int buttonPin = 1; // the number of the pushbutton pin

    // Variables will change:

    int buttonPushCounter = 0; // counter for the number of button presses
    int buttonState = 0; // current state of the button
    int lastButtonState = 0;

    //Ripple variables
    int color;
    int center = 0;
    int step = -1;
    int maxSteps = 16;
    float fadeRate = 0.80;
    int diff;

    //background color
    uint32_t currentBg = random(256);
    uint32_t nextBg = currentBg;

    void setup() {
    delay( 2000 ); // power-up safety delay
    FastLED.addLeds<WS2812B, PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness( BRIGHTNESS );
    analogReference(EXTERNAL);
    memset(vol, 0, sizeof(vol));
    LEDS.addLeds<LED_TYPE, LED_DT, COLOR_ORDER>(leds, NUM_LEDS);
    strip.begin();
    strip.show(); // Initialize all pixels to 'off'


    //initialize the serial port
    Serial.begin(115200);
    pinMode(buttonPin, INPUT);
    //initialize the buttonPin as output
    digitalWrite(buttonPin, HIGH);

    for (int i = 0 ; i < NUM_BALLS ; i++) { // Initialize variables
    tLast[i] = millis();
    h[i] = h0;
    pos[i] = 0; // Balls start on the ground
    vImpact[i] = vImpact0; // And "pop" up at vImpact0
    tCycle[i] = 0;
    COR[i] = 0.90 - float(i)/pow(NUM_BALLS,2);


    }
    }

    void loop() {

    //for mic
    uint8_t i;
    uint16_t minLvl, maxLvl;
    int n, height;
    // end mic

    // read the pushbutton input pin:
    buttonState = digitalRead(buttonPin);
    // compare the buttonState to its previous state
    if (buttonState != lastButtonState) {
    // if the state has changed, increment the counter
    if (buttonState == HIGH) {
    // if the current state is HIGH then the button
    // wend from off to on:
    buttonPushCounter++;
    Serial.println("on");
    Serial.print("number of button pushes: ");
    Serial.println(buttonPushCounter);
    if(buttonPushCounter==15) {
    buttonPushCounter=1;}
    }
    else {
    // if the current state is LOW then the button
    // wend from on to off:
    Serial.println("off");
    }
    }
    // save the current state as the last state,
    //for next time through the loop
    lastButtonState = buttonState;


    switch (buttonPushCounter){

    case 1:
    buttonPushCounter==1; {
    colorWipe(strip.Color(160, 160, 160), 50); // white
    break;}

    case 2:
    buttonPushCounter==2; {
    vu(); // Red
    break;}

    case 3:
    buttonPushCounter==3; {
    vu2(); // Red
    break;}

    case 4:
    buttonPushCounter==4; {
    Vu3(); //
    break;}

    case 5:
    buttonPushCounter==5; {
    Vu4(); //
    break;}

    case 6:
    buttonPushCounter==6; {
    rainbow(150);
    break;}

    case 7:
    buttonPushCounter==7; {
    rainbow(20);
    break;}

    case 8:
    buttonPushCounter==8; {
    ripple();
    break;}

    case 9:
    buttonPushCounter==9; {
    ripple2();
    break;}

    case 10:
    buttonPushCounter==10; {
    Twinkle();
    break;}

    case 11:
    buttonPushCounter==11; {
    pattern2();
    break;}

    case 12:
    buttonPushCounter==12; {
    pattern3();
    break;}

    case 13:
    buttonPushCounter==13; {
    Balls(); //
    break;}

    case 14:
    buttonPushCounter==14; {
    colorWipe(strip.Color(0, 0, 0), 10); // A Black
    break;}




    }



    }

    void colorWipe(uint32_t c, uint8_t wait) {
    for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    if (digitalRead(buttonPin) != lastButtonState) // <------------- add this
    return; // <------------ and this
    delay(wait);
    }
    }
    void Vu4() {
    unsigned long startMillis= millis(); // Start of sample window
    unsigned int peakToPeak = 0; // peak-to-peak level

    unsigned int signalMax = 0;
    unsigned int signalMin = 1024;

    // collect data for 50 mS
    while (millis() - startMillis < 50)
    {
    sample = analogRead(A5);
    if (sample < 1024) // toss out spurious readings
    {
    if (sample > signalMax)
    {
    signalMax = sample; // save just the max levels
    }
    else if (sample < signalMin)
    {
    signalMin = sample; // save just the min levels
    }
    }
    }
    peakToPeak = signalMax - signalMin; // max - min = peak-peak amplitude

    if (peakToPeak < 500)
    color = Blue;
    if (peakToPeak >= 500 && peakToPeak < 750)
    color = Red;
    if (peakToPeak >= 750)
    color = Yellow;

    for (int i = 0; i < 120; i ++)
    strip.setPixelColor(i, Dark);
    for (int i = 0; i < map(peakToPeak, 0,1024, 0,100); i ++)
    strip.setPixelColor(i, color);

    Serial.println(analogRead(0));

    strip.show();
    }




    void Vu3() {
    uint8_t i;
    uint16_t minLvl, maxLvl;
    int n, height;

    n = analogRead(MIC_PIN); // Raw reading from mic
    n = abs(n - 512 - DC_OFFSET); // Center on zero
    n = (n <= NOISE) ? 0 : (n - NOISE); // Remove noise/hum
    lvl = ((lvl * 7) + n) >> 3; // "Dampened" reading (else looks twitchy)

    // Calculate bar height based on dynamic min/max levels (fixed point):
    height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

    if (height < 0L) height = 0; // Clip output
    else if (height > TOP) height = TOP;
    if (height > peak) peak = height; // Keep 'peak' dot at top

    greenOffset += SPEED;
    blueOffset += SPEED;
    if (greenOffset >= 255) greenOffset = 0;
    if (blueOffset >= 255) blueOffset = 0;

    // Color pixels based on rainbow gradient
    for (i = 0; i < NUM_LEDS; i++) {
    if (i >= height) {
    strip.setPixelColor(i, 0, 0, 0);
    } else {
    strip.setPixelColor(i, Wheel(
    map(i, 0, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset)
    ));
    }
    }
    // Draw peak dot
    if(peak > 0 && peak <= N_PIXELS-1) strip.setPixelColor(peak,Wheel(map(peak,0,strip.numPixels()-1,30,150)));

    strip.show(); // Update strip

    // Every few frames, make the peak pixel drop by 1:

    if(++dotCount >= PEAK_FALL) { //fall rate

    if(peak > 0) peak--;
    dotCount = 0;
    }
    strip.show(); // Update strip

    vol[volCount] = n;
    if (++volCount >= SAMPLES) {
    volCount = 0;
    }

    // Get volume range of prior frames
    minLvl = maxLvl = vol[0];
    for (i = 1; i < SAMPLES; i++) {
    if (vol[i] < minLvl) {
    minLvl = vol[i];
    } else if (vol[i] > maxLvl) {
    maxLvl = vol[i];
    }
    }

    // minLvl and maxLvl indicate the volume range over prior frames, used
    // for vertically scaling the output graph (so it looks interesting
    // regardless of volume level). If they're too close together though
    // (e.g. at very low volume levels) the graph becomes super coarse
    // and 'jumpy'...so keep some minimum distance between them (this
    // also lets the graph go to zero when no sound is playing):
    if ((maxLvl - minLvl) < TOP) {
    maxLvl = minLvl + TOP;
    }
    minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; // Dampen min/max levels
    maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; // (fake rolling average)
    }


    void Balls() {
    for (int i = 0 ; i < NUM_BALLS ; i++) {
    tCycle[i] = millis() - tLast[i] ; // Calculate the time since the last time the ball was on the ground

    // A little kinematics equation calculates positon as a function of time, acceleration (gravity) and intial velocity
    h[i] = 0.5 * GRAVITY * pow( tCycle[i]/1000 , 2.0 ) + vImpact[i] * tCycle[i]/1000;

    if ( h[i] < 0 ) {
    h[i] = 0; // If the ball crossed the threshold of the "ground," put it back on the ground
    vImpact[i] = COR[i] * vImpact[i] ; // and recalculate its new upward velocity as it's old velocity * COR
    tLast[i] = millis();

    if ( vImpact[i] < 0.01 ) vImpact[i] = vImpact0; // If the ball is barely moving, "pop" it back up at vImpact0
    }
    pos[i] = round( h[i] * (NUM_LEDS - 1) / h0); // Map "h" to a "pos" integer index position on the LED strip
    }

    //Choose color of LEDs, then the "pos" LED on
    for (int i = 0 ; i < NUM_BALLS ; i++) leds[pos[i]] = CHSV( uint8_t (i * 40) , 255, 255);
    FastLED.show();
    //Then off for the next loop around
    for (int i = 0 ; i < NUM_BALLS ; i++) {
    leds[pos[i]] = CRGB::Black;
    }
    }



    // Slightly different, this makes the rainbow equally distributed throughout
    void rainbowCycle(uint8_t wait) {
    uint16_t i, j;

    for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
    strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    if (digitalRead(buttonPin) != lastButtonState) // <------------- add this
    return; // <------------ and this
    delay(wait);
    }
    }
    // HERE


    void vu() {

    uint8_t i;
    uint16_t minLvl, maxLvl;
    int n, height;

    n = analogRead(MIC_PIN); // Raw reading from mic
    n = abs(n - 512 - DC_OFFSET); // Center on zero
    n = (n <= NOISE) ? 0 : (n - NOISE); // Remove noise/hum
    lvl = ((lvl * 7) + n) >> 3; // "Dampened" reading (else looks twitchy)

    // Calculate bar height based on dynamic min/max levels (fixed point):
    height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

    if(height < 0L) height = 0; // Clip output
    else if(height > TOP) height = TOP;
    if(height > peak) peak = height; // Keep 'peak' dot at top


    // Color pixels based on rainbow gradient
    for(i=0; i<N_PIXELS; i++) {
    if(i >= height) strip.setPixelColor(i, 0, 0, 0);
    else strip.setPixelColor(i,Wheel(map(i,0,strip.numPixels()-1,30,150)));

    }


    // Draw peak dot
    if(peak > 0 && peak <= N_PIXELS-1) strip.setPixelColor(peak,Wheel(map(peak,0,strip.numPixels()-1,30,150)));

    strip.show(); // Update strip

    // Every few frames, make the peak pixel drop by 1:

    if(++dotCount >= PEAK_FALL) { //fall rate

    if(peak > 0) peak--;
    dotCount = 0;
    }



    vol[volCount] = n; // Save sample for dynamic leveling
    if(++volCount >= SAMPLES) volCount = 0; // Advance/rollover sample counter

    // Get volume range of prior frames
    minLvl = maxLvl = vol[0];
    for(i=1; i<SAMPLES; i++) {
    if(vol[i] < minLvl) minLvl = vol[i];
    else if(vol[i] > maxLvl) maxLvl = vol[i];
    }
    // minLvl and maxLvl indicate the volume range over prior frames, used
    // for vertically scaling the output graph (so it looks interesting
    // regardless of volume level). If they're too close together though
    // (e.g. at very low volume levels) the graph becomes super coarse
    // and 'jumpy'...so keep some minimum distance between them (this
    // also lets the graph go to zero when no sound is playing):
    if((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;
    minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; // Dampen min/max levels
    maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; // (fake rolling average)

    }

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


    void vu2() {

    uint8_t i;
    uint16_t minLvl, maxLvl;
    int n, height;



    n = analogRead(MIC_PIN); // Raw reading from mic
    n = abs(n - 512 - DC_OFFSET); // Center on zero
    n = (n <= NOISE) ? 0 : (n - NOISE); // Remove noise/hum
    lvl = ((lvl * 7) + n) >> 3; // "Dampened" reading (else looks twitchy)

    // Calculate bar height based on dynamic min/max levels (fixed point):
    height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

    if(height < 0L) height = 0; // Clip output
    else if(height > TOP) height = TOP;
    if(height > peak) peak = height; // Keep 'peak' dot at top


    // Color pixels based on rainbow gradient
    for(i=0; i<N_PIXELS_HALF; i++) {
    if(i >= height) {
    strip.setPixelColor(N_PIXELS_HALF-i-1, 0, 0, 0);
    strip.setPixelColor(N_PIXELS_HALF+i, 0, 0, 0);
    }
    else {
    uint32_t color = Wheel(map(i,0,N_PIXELS_HALF-1,30,150));
    strip.setPixelColor(N_PIXELS_HALF-i-1,color);
    strip.setPixelColor(N_PIXELS_HALF+i,color);
    }

    }



    // Draw peak dot
    if(peak > 0 && peak <= N_PIXELS_HALF-1) {
    uint32_t color = Wheel(map(peak,0,N_PIXELS_HALF-1,30,150));
    strip.setPixelColor(N_PIXELS_HALF-peak-1,color);
    strip.setPixelColor(N_PIXELS_HALF+peak,color);
    }

    strip.show(); // Update strip

    // Every few frames, make the peak pixel drop by 1:

    if(++dotCount >= PEAK_FALL) { //fall rate

    if(peak > 0) peak--;
    dotCount = 0;
    }



    vol[volCount] = n; // Save sample for dynamic leveling
    if(++volCount >= SAMPLES) volCount = 0; // Advance/rollover sample counter

    // Get volume range of prior frames
    minLvl = maxLvl = vol[0];
    for(i=1; i<SAMPLES; i++) {
    if(vol[i] < minLvl) minLvl = vol[i];
    else if(vol[i] > maxLvl) maxLvl = vol[i];
    }
    // minLvl and maxLvl indicate the volume range over prior frames, used
    // for vertically scaling the output graph (so it looks interesting
    // regardless of volume level). If they're too close together though
    // (e.g. at very low volume levels) the graph becomes super coarse
    // and 'jumpy'...so keep some minimum distance between them (this
    // also lets the graph go to zero when no sound is playing):
    if((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;
    minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; // Dampen min/max levels
    maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; // (fake rolling average)

    }

    //here................

    void ripple() {

    if (currentBg == nextBg) {
    nextBg = random(256);
    }
    else if (nextBg > currentBg) {
    currentBg++;
    } else {
    currentBg--;
    }
    for(uint16_t l = 0; l < NUM_LEDS; l++) {
    leds[l] = CHSV(currentBg, 255, 50); // strip.setPixelColor(l, Wheel(currentBg, 0.1));
    }

    if (step == -1) {
    center = random(NUM_LEDS);
    color = random(256);
    step = 0;
    }

    if (step == 0) {
    leds[center] = CHSV(color, 255, 255); // strip.setPixelColor(center, Wheel(color, 1));
    step ++;
    }
    else {
    if (step < maxSteps) {
    Serial.println(pow(fadeRate,step));

    leds[wrap(center + step)] = CHSV(color, 255, pow(fadeRate, step)*255); // strip.setPixelColor(wrap(center + step), Wheel(color, pow(fadeRate, step)));
    leds[wrap(center - step)] = CHSV(color, 255, pow(fadeRate, step)*255); // strip.setPixelColor(wrap(center - step), Wheel(color, pow(fadeRate, step)));
    if (step > 3) {
    leds[wrap(center + step - 3)] = CHSV(color, 255, pow(fadeRate, step - 2)*255); // strip.setPixelColor(wrap(center + step - 3), Wheel(color, pow(fadeRate, step - 2)));
    leds[wrap(center - step + 3)] = CHSV(color, 255, pow(fadeRate, step - 2)*255); // strip.setPixelColor(wrap(center - step + 3), Wheel(color, pow(fadeRate, step - 2)));
    }
    step ++;
    }
    else {
    step = -1;
    }
    }

    LEDS.show();
    delay(50);
    }


    int wrap(int step) {
    if(step < 0) return NUM_LEDS + step;
    if(step > NUM_LEDS - 1) return step - NUM_LEDS;
    return step;
    }


    void one_color_allHSV(int ahue, int abright) { // SET ALL LEDS TO ONE COLOR (HSV)
    for (int i = 0 ; i < NUM_LEDS; i++ ) {
    leds[i] = CHSV(ahue, 255, abright);
    }
    }


    void ripple2() {
    if (BG){
    if (currentBg == nextBg) {
    nextBg = random(256);
    }
    else if (nextBg > currentBg) {
    currentBg++;
    } else {
    currentBg--;
    }
    for(uint16_t l = 0; l < N_PIXELS; l++) {
    strip.setPixelColor(l, Wheel(currentBg, 0.1));
    }
    } else {
    for(uint16_t l = 0; l < N_PIXELS; l++) {
    strip.setPixelColor(l, 0, 0, 0);
    }
    }


    if (step == -1) {
    center = random(N_PIXELS);
    color = random(256);
    step = 0;
    }



    if (step == 0) {
    strip.setPixelColor(center, Wheel(color, 1));
    step ++;
    }
    else {
    if (step < maxSteps) {
    strip.setPixelColor(wrap(center + step), Wheel(color, pow(fadeRate, step)));
    strip.setPixelColor(wrap(center - step), Wheel(color, pow(fadeRate, step)));
    if (step > 3) {
    strip.setPixelColor(wrap(center + step - 3), Wheel(color, pow(fadeRate, step - 2)));
    strip.setPixelColor(wrap(center - step + 3), Wheel(color, pow(fadeRate, step - 2)));
    }
    step ++;
    }
    else {
    step = -1;
    }
    }

    strip.show();
    delay(50);
    }
    //int wrap(int step) {
    // if(step < 0) return Pixels + step;
    // if(step > Pixels - 1) return step - Pixels;
    // return step;
    //}



    // 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, float opacity) {

    if(WheelPos < 85) {
    return strip.Color((WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity, 0);
    }
    else if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color((255 - WheelPos * 3) * opacity, 0, (WheelPos * 3) * opacity);
    }
    else {
    WheelPos -= 170;
    return strip.Color(0, (WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity);
    }
    }


    void pattern2() {

    sinelon(); // Call our sequence.
    show_at_max_brightness_for_power(); // Power managed display of LED's.
    } // loop()


    void sinelon() {
    // a colored dot sweeping back and forth, with fading trails
    fadeToBlackBy( leds, NUM_LEDS, thisfade);
    int pos1 = beatsin16(thisbeat,0,NUM_LEDS);
    int pos2 = beatsin16(thatbeat,0,NUM_LEDS);
    leds[(pos1+pos2)/2] += CHSV( myhue++/64, thissat, thisbri);
    }
    // Pattern 3 - JUGGLE
    void pattern3() {
    ChangeMe();
    juggle();
    show_at_max_brightness_for_power(); // Power managed display of LED's.
    } // loop()


    void juggle() { // Several colored dots, weaving in and out of sync with each other
    curhue = thishue; // Reset the hue values.
    fadeToBlackBy(leds, NUM_LEDS, faderate);
    for( int i = 0; i < numdots; i++) {
    leds[beatsin16(basebeat+i+numdots,0,NUM_LEDS)] += CHSV(curhue, thissat, thisbright); //beat16 is a FastLED 3.1 function
    curhue += hueinc;
    }
    } // juggle()


    void ChangeMe() { // A time (rather than loop) based demo sequencer. This gives us full control over the length of each sequence.
    uint8_t secondHand = (millis() / 1000) % 30; // IMPORTANT!!! Change '30' to a different value to change duration of the loop.
    static uint8_t lastSecond = 99; // Static variable, means it's only defined once. This is our 'debounce' variable.
    if (lastSecond != secondHand) { // Debounce to make sure we're not repeating an assignment.
    lastSecond = secondHand;
    if (secondHand == 0) {numdots=1; faderate=2;} // You can change values here, one at a time , or altogether.
    if (secondHand == 10) {numdots=4; thishue=128; faderate=8;}
    if (secondHand == 20) {hueinc=48; thishue=random8();} // Only gets called once, and not continuously for the next several seconds. Therefore, no rainbows.
    }
    } // ChangeMe()

    void Twinkle () {
    if (random(25) == 1) {
    uint16_t i = random(Pixels);
    if (redStates[i] < 1 && greenStates[i] < 1 && blueStates[i] < 1) {
    redStates[i] = random(256);
    greenStates[i] = random(256);
    blueStates[i] = random(256);
    }
    }

    for(uint16_t l = 0; l < Pixels; l++) {
    if (redStates[l] > 1 || greenStates[l] > 1 || blueStates[l] > 1) {
    strip.setPixelColor(l, redStates[l], greenStates[l], blueStates[l]);

    if (redStates[l] > 1) {
    redStates[l] = redStates[l] * Fade;
    } else {
    redStates[l] = 0;
    }

    if (greenStates[l] > 1) {
    greenStates[l] = greenStates[l] * Fade;
    } else {
    greenStates[l] = 0;
    }

    if (blueStates[l] > 1) {
    blueStates[l] = blueStates[l] * Fade;
    } else {
    blueStates[l] = 0;
    }

    } else {
    strip.setPixelColor(l, 0, 0, 0);
    }
    }
    strip.show();
    delay(10);

    }

    // TOO HERE

    void rainbow(uint8_t wait) {
    uint16_t i, j;

    for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    // check if a button pressed
    if (digitalRead(buttonPin) != lastButtonState) // <------------- add this
    return; // <------------ and this
    delay(wait);
    }
    }


  • Poziom 3  
    Nie chcę zaczynać nowego tematu, bo wątek bardzo podobny do mojego problemu - widzę, że troszkę przy tym działaliście, czy ktoś jest w stanie podjąć się wykonania układu, który odczytywałby napięcie w zakresie od 48V do 63V i w zależności od jego wartości zmieniał kolor paska LED? Od czerwonego, przez pomarańczowy, żółty, do zielonego np?

    Jeśli tak - macie doświadczenie i jesteście w stanie oszacować wielkość takiego układu?

    Dzięki,
    Pozdrawiam,
    Igor
  • Poziom 1  
  • Poziom 3  
    o_Tadeusz napisał:
    Mithcio napisał:
    Jeśli tak - macie doświadczenie i jesteście w stanie oszacować wielkość takiego układu?

    Wielkość w sensie wymiarów czy w sensie wielkości kodu?


    Wymiarów :)
  • Poziom 1  
  • Poziom 3  
    o_Tadeusz napisał:
    Mithcio napisał:
    o_Tadeusz napisał:
    Mithcio napisał:
    Jeśli tak - macie doświadczenie i jesteście w stanie oszacować wielkość takiego układu?

    Wielkość w sensie wymiarów czy w sensie wielkości kodu?

    Wymiarów :)

    Zależy jakie masz możliwości technologiczne i ile kasy.
    Jesteś w stanie montować układy w miniaturowych obudowach jak BGA?
    Wykonasz wielowarstwowe PCB?
    Kupisz gotowy miniaturowy zasilacz, który tani nie będzie?


    Na ostatnie pytanie odpowiem "tak". Reszta niestety nie - szukam właśnie kogoś, kto by to fizycznie zrobił, ale średnio idzie, więc jako część projektu bym to liczył. Jaki to jest rząd wielkości (koszt) w przypadku ogarnięcia całego projektu od zera do wykonania fizycznego i oprogramowania?
  • Poziom 1  
  • Poziom 3  
    Dzięki :)
    10k to troszkę dużo, samo urządzenie kosztuje 8k...2k do przeżycia, więcej - muszę pomyśleć.
  • Poziom 1