Herramientas de usuario

Herramientas del sitio

Traza:
proyectos:vestuario_aqa

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anteriorRevisión previa
Próxima revisión		Revisión previa
proyectos:vestuario_aqa [2019/12/04 02:35] – [Código para el proyecto del corazon] brolinproyectos:vestuario_aqa [2021/10/30 23:38] (actual) – kz
Línea 479: Línea 479:
 } }
 </code> </code>
 +
 +==== Leds + plantower: cambia color segun lectura del sensor ====
 +
 +platformio.ini
 +
 +<code c++>
 +[env:d1_mini]
 +platform = espressif8266
 +board = d1_mini
 +framework = arduino
 +lib_deps = FastLED, PMS Library, https://github.com/DedeHai/FastLEDPainter.git, Time
 +
 +</code>
 +
 +main.cpp
 +<code>
 +#include "Arduino.h"
 +#include <SoftwareSerial.h>
 +#include "PMS.h"
 +#include <FastLED.h>
 +#include <FastLEDPainter.h>
 +#include <Time.h>
 +
 +#define P_TOWER_RX D2
 +#define P_TOWER_TX 6
 +
 +// Plantower
 +SoftwareSerial plantower_serial(P_TOWER_RX, P_TOWER_TX);
 +PMS pms(plantower_serial);
 +PMS::DATA data;
 +
 +int pm2_5 = 0;
 +int *dir_pm2_5;
 +
 +// Leds
 +#define DATA_PIN D7
 +#define CLK_PIN D6
 +#define LED_TYPE DOTSTAR
 +#define COLOR_ORDER BGR
 +#define NUM_LEDS 26 // estos 10 es para que cuando lea el sensor no se vean los leds prendidos
 +#define BRIGHTNESS 96
 +CRGB leds[NUM_LEDS];
 +
 +//create one canvas and one brush with global scope
 +FastLEDPainterCanvas pixelcanvas = FastLEDPainterCanvas(NUM_LEDS);  //create canvas, linked to the FastLED library (canvas must be created before the brush)
 +FastLEDPainterBrush pixelbrush = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to
 +
 +CHSV brushcolor; //the brush and the canvas operate on HSV color space only
 +
 +int color = 0;
 +int speed = 400;
 +
 +int time_hours = 0;
 +int time_minutes = 0;
 +int time_seconds = 0;
 +
 +void readPlantower();
 +void animateLeds();
 +void updateValues();
 +
 +void setup() {
 +  //initilize FastLED library
 +  FastLED.addLeds<LED_TYPE, DATA_PIN, CLK_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
 +
 +  plantower_serial.begin(9600);
 +  Serial.begin(115200);
 +  Serial.println(" ");
 +  Serial.println(F("FastLED Painter simple demo"));
 +
 +  //check if ram allocation of brushes and canvases was successful (painting will not work if unsuccessful, program should still run though)
 +  //this check is optional but helps to check if something does not work, especially on low ram chips like the Arduino Uno
 +  if (pixelcanvas.isvalid() == false)
 +    Serial.println(F("canvas allocation problem (out of ram, reduce number of pixels)"));
 +  else
 +    Serial.println(F("canvas allocation ok"));
 +
 +  if (pixelbrush.isvalid() == false)
 +    Serial.println(F("brush allocation problem"));
 +  else
 +    Serial.println(F("brush allocation ok"));
 +
 +  //initialize the animation, this is where the magic happens:
 +  brushcolor.h = color; //zero is red in HSV. Library uses 0-255 instead of 0-360 for colors (see https://en.wikipedia.org/wiki/HSL_and_HSV)
 +  brushcolor.s = 255;   //full color saturation
 +  brushcolor.v = 130;   //about half the full brightness
 +
 +  pixelbrush.setSpeed(speed);      //set the brush movement speed (4096 means to move one pixel per update)
 +  pixelbrush.setColor(brushcolor); //set the brush color
 +  pixelbrush.setFadeSpeed(130);    //fading speed of pixels (255 is maximum fading speed)
 +  pixelbrush.setFadeout(true);     //do brightness fadeout after painting
 +  pixelbrush.setBounce(true);      //bounce the brush when it reaches the end of the strip
 +
 +  // set pointer
 +  dir_pm2_5 = &pm2_5;
 +
 +  // setup time
 +  setTime(time_hours, time_minutes, time_seconds, 30, 11, 19);
 +}
 +
 +void loop() {
 +  readPlantower();
 +}
 +
 +void readPlantower() {
 +  int sec = second();
 +  if (sec == 0 || sec == 15 || sec == 20 || sec == 30 || sec == 40 || sec == 50 ||
 +      sec == 5 || sec == 10 || sec == 35 || sec == 35 || sec == 45 || sec == 55) {
 +    pms.wakeUp();
 +    if (pms.read(data)) { 
 +      pm2_5 = data.PM_AE_UG_2_5; 
 +      delay(500);
 +      updateValues(); 
 +    }
 +    Serial.print("Leyendo pm 2.5 "); 
 +    Serial.println(*dir_pm2_5);
 +  }
 +  else {
 +    Serial.print("durmiendo. Ultimo valor ");
 +    Serial.println(*dir_pm2_5); 
 +    pms.sleep();
 +    animateLeds();
 +  }
 +  // Serial.print("sec: ");
 +  // Serial.println(sec);
 +}
 +
 +void animateLeds(){
 +  // Serial.println("Encendiendo leds");
 +  FastLED.clear();        //always need to clear the pixels, the canvas' colors will be added to whatever is on the pixels before calling a canvas update
 +  pixelbrush.paint();     //paint the brush to the canvas (and update the brush, i.e. move it a little)
 +  pixelcanvas.transfer(); //transfer the canvas to the LEDs
 +  FastLED.show();
 +}
 +
 +void updateValues() {
 +  // varia en los que varia
 +  /*
 +    233 minimo
 +    1225 maximo
 +  */
 +  if (*dir_pm2_5 < 400){ 
 +    brushcolor.h = 90; // aire bueno verde
 +    pixelbrush.setColor(brushcolor);
 +    pixelbrush.setFadeout(true);
 +    pixelbrush.setBounce(true);
 +  } else if (*dir_pm2_5 > 400 ) {
 +    brushcolor.h = 200; // aire regular azul
 +    pixelbrush.setColor(brushcolor);
 +    pixelbrush.setFadeout(true);
 +    pixelbrush.setBounce(true);
 +  } else if (*dir_pm2_5 > 800) {
 +    brushcolor.h = 155; // aire malo ?
 +    pixelbrush.setColor(brushcolor);
 +    pixelbrush.setFadeout(true);
 +    pixelbrush.setBounce(true);
 +  } else if (*dir_pm2_5 > 1200) {
 +    brushcolor.h = 0; // magenta aire podrido 
 +    pixelbrush.setColor(brushcolor);
 +    pixelbrush.setFadeout(true);
 +    pixelbrush.setBounce(true);
 +  }
 +}
 +</code>
 +
 +===== mostrar texto en matrix led 8 x 8 una pantalla =====
 +
 +<code c++>
 +
 +//Adafruit_NeoMatrix example for single NeoPixel Shield.
 +//Scrolls 'Howdy' across the matrix in a portrait (vertical) orientation.
 +#include <Arduino.h>
 +#include <Adafruit_GFX.h>
 +#include <Adafruit_NeoMatrix.h>
 +#include <Adafruit_NeoPixel.h>
 +#ifndef PSTR
 + #define PSTR // Make Arduino Due happy
 +#endif
 +
 +#define PIN D3
 +
 +// MATRIX DECLARATION:
 +// Parameter 1 = width of NeoPixel matrix
 +// Parameter 2 = height of matrix
 +// Parameter 3 = pin number (most are valid)
 +// Parameter 4 = matrix layout flags, add together as needed:
 +//   NEO_MATRIX_TOP, NEO_MATRIX_BOTTOM, NEO_MATRIX_LEFT, NEO_MATRIX_RIGHT:
 +//     Position of the FIRST LED in the matrix; pick two, e.g.
 +//     NEO_MATRIX_TOP + NEO_MATRIX_LEFT for the top-left corner.
 +//   NEO_MATRIX_ROWS, NEO_MATRIX_COLUMNS: LEDs are arranged in horizontal
 +//     rows or in vertical columns, respectively; pick one or the other.
 +//   NEO_MATRIX_PROGRESSIVE, NEO_MATRIX_ZIGZAG: all rows/columns proceed
 +//     in the same order, or alternate lines reverse direction; pick one.
 +//   See example below for these values in action.
 +// Parameter 5 = pixel type flags, add together as needed:
 +//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
 +//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
 +//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
 +//   NEO_GRBW    Pixels are wired for GRBW bitstream (RGB+W NeoPixel products)
 +//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
 +
 +
 +// Example for NeoPixel Shield.  In this application we'd like to use it
 +// as a 5x8 tall matrix, with the USB port positioned at the top of the
 +// Arduino.  When held that way, the first pixel is at the top right, and
 +// lines are arranged in columns, progressive order.  The shield uses
 +// 800 KHz (v2) pixels that expect GRB color data.
 +// Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(16, 8, PIN,
 +//   NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
 +//   NEO_MATRIX_COLUMNS + NEO_MATRIX_PROGRESSIVE,
 +//   NEO_GRB            + NEO_KHZ800);
 +
 +Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(8, 8, PIN,
 +  NEO_MATRIX_TOP     + NEO_MATRIX_RIGHT +
 +  NEO_MATRIX_COLUMNS + NEO_MATRIX_PROGRESSIVE,
 +  NEO_GRB            + NEO_KHZ800
 +);
 +
 +const uint16_t colors[] = {
 +  matrix.Color(255, 0, 0), matrix.Color(0, 255, 0), matrix.Color(0, 0, 255) 
 +};
 +
 +String Word = "Golondrinas, llanaditas, un/loquer, 2021";
 +
 +void setup() {
 +  matrix.begin();
 +  matrix.setTextWrap(false);
 +  matrix.setBrightness(40);
 +  matrix.setTextColor(colors[0]);
 +}
 +
 +int x    = matrix.width();
 +int pass = 0;
 +int pixelsInText = (Word.length() * 7)+8;
 +
 +void loop() {
 +  matrix.fillScreen(0);
 +  matrix.setCursor(x, 0);
 +  matrix.print(Word);
 +  if(--x < -pixelsInText) {
 +    x = matrix.width();
 +    if(++pass >= 3) pass = 0;
 +    matrix.setTextColor(colors[pass]);
 +  }
 +  matrix.show();
 +  delay(100);
 +}
 +
 +</code>
 +
 +==== código para manipular con microfono la intensidad de la matriz de led ====
 +
 +<code c++>
 +
 +#include <Arduino.h>
 +#include <FastLED.h>
 +#define LED_PIN     D2
 +#define LED_TYPE    WS2812B
 +#define COLOR_ORDER GRB
 +#define f false
 +#define t true
 + 
 +const uint8_t kMatrixWidth  = 8;
 +const uint8_t kMatrixHeight = 8;
 +#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
 + 
 +int BRIGHTNESS = 60;   // this is half brightness
 +CRGB leds[kMatrixWidth * kMatrixHeight];
 + 
 +#define amarillo CRGB::Yellow 
 +#define black CRGB::Black 
 +#define rojo CRGB::Red
 +#define blue CRGB::Blue
 + 
 +int loop_cnt = 0;
 +
 +const int sampleWindow = 50; // Sample window width in mS (50 mS = 20Hz)
 +unsigned int sample;
 +
 +uint8_t noise[kMatrixWidth][kMatrixHeight];
 + 
 +void setup() {
 +  Serial.begin(115200);
 +  LEDS.addLeds<LED_TYPE,LED_PIN,COLOR_ORDER>(leds,NUM_LEDS);
 +  FastLED.setBrightness(BRIGHTNESS);
 +}
 + 
 +#define ESCENAS 1
 + 
 +CRGB matrix[ESCENAS][8][8] = {
 +  {
 +    {blue, blue, blue,blue, blue, blue, blue,blue},
 +    {blue, blue, blue,blue, blue, blue, blue,blue},
 +    {blue, blue, blue,blue, blue, blue, blue,blue},
 +    {blue, blue, blue,blue, blue, blue, blue,blue},
 +    {blue, blue, blue,blue, blue, blue, blue,blue},
 +    {blue, blue, blue,blue, blue, blue, blue,blue},
 +    {blue, blue, blue,blue, blue, blue, blue,blue},
 +    {blue, blue, blue,blue, blue, blue, blue,blue},
 +  },
 +};
 + 
 +void loop() {
 +  for(int i = 0; i< kMatrixHeight; i++) {
 +    for(int j = 0; j< kMatrixWidth; j++) {
 +      leds[i*kMatrixWidth + j] = matrix[loop_cnt%ESCENAS][i][j];
 +    }
 +  }
 +  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 < sampleWindow)
 +   {
 +      sample = analogRead(0);
 +      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
 +   double volts = (peakToPeak * 5.0) / 1024;  // convert to volts
 +
 +  int cambiarBrillo = map(volts, 0, 5, 0, 100);
 +  Serial.println(cambiarBrillo);
 +  FastLED.show();
 +  FastLED.setBrightness(cambiarBrillo);
 +  loop_cnt++;
 +}
 +
 +</code>
 +
  
proyectos/vestuario_aqa.1575426937.txt.gz · Última modificación: 2019/12/04 02:35 por brolin