Frickelpiet.de

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Sie befinden sich hier: start » arduino » silentbase_802_neopixel » programmversion_1
Zuletzt angesehen:
arduino:silentbase_802_neopixel:programmversion_1

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
arduino:silentbase_802_neopixel:programmversion_1 [18.03.2023 08:27] – Frickelpietarduino:silentbase_802_neopixel:programmversion_1 [18.05.2023 12:34] (aktuell) – Externe Bearbeitung 127.0.0.1
Zeile 1: Zeile 1:
-====== Beleuchtung für BeQuiet SilentBase 802 - Programmversion 1 ======+====== Neopixel-Feuereffekt für das SilentBase 802 - Programmversion 1 ====== 
 +Diesem Programm liegt der Fire2012-Effekt von Mark Kriegsman aus der FastLED-Bibliothek zugrunde, der allerdings so umgeschrieben wurde, dass er mit der Adafruit NeoPixel-Bibliothek funktioniert. 
 + 
 +<code> 
 +// Beleuchtung BeQuiet SilentBase 802 
 +// Arduino Nano (Every) 
 + 
 +//------------------------- Eingebundene Bibliotheken ---------------------// 
 +#include <OneWire.h>                         // Bibliothek für die Kommunikation über OneWire 
 +#include <DallasTemperature.h>               // Bibliothek für die digitalen Temperatursensoren DS18B20 
 +#include <Adafruit_NeoPixel.h>               // Bibliothek für die NeoPixel 
 + 
 +// Debug-Level 
 +#define DEBUG_EFFECT                                        // Ausgabe sehr vieler Daten an die serielle Schnittstelle 
 +//#define DEBUG_SENSOR                                   // Ausgabe der Sensordaten und Betriebszustände an die serielle Schnittstelle 
 + 
 +//------------------------- Definition der Inputs und Outputs ---------------------// 
 +#define NEOPIN1       2            // NeoPixel-Strip rechte Seite 
 +#define NEOPIN2       4            // NeoPixel-Strip linke Seite 
 +#define POWERPIN      3            // Schaltet über den MOSFET die NeoPixel-Streifen ein 
 +#define LEDPIN1       6            // LED 1 
 +#define LEDPIN2       8            // LED 2 
 +#define ONE_WIRE_BUS 11       // Datenleitung für die Temperatursensoren DS18B20 
 + 
 +//-------------------------- Definition der Auflösung der Temperatursensoren ----// 
 +// 9 bit resolution: 0,5°C increments, takes 94 ms for A/D conversion 
 +// 10 bit resolution: 0,25°C increments, takes 188 ms for A/D conversion 
 +// 11 bit resolution: 0,125°C increments, takes 375 ms for A/D conversion 
 +// 12 bit resolution: 0,0625°C increments, takes 750 ms for A/D conversion 
 +#define TEMPERATURE_PRECISION 11 
 + 
 +// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs) 
 +OneWire oneWire(ONE_WIRE_BUS); 
 + 
 +// Pass our oneWire reference to Dallas Temperature. 
 +DallasTemperature sensors(&oneWire); 
 + 
 +// arrays to hold device addresses 
 +DeviceAddress sensor0, sensor1, sensor2; 
 + 
 +// Definiert die Variablen 
 +int numPixels = 71;           // Anzahl der NeoPixel 
 +float temperature;            // Die höchste an den drei Sensoren gemessene Temperatur 
 +int load;                     // Variable repäsentiert später die Differenz zwischen minimaler und maximaler Netzteillast in Prozent 
 + 
 +float temperature_min = 20;   // Konfiguriert den unteren Grenzwert der Gehäusetemperatur 
 +float temperature_max = 40;   // Konfiguriert den oberen Grenzwert der Gehäusetemperatur 
 + 
 +boolean LEDstate; 
 +boolean POWERstate = 0;       // Wird "1" sobald der Loop aufgerufen wird 
 + 
 +int cooling;                  // Variable für Beleuchtungseffekt Flammen 
 +int sparkling;                // Variable für Beleuchtungseffekt Flammen 
 +int cooldown; 
 +static byte heat[71];         // Ein Array für die Temperaturwerte 
 +byte t192;                    // Variable für Beleuchtungseffekt Flammen 
 +   
 +// Definiert die NeoPixel-Strips 
 +Adafruit_NeoPixel strip1 = Adafruit_NeoPixel(numPixels, NEOPIN1, NEO_GRB + NEO_KHZ800); 
 +Adafruit_NeoPixel strip2 = Adafruit_NeoPixel(numPixels, NEOPIN2, NEO_GRB + NEO_KHZ800); 
 + 
 + 
 + 
 +// Definiert die globalen RGBW-Werte 
 +byte r = 0; 
 +byte g = 0; 
 +byte b = 0; 
 +byte w = 0; 
 + 
 + 
 +// Definiert die Tracking-Variablen für die IF-Abfragen 
 +unsigned long previousMillisSensors = 0; 
 +unsigned long previousMillisLED = 0; 
 +unsigned long previousMillisEffect = 0; 
 +unsigned long previousMillisSerialPrint = 0; 
 + 
 +// Definiert die Intervalle für die IF-Abfragen 
 +int intervalSensors = 1000;      // Delay für Auslesen der Temperatursensoren 
 +int intervalLED = 500;           // Delay für die Ausgabe der Temperatur als Blinkfrequenz der LED2 
 +int intervalEffect = 5;         // Delay für Effekte 
 +int intervalSerialPrint = 1000;  // Delay für serielle Ausgabe 
 + 
 + 
 +void setup() { 
 +  digitalWrite(POWERPIN, LOW);                  // Schaltet den MOSFET aus 
 +  Serial.begin(115200); 
 +   
 +  // Initialisiere die NeoPixel-Pins 
 +  pinMode(NEOPIN1, OUTPUT); 
 +  pinMode(NEOPIN2, OUTPUT); 
 +  pinMode(POWERPIN, OUTPUT); 
 +  pinMode(LEDPIN1, OUTPUT); 
 +  pinMode(LEDPIN2, OUTPUT); 
 +   
 +  
 +  // Initialisiere die NeoPixel-Strips 
 +  digitalWrite(POWERPIN, HIGH); 
 +   
 +  strip1.begin(); // Initialisiert das Neopixel 
 +  //strip1.show();  // Macht das NeoPixel sichtbar 
 +  strip1.clear(); // Macht das NeoPixel aus 
 +   
 +  strip2.begin(); // Initialisiert das Neopixel 
 +  //strip2.show();  // Macht das NeoPixel sichtbar 
 +  strip2.clear(); // Macht das NeoPixel aus 
 +   
 +  // Start up the library 
 +  sensors.begin(); 
 + 
 +  // locate devices on the bus 
 +  Serial.print("Locating devices..."); 
 +  Serial.print("Found "); 
 +  Serial.print(sensors.getDeviceCount(), DEC); 
 +  Serial.println(" devices."); 
 + 
 +  // Search for devices on the bus and assign based on an index. Ideally, 
 +  // you would do this to initially discover addresses on the bus and then 
 +  // use those addresses and manually assign them (see above) once you know 
 +  // the devices on your bus (and assuming they don't change). 
 +  // 
 +  // method 1: by index 
 +  if (!sensors.getAddress(sensor0, 0)) Serial.println("Unable to find address for Device 0"); 
 +  if (!sensors.getAddress(sensor1, 1)) Serial.println("Unable to find address for Device 1"); 
 +  if (!sensors.getAddress(sensor2, 2)) Serial.println("Unable to find address for Device 2"); 
 + 
 +  // show the addresses we found on the bus 
 +  Serial.print("Device 0 Address: "); 
 +  printAddress(sensor0); 
 +  Serial.println(); 
 + 
 +  Serial.print("Device 1 Address: "); 
 +  printAddress(sensor1); 
 +  Serial.println(); 
 + 
 +  Serial.print("Device 2 Address: "); 
 +  printAddress(sensor2); 
 +  Serial.println(); 
 +   
 +  // set the resolution to 11 bit per device 
 +  sensors.setResolution(sensor0, TEMPERATURE_PRECISION); 
 +  sensors.setResolution(sensor1, TEMPERATURE_PRECISION); 
 +  sensors.setResolution(sensor2, TEMPERATURE_PRECISION); 
 + 
 +  Serial.print("Device 0 Resolution: "); 
 +  Serial.println(sensors.getResolution(sensor0), DEC); 
 + 
 +  Serial.print("Device 1 Resolution: "); 
 +  Serial.println(sensors.getResolution(sensor1), DEC); 
 + 
 +  Serial.print("Device 2 Resolution: "); 
 +  Serial.println(sensors.getResolution(sensor2), DEC); 
 + 
 +delay (2000); 
 +} 
 + 
 +void loop() { 
 +  // Aktuelle Zeit abfragen 
 +  unsigned long currentMillis = millis(); 
 + 
 +  // Schaltet die NeoPixel ein und initialisiert die NeoPixel 
 +  if(POWERstate == 0) { 
 +    POWERstate = 1; 
 +    digitalWrite(LEDPIN1, HIGH);                   // Schaltet LED1 ein 
 +    /* 
 +    digitalWrite(POWERPIN, HIGH);                  // Schaltet den MOSFET durch 
 +     
 +    strip1.begin(); // Initialisiert das Neopixel 
 +    strip1.show();  // Macht das NeoPixel sichtbar 
 +    //strip1.clear(); // Macht das NeoPixel aus 
 +   
 +    strip2.begin(); // Initialisiert das Neopixel 
 +    strip2.show();  // Macht das NeoPixel sichtbar 
 +    //strip2.clear(); // Macht das NeoPixel aus 
 +    */ 
 +  } 
 + 
 +// Auslesen der Temperatursensoren und Berechnen einiger Variablen zur Beeinflussung des Effekts 
 +  if ((unsigned long)(currentMillis - previousMillisSensors) >= intervalSensors) { 
 +   
 +    // Request to all devices on the bus 
 +    //temperature conversion - non-blocking / async 
 +    unsigned long start = micros();        
 +    sensors.setWaitForConversion(false);  // makes it async 
 +    sensors.requestTemperatures(); 
 +    sensors.setWaitForConversion(true); 
 +    unsigned long stop = micros(); 
 +     
 +    #ifdef DEBUG_SENSOR 
 +    Serial.print("Time used: "); 
 +    Serial.print(stop - start); 
 +    Serial.println(" microseconds"); 
 + 
 +    // print the device information 
 +    printData(sensor0); 
 +    printData(sensor1); 
 +    printData(sensor2); 
 +    #endif 
 +     
 +    // Berechnen der höchsten Temperatur an den verfügbaren Sensoren 
 +    float tempSensor0 = sensors.getTempC(sensor0); 
 +    float tempSensor1 = sensors.getTempC(sensor1); 
 +    float tempSensor2 = sensors.getTempC(sensor2); 
 + 
 +    temperature = 0; 
 +    temperature = tempSensor0; 
 +    if(tempSensor1 > temperature) { 
 +      temperature = tempSensor1; 
 +    } 
 +    if(tempSensor2 > temperature) { 
 +      temperature = tempSensor2; 
 +    } 
 +    #ifdef DEBUG_SENSOR 
 +    Serial.print("Temperature: "); 
 +    Serial.print(temperature); 
 +    Serial.println(" °C"); 
 +    #endif 
 +     
 +    // Berechenen der Blinkfrequenz von LED2 
 +    if(temperature < temperature_min) { 
 +      temperature = temperature_min; 
 +    } 
 +    if(temperature > temperature_max) { 
 +      temperature = temperature_max; 
 +    } 
 +    intervalLED = map(temperature, temperature_min, temperature_max, 1000, 250); 
 +    #ifdef DEBUG_SENSOR 
 +    Serial.print("Blink frequency LED2: "); Serial.println(intervalLED); Serial.print(" ms"); 
 +    #endif 
 +     
 +    // Berechnung der Netzteillast in Prozent: Bei ruhendem Desktop soll der Wert 0 sein, bei maximaler Auslastung 100 
 +    load = map(temperature, temperature_min, temperature_max, 0, 100); 
 + 
 +    // Berechnung von Cooling für den Effekt Fire 2012: Legt fest, wie stark die aufsteigenden Flammen abkühlen 
 +    // Werte zwischen 20 und 100 sollen am hübschesten sein, ein guter Standard ist 50 
 +    cooling = map(temperature, temperature_min, temperature_max, 100, 20); 
 + 
 +    // Berechnung von Sparkling für den Effekt Fire2012: Legt fest, wie oft ein Funke auflohdert 
 +    //Werte zwischen 50 und 200 sollen am hübschesten sein, ein guter Standard ist 120 
 +    sparkling = map(temperature, temperature_min, temperature_max, 30, 200); 
 + 
 +    #ifdef DEBUG_EFFECT 
 +    //Serial.print("load: "); 
 +    Serial.print(load); Serial.print("\t"); 
 +    //Serial.print("cooling: "); 
 +    Serial.print(cooling); Serial.print("\t"); 
 +    //Serial.print("sparkling: "); 
 +    Serial.println(sparkling); 
 +    #endif 
 +     
 +  //Speichere die aktuelle Zeit in die zughörige Variable 
 +  previousMillisSensors = currentMillis; 
 +  } 
 + 
 + 
 +// Ausgabe der Temperatur als Blinkfrequenz der LED1 
 +  if ((unsigned long)(currentMillis - previousMillisLED) >= intervalLED) { 
 + 
 +    if(LEDstate == 0) { 
 +      digitalWrite(LEDPIN2, HIGH); 
 +      //Serial.println("LED an"); 
 +      LEDstate = 1; 
 +    } 
 +    else if(LEDstate == 1) { 
 +      digitalWrite(LEDPIN2, LOW); 
 +      //Serial.println("LED aus"); 
 +      LEDstate = 0; 
 +    } 
 +     
 +     
 +  //Speichere die aktuelle Zeit in die zughörige Variable 
 +  previousMillisLED = currentMillis; 
 +  } 
 + 
 + 
 +  // Feuer-Effekt 
 +      if ((unsigned long)(currentMillis - previousMillisEffect) >= intervalEffect) { 
 + 
 +      // Step 1.  Cool down every cell a little 
 +      for(int i = 0; i < numPixels; i++) {     
 +        cooldown = random(0, ((cooling * 10) / numPixels) + 2); 
 +     
 +        if(cooldown > heat[i]) { 
 +          heat[i] = 0; 
 +            } else { 
 +            heat[i] = heat[i] - cooldown; 
 +            } 
 +          } 
 + 
 +      // Step 2.  Heat from each cell drifts 'up' and diffuses a little 
 +      if( t192 > 0x80) {                                                // hottest 
 +        for(int k = numPixels - 1; k >= 2; k--) { 
 +          heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;      // muss noch angepasst werden 
 +        } 
 +          } else if( t192 > 0x40 ) {                                    // middle 
 +          for(int k = numPixels - 1; k >= 2; k--) { 
 +          heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;      // muss noch angepasst werden 
 +        } 
 +          } else {                                                      // coolest 
 +          for(int k = numPixels - 1; k >= 2; k--) {  
 +          heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;      // muss noch angepasst werden 
 +        } 
 +          }  
 +     
 +    // Step 3.  Randomly ignite new 'sparks' near the bottom 
 +      if(random(255) < sparkling) { 
 +        int l = random(7); 
 +        heat[l] = heat[l] + random(160,255); 
 +        //heat[l] = random(160,255); 
 +        } 
 + 
 +    // Step 4.  Convert heat to LED colors 
 +      for(int j = numPixels -1; j >= 0; j--) {         
 +        // Scale 'heat' down from 0-255 to 0-191 
 +        t192 = round((heat[j]  /255.0) * 191); 
 +  
 +        // calculate ramp up from 
 +        byte heatramp = t192 & 0x3F; // 0..63 
 +        heatramp <<= 2; // scale up to 0..252 
 + 
 +        // figure out which third of the spectrum we're in: 
 +        if( t192 > 0x80) {                       // hottest 
 +          strip1.setPixelColor(map(j, 0, numPixels, numPixels, 0), 255, 255, heatramp); 
 +          strip2.setPixelColor(map(j, 0, numPixels, numPixels, 0), 255, 255, heatramp); 
 +          } else if( t192 > 0x40 ) {             // middle 
 +          strip1.setPixelColor(map(j, 0, numPixels, numPixels, 0), 255, heatramp, 0); 
 +          strip2.setPixelColor(map(j, 0, numPixels, numPixels, 0), 255, heatramp, 0); 
 +          } else {                               // coolest 
 +          strip1.setPixelColor(map(j, 0, numPixels, numPixels, 0), heatramp, 0, 0); 
 +          strip2.setPixelColor(map(j, 0, numPixels, numPixels, 0), heatramp, 0, 0);   
 +          } 
 +        } 
 +      strip1.show(); 
 +      strip2.show(); 
 +       
 +     
 +    //Speichere die aktuelle Zeit in die zughörige Variable 
 +    previousMillisEffect = currentMillis; 
 +    } 
 +} 
 + 
 + 
 +// function to print a device address 
 +void printAddress(DeviceAddress deviceAddress) 
 +{ 
 +  for (uint8_t i = 0; i < 8; i++) 
 +  { 
 +    // zero pad the address if necessary 
 +    if (deviceAddress[i] < 16) Serial.print("0"); 
 +    Serial.print(deviceAddress[i], HEX); 
 +  } 
 +} 
 + 
 +// function to print the temperature for a device 
 +void printTemperature(DeviceAddress deviceAddress) 
 +{ 
 +  float tempC = sensors.getTempC(deviceAddress); 
 +  Serial.print("Temp C: "); 
 +  Serial.print(tempC); 
 +} 
 + 
 +// function to print a device's resolution 
 +void printResolution(DeviceAddress deviceAddress) 
 +{ 
 +  Serial.print("Resolution: "); 
 +  Serial.print(sensors.getResolution(deviceAddress)); 
 +  Serial.println(); 
 +} 
 + 
 +// main function to print information about a device 
 +void printData(DeviceAddress deviceAddress) 
 +{ 
 +  Serial.print("Device Address: "); 
 +  printAddress(deviceAddress); 
 +  Serial.print(" "); 
 +  printTemperature(deviceAddress); 
 +  Serial.println(); 
 +} 
 +</code>
  
 {{tag>Arduino Neopixel PC}} {{tag>Arduino Neopixel PC}}
arduino/silentbase_802_neopixel/programmversion_1.1679124459.txt.gz · Zuletzt geändert: 18.05.2023 12:16 (Externe Bearbeitung)