/** draw a frame, interpolating between 2 "key frames" @param pcnt percentage of interpolation */ void EWCDisplay::_drawFrame(int pcnt) { int nextv; unsigned char h; unsigned char s; unsigned char v; //each row interpolates with the one before it for (unsigned char y = M_HEIGHT - 1; y > 0; y--) { for (unsigned char x = 0; x < M_WIDTH; x++) { h = _hueMask[y][x]; s = 255; nextv = (((100.0 - pcnt) * _matrix[x][y] + _pcnt * _matrix[x][y - 1]) / 100.0) - _valueMask[y][x]; v = (unsigned char)_max(0, nextv); _setPixel(x, y, RgbColor(HsbColor(h, s, v))); } } //first row interpolates with the "next" line for (unsigned char x = 0; x < M_WIDTH; x++) { h = _hueMask[0][x]; s = 255; v = (unsigned char)(((100.0 - _pcnt) * _matrix[x][0] + _pcnt * _line[x]) / 100.0); _setPixel(x, 0, RgbColor(HsbColor(h, s, v))); } }
static inline RgbColor rgb_mandelbrot(const int its, const int max_iterations, const cmplx lastvector) { if (its == 0 || its == max_iterations) return RgbColor(0, 0, 0); const double smoothed = its - log( log(squ_abs(lastvector))/2.0 / log(max_iterations) ) / log(2); const unsigned brightness = std::min(std::pow(std::max(smoothed-6, 0.0), 2), 255.0); HsvColor hsv(static_cast<unsigned>(its) % 256, 255, brightness); return RgbColor(hsv); }
Sphere::Sphere(){ this->center_ = new Point3D(0,0,0); this->radius_ = 1.0; PhongShader* default_shader = new PhongShader(); this->shader_ = default_shader; setDiffuseColor(RgbColor(0,0,0)); setSpecularHighlight(RgbColor(0,0,0)); setPhongConstant(0); setReflectiveColor(RgbColor(0,0,0)); setRefractionIndex(0.0); }
void flashgreen(uint8_t wait, uint8_t flashes) { uint16_t i, z; for (z=0; z<flashes; z++) { for(i=0; i<PixelCount; i++) { strip.SetPixelColor(i, RgbColor (0, 255, 0)); } strip.Show(); delay(wait); for(i=0; i<PixelCount; i++) { strip.SetPixelColor(i, RgbColor (0, 0, 0)); } strip.Show(); delay(wait); } }
void EWCDisplay::_displayStripRandomColor() { for (int i = 0; i < _stackptr; i++) { _leds[_ledStrip[i]] = RgbColor(HsbColor(random(0, 255), 255, 255)); } _showStrip(); }
void offblack() { uint16_t i; for(i=0; i<PixelCount; i++) { strip.SetPixelColor(i, RgbColor (0, 0, 0)); } strip.Show(); }
void LightMatrixManager::clearDisplay() { for (int i = 0; i < NUMPIXELS; i++) { _pixels.SetPixelColor(i, RgbColor(0, 0, 0)); } }
//------------------------------------------------------------------------------ // static std::string ToRgbString(const UnsignedInt &intColor) //------------------------------------------------------------------------------ std::string RgbColor::ToRgbString(const UnsignedInt &intColor) { char buffer[20]; RgbColor color = RgbColor(intColor); sprintf(buffer, "[%d %d %d]", color.Red(), color.Green(), color.Blue()); return std::string(buffer); }
/* set the ledstrip to a certain (r, g, b) value. */ void setWS2812Strip(int r, int g, int b) { for(int i = 0; i < ws2812_striplen;i++) { RgbColor color = RgbColor(r, g, b); strip->SetPixelColor(i, color); } }
RgbColor RgbColor::unserialize(JSONObject object) { int new_red = atoi(JSONString::extract_string(object["red"]).c_str()); int new_blue = atoi(JSONString::extract_string(object["blue"]).c_str()); int new_green = atoi(JSONString::extract_string(object["green"]).c_str()); return RgbColor(new_red, new_green, new_blue); }
//------------------------------------------------------------------------------ // void OnColorPickerChange(wxColourPickerEvent& event) //------------------------------------------------------------------------------ void GmatColorPanel::OnColorPickerChange(wxColourPickerEvent& event) { #ifdef DEBUG_COLOR_CHANGE MessageInterface::ShowMessage("GmatColorPanel::OnColorPickerChange() entered\n"); #endif if (event.GetEventObject() == mOrbitColorCtrl) { wxColour wxcolor = mOrbitColorCtrl->GetColour(); RgbColor rgbColor = RgbColor(wxcolor.Red(), wxcolor.Green(), wxcolor.Blue()); if (mUseInputObjectColor) { mOrbitIntColor = rgbColor.GetIntColor(); } else { std::string colorStr = RgbColor::ToRgbString(rgbColor.GetIntColor()); theClonedSpacePoint-> SetStringParameter(theClonedSpacePoint->GetParameterID("OrbitColor"), colorStr); } } else if (event.GetEventObject() == mTargetColorCtrl) { wxColour wxcolor = mTargetColorCtrl->GetColour(); RgbColor rgbColor = RgbColor(wxcolor.Red(), wxcolor.Green(), wxcolor.Blue()); if (mUseInputObjectColor) { mTargetIntColor = rgbColor.GetIntColor(); } else { std::string colorStr = RgbColor::ToRgbString(rgbColor.GetIntColor()); theClonedSpacePoint-> SetStringParameter(theClonedSpacePoint->GetParameterID("TargetColor"), colorStr); } } mHasColorChanged = true; theParentGmatPanel->EnableUpdate(true); #ifdef DEBUG_COLOR_CHANGE MessageInterface::ShowMessage("GmatColorPanel::OnColorPickerChange() leaving\n"); #endif }
static RgbColor temp2color(uint16_t temp, uint8_t brightness) { uint8_t r = std::min<uint32_t>(255, temp); temp -= r; uint8_t g = std::min<uint32_t>(255, temp); temp -= g; r = (r * uint32_t(brightness) + 255) / 256; g = (g * uint32_t(brightness) + 255) / 512; temp = (temp * uint32_t(brightness) + 255) / 1024; return RgbColor(r, g, temp); }
// -- NeoPixel Sunrise Functions void sunrise(uint16_t wait) { uint16_t i, j; for(j=0; j<256; j++) { for(i=0; i<PixelCount; i++) { strip.SetPixelColor(i, RgbColor (j, 0, 0)); } strip.Show(); delay(wait); } }
void LightMatrixManager::clearReservationsMappedToPixels() { for (uint8_t week = 0; week < MAX_WEEKS; week++) { for (uint8_t day = 0; day < NUM_COLUMNS; day++) { for (uint8_t hour = 0; hour < NUM_ROWS; hour++) { _reservation[week][day][hour] = RgbColor(0,0,0); } } } }
//------------------------------------------------------------------------------ // void ShowSpacePointColor(const wxString &name, UnsignedInt color = GmatColor::RED) //------------------------------------------------------------------------------ void GroundTrackPlotPanel::ShowSpacePointColor(const wxString &name, UnsignedInt color) { #ifdef DEBUG_PANEL_COLOR MessageInterface::ShowMessage ("OrbitViewPanel::ShowSpacePointColor() name='%s'\n", name.c_str()); #endif if (!name.IsSameAs("")) { std::string selObjName = name.c_str(); // if object name not found, insert if (mOrbitColorMap.find(selObjName) == mOrbitColorMap.end()) { #ifdef DEBUG_PANEL_COLOR MessageInterface::ShowMessage ("ShowSpacePointColor() name not found, so adding it to color map\n"); #endif mOrbitColorMap[selObjName] = RgbColor(color); mTargetColorMap[selObjName] = RgbColor(GmatColor::ORANGE); } RgbColor orbColor = mOrbitColorMap[selObjName]; RgbColor targColor = mTargetColorMap[selObjName]; #ifdef DEBUG_PANEL_COLOR MessageInterface::ShowMessage ("OrbitViewPanel::ShowSpacePointColor() orbColor=%u, targColor=%u\n", orbColor.GetIntColor(), targColor.GetIntColor()); #endif mOrbitColor.Set(orbColor.Red(), orbColor.Green(), orbColor.Blue()); mTargetColor.Set(targColor.Red(), targColor.Green(), targColor.Blue()); mOrbitColorCtrl->SetColour(mOrbitColor); mTargetColorCtrl->SetColour(mTargetColor); } }
RgbColor JpegMap::blurPixel(const unsigned x, const unsigned y) const { unsigned r = 0, g = 0, b = 0; unsigned cnt = 4; addPixelRgbValues(getPixel(x, y), r, g, b, cnt); if (x > 0 ) { addPixelRgbValues(getPixel(x-1, y ), r, g, b); ++cnt; } if (x < _width-1 ) { addPixelRgbValues(getPixel(x+1, y ), r, g, b); ++cnt; } if (y > 0 ) { addPixelRgbValues(getPixel(x , y-1), r, g, b); ++cnt; } if (y < _height-1) { addPixelRgbValues(getPixel(x , y+1), r, g, b); ++cnt; } return RgbColor(r / cnt, g / cnt, b / cnt); }
void loop() { ArduinoOTA.handle(); // -- MQTT connect if (!client.connected()) { error_path += thisDevicePath; error_path += "/"; error_path += "errors/"; error_path += thisDeviceName; if (client.connect(MQTT::Connect(thisDeviceName).set_will(error_path, "disconnected"))) { Serial.println("MQTT connected"); client.set_callback(callback); client.subscribe(MQTT::Subscribe() .add_topic("/deviceInfo/#") .add_topic("/global/#") .add_topic(subscribe_path) ); // notify persistence of device IP String persistence_ip_path = "/persistence/control/"; persistence_ip_path += thisDeviceName; persistence_ip_path += "/ip"; client.publish(MQTT::Publish(persistence_ip_path, local_ip_str).set_qos(2)); // ask persistence/control/device_name/chipID "request states" -- do you have any states with my device_name or chipID String persistence_path = "/persistence/control/"; persistence_path += thisDeviceName; persistence_path += "/"; persistence_path += chip_id; client.publish(MQTT::Publish(persistence_path, "request states").set_qos(2)); Serial.println("request states sent"); } } if (client.connected()) { client.loop(); } // -- NeoPixel continuous update for(int i=0; i<PixelCount; i++) { strip.SetPixelColor(i, RgbColor (redValue, greenValue, blueValue)); } strip.Show(); yield(); }
RgbColor getMirektoRGB(int mirek) { int hectemp = 10000 / mirek; int r, g, b; if (hectemp <= 66) { r = COLOR_SATURATION; g = 99.4708025861 * log(hectemp) - 161.1195681661; b = hectemp <= 19 ? 0 : (138.5177312231 * log(hectemp - 10) - 305.0447927307); } else { r = 329.698727446 * pow(hectemp - 60, -0.1332047592); g = 288.1221695283 * pow(hectemp - 60, -0.0755148492); b = COLOR_SATURATION; } r = r > COLOR_SATURATION ? COLOR_SATURATION : r; g = g > COLOR_SATURATION ? COLOR_SATURATION : g; b = b > COLOR_SATURATION ? COLOR_SATURATION : b; return RgbColor(r, g, b); }
RgbColor RgbColor::BilinearBlend(const RgbColor& c00, const RgbColor& c01, const RgbColor& c10, const RgbColor& c11, float x, float y) { float v00 = (1.0f - x) * (1.0f - y); float v10 = x * (1.0f - y); float v01 = (1.0f - x) * y; float v11 = x * y; return RgbColor( c00.R * v00 + c10.R * v10 + c01.R * v01 + c11.R * v11, c00.G * v00 + c10.G * v10 + c01.G * v01 + c11.G * v11, c00.B * v00 + c10.B * v10 + c01.B * v01 + c11.B * v11); }
RgbColor getXYtoRGB(float x, float y, int brightness_raw) { float brightness = ((float)brightness_raw) / 255.0f; float bright_y = brightness / y; float X = x * bright_y; float Z = (1 - x - y) * bright_y; // convert to RGB (0.0-1.0) color space float R = X * 1.4628067 - brightness * 0.1840623 - Z * 0.2743606; float G = -X * 0.5217933 + brightness * 1.4472381 + Z * 0.0677227; float B = X * 0.0349342 - brightness * 0.0968930 + Z * 1.2884099; // apply inverse 2.2 gamma float inv_gamma = 1.0 / 2.4; float linear_delta = 0.055; float linear_interval = 1 + linear_delta; float r = R <= 0.0031308 ? 12.92 * R : (linear_interval) * pow(R, inv_gamma) - linear_delta; float g = G <= 0.0031308 ? 12.92 * G : (linear_interval) * pow(G, inv_gamma) - linear_delta; float b = B <= 0.0031308 ? 12.92 * B : (linear_interval) * pow(B, inv_gamma) - linear_delta; return RgbColor(r * COLOR_SATURATION, g * COLOR_SATURATION, b * COLOR_SATURATION); }
//------------------------------------------------------------------------------ // void OnCheckBoxChange(wxCommandEvent& event) //------------------------------------------------------------------------------ void GmatColorPanel::OnCheckBoxChange(wxCommandEvent& event) { mHasOverrideColorChanged = true; mOverrideOrbitColor = mOverrideOrbitColorCheckBox->GetValue(); if (mOverrideOrbitColor) { mOrbitColorLabel->Enable(true); mOrbitColorCtrl->Enable(true); } else { // Show original orbit color RgbColor rgbOrbitColor = RgbColor(mDefaultOrbitColor); mOrbitColor.Set(rgbOrbitColor.Red(), rgbOrbitColor.Green(), rgbOrbitColor.Blue()); mOrbitColorCtrl->SetColour(mOrbitColor); mOrbitIntColor = rgbOrbitColor.GetIntColor(); mOrbitColorLabel->Enable(false); mOrbitColorCtrl->Enable(false); } theParentGmatPanel->EnableUpdate(true); }
/* fade all the pixels individually from one color to the next. creating a rainbow like effect. */ void rainbowWS2812(int speed, int brightness) { cinterval = speed + 1; ccurrent = millis(); if((ccurrent - cprevious) >= cinterval) { cprevious = ccurrent; static int range = 0xff*3; uint8_t buffer[3][ws2812_striplen]; int i, s; colors = colorinc(); for(i = 0; i < ws2812_striplen; i++) { for(s = 0; s < range/ws2812_striplen; s++) colors = colorinc(); float brightnessFactor = (float)(((float)brightness) / 100); int r = colors[RED] * brightnessFactor; int g = colors[GREEN] * brightnessFactor; int b = colors[BLUE] * brightnessFactor; RgbColor rgbcolor = RgbColor(r, g, b); strip->SetPixelColor(i, rgbcolor); } } }
RgbColor RgbColor::LinearBlend(RgbColor left, RgbColor right, float progress) { return RgbColor( left.R + ((right.R - left.R) * progress), left.G + ((right.G - left.G) * progress), left.B + ((right.B - left.B) * progress)); }
RgbColor JpegMap::getPixel(const unsigned x, const unsigned y) const { const unsigned offset = ( x + y * _width ) * _bpp; if (x >= _width || y >= _height) return RgbColor(0, 0, 0); return RgbColor(_raw[offset], _raw[offset+1], _raw[offset+2]); }
//------------------------------------------------------------------------------ UnsignedInt RgbColor::ToIntColor(const std::string &colorString) { #ifdef DEBUG_INT_COLOR MessageInterface::ShowMessage ("RgbColor::ToIntColor() entered, colorString = '%s'\n", colorString.c_str()); #endif // First figure out if input is a color name ColorDatabase *colorDb = ColorDatabase::Instance(); UnsignedInt intColor; if (!GmatStringUtil::StartsWith(colorString, "[") && !GmatStringUtil::EndsWith(colorString, "]")) { if (colorDb->HasColor(colorString)) { intColor = colorDb->GetIntColor(colorString); #ifdef DEBUG_INT_COLOR MessageInterface::ShowMessage("RgbColor::ToIntColor() returning %06X\n", intColor); #endif return intColor; } else { UtilityException ue; ue.SetDetails("The color \"%s\" not found in the color database. " "Available colors are \"%s\"", colorString.c_str(), colorDb->GetAllColorNames().c_str()); throw ue; } } // It is rgb tuples UnsignedIntArray intArray = GmatStringUtil::ToUnsignedIntArray(colorString); Byte rgb[3]; bool error = false; if (intArray.size() != 3) { error = true; } else { for (UnsignedInt i = 0; i < intArray.size(); i++) { if (intArray[i] < 0 || intArray[i] > 255) { error = true; break; } else { rgb[i] = intArray[i]; } } } if (error) { UtilityException ue; ue.SetDetails("\"%s\" has invalid RGB color values. Valid color value is " "triplet Integer number between 0 and 255 inside of [ ]", colorString.c_str()); throw ue; } else { RgbColor color = RgbColor(rgb[0], rgb[1], rgb[2]); intColor = color.GetIntColor(); #ifdef DEBUG_INT_COLOR MessageInterface::ShowMessage("RgbColor::ToIntColor() returning %06X\n", intColor); #endif return intColor; } }
AmbientLight::AmbientLight() { this->color_ = RgbColor(0,0,0); }
DirectionalLight::DirectionalLight(){ this->color_ = RgbColor(0,0,0); this->direction_from_light_ = new Vector3D(0,0,0); }
//------------------------------------------------------------------------------ // void LoadData() //------------------------------------------------------------------------------ void GmatColorPanel::LoadData() { #ifdef DEBUG_PANEL_LOAD MessageInterface::ShowMessage("GmatColorPanel::LoadData() entered.\n"); #endif try { if (mUseInputObjectColor) { // Load colors from the input object name SpacePoint *sp = (SpacePoint*) ((theParentGmatPanel->GetGuiInterpreter())->GetConfiguredObject(mSpacePointName)); if (sp) { mOrbitIntColor = sp->GetCurrentOrbitColor(); mTargetIntColor = sp->GetCurrentTargetColor(); } } else { // Load colors from the spacecraft mOrbitIntColor = theClonedSpacePoint->GetCurrentOrbitColor(); mTargetIntColor = theClonedSpacePoint->GetCurrentTargetColor(); } mDefaultOrbitColor = mOrbitIntColor; if (mOverrideOrbitColor) mOrbitIntColor = mOverrdingColor; RgbColor rgbOrbitColor = RgbColor(mOrbitIntColor); RgbColor rgbTargetColor = RgbColor(mTargetIntColor); #ifdef DEBUG_PANEL_LOAD MessageInterface::ShowMessage(" rgbOrbitColor = %06X\n", rgbOrbitColor.GetIntColor()); MessageInterface::ShowMessage(" rgbTargetColor = %06X\n", rgbTargetColor.GetIntColor()); #endif mOrbitColor.Set(rgbOrbitColor.Red(), rgbOrbitColor.Green(), rgbOrbitColor.Blue()); mOrbitColorCtrl->SetColour(mOrbitColor); mTargetColor.Set(rgbTargetColor.Red(), rgbTargetColor.Green(), rgbTargetColor.Blue()); mTargetColorCtrl->SetColour(mTargetColor); // If showing only orbit color, hide target color if (mShowOrbitColorOnly) { mTargetColorLabel->Hide(); mTargetColorCtrl->Hide(); } // Set value to overrding color CheckBox if (mOverrideOrbitColor) mOverrideOrbitColorCheckBox->SetValue(true); else mOverrideOrbitColorCheckBox->SetValue(false); // If not showing override color check box, hide it if (!mShowOverrideOrbitColorCheckBox) mOverrideOrbitColorCheckBox->Hide(); else { // If not overriding orbit color, disable it if (!mOverrideOrbitColor) { mOrbitColorLabel->Disable(); mOrbitColorCtrl->Disable(); } } Layout(); } catch (BaseException &e) { MessageInterface::PopupMessage(Gmat::ERROR_, e.GetFullMessage().c_str()); } #ifdef DEBUG_PANEL_LOAD MessageInterface::ShowMessage("GmatColorPanel::LoadData() leaving\n"); #endif }
void loop() { ArduinoOTA.handle(); // -- MQTT connect if (!client.connected()) { error_path += thisDevicePath; error_path += "/"; error_path += "errors/"; error_path += thisDeviceName; if (client.connect(MQTT::Connect(thisDeviceName).set_will(error_path, "disconnected"))) { Serial.println("MQTT connected"); client.set_callback(callback); client.subscribe(MQTT::Subscribe() .add_topic("/deviceInfo/#") .add_topic("/global/#") .add_topic(subscribe_path) ); // notify persistence of device IP String persistence_ip_path = "/persistence/control/"; persistence_ip_path += thisDeviceName; persistence_ip_path += "/ip"; client.publish(MQTT::Publish(persistence_ip_path, local_ip_str).set_qos(2)); // ask persistence/control/device_name/chipID "request states" -- do you have any states with my device_name or chipID String persistence_path = "/persistence/control/"; persistence_path += thisDeviceName; persistence_path += "/"; persistence_path += chip_id; client.publish(MQTT::Publish(persistence_path, "request states").set_qos(2)); Serial.println("request states sent"); } } if (client.connected()) { client.loop(); } /* // -- Device Request Response if (sendJSON) { buildDeviceJson(); // flag set to false inside function } */ /* // -- Confirm Messages if (sendConfirm) { client.publish(MQTT::Publish(confirmPath, confirmPayload).set_qos(2)); sendConfirm = false; } */ /* // -- NeoPixel updates if (neoPixelChange) { for(int i=0; i<PixelCount; i++) { strip.SetPixelColor(i, RgbColor (redValue, greenValue, blueValue)); } strip.Show(); neoPixelChange = false; } */ // -- NeoPixel continuous update for(int i=0; i<PixelCount; i++) { strip.SetPixelColor(i, RgbColor (redValue, greenValue, blueValue)); } strip.Show(); /* // -- NeoPixel Sunrise Alarm Code if (millis() - lastcheck > alarmcheck) { DateTime now = RTC.now(); lastcheck = millis(); if (alarmminute == now.minute() && alarmhour == now.hour()) { sunrise(4000); sunrise(400); sunrise(40); sunrise(40); sunrise(40); sunrise(40); sunrise(40); sunrise(20); sunrise(20); black(); } } */ // Do things every NTPLimit seconds if ( millis() - tick > NTPlimit) { tick = millis(); /* // -- get server and send NTP packet //get a random server from the pool WiFi.hostByName(ntpServerName, timeServerIP); sendNTPpacket(timeServerIP); // send an NTP packet to a time server // wait to see if a reply is available delay(1000); int cb = udp.parsePacket(); if (!cb) { Serial.println("no packet yet"); } else { //Serial.print("packet received, length="); //Serial.println(cb); udp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer unsigned long highWord = word(packetBuffer[40], packetBuffer[41]); unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]); // combine the four bytes (two words) into a long integer // this is NTP time (seconds since Jan 1 1900): unsigned long secsSince1900 = highWord << 16 | lowWord; const unsigned long seventyYears = 2208988800UL; unsigned long epoch = secsSince1900 - seventyYears; int UTChour = (epoch % 86400L) / 3600; // (86400 equals secs per day) int UTCmin = (epoch % 3600) / 60; // (3600 equals secs per minute) //Serial.println(UTChour); Serial.print(year(epoch)); Serial.print('-'); Serial.print(month(epoch)); Serial.print('-'); Serial.println(day(epoch)); Serial.print("The UTC time is "); // UTC is the time at Greenwich Meridian (GMT) Serial.print(UTChour); Serial.print(':'); if ( ((epoch % 3600) / 60) < 10 ) { Serial.print('0'); } Serial.print(UTCmin); Serial.print(':'); if ( (epoch % 60) < 10 ) { Serial.print('0'); } Serial.println(epoch % 60); // print the second } */ /* // -- begin neropixel test delay(1000); Serial.println("Colors R, G, B, W..."); // set the colors, // if they don't match in order, you need to use NeoGrbFeature feature strip.SetPixelColor(0, RgbColor (128, 0, 0)); strip.SetPixelColor(1, green); strip.SetPixelColor(2, blue); strip.SetPixelColor(3, white); // the following line demonstrates rgbw color support // if the NeoPixels are rgbw types the following line will compile // if the NeoPixels are anything else, the following line will give an error //strip.SetPixelColor(3, RgbwColor(colorSaturation)); strip.Show(); delay(1000); Serial.println("Off ..."); // turn off the pixels strip.SetPixelColor(0, black); strip.SetPixelColor(1, black); strip.SetPixelColor(2, black); strip.SetPixelColor(3, black); strip.Show(); delay(1000); Serial.println("HSL Colors R, G, B, W..."); // set the colors, // if they don't match in order, you may need to use NeoGrbFeature feature strip.SetPixelColor(0, hslRed); strip.SetPixelColor(1, hslGreen); strip.SetPixelColor(2, hslBlue); strip.SetPixelColor(3, hslWhite); strip.Show(); delay(1000); Serial.println("Off again..."); // turn off the pixels strip.SetPixelColor(0, hslBlack); strip.SetPixelColor(1, hslBlack); strip.SetPixelColor(2, hslBlack); strip.SetPixelColor(3, hslBlack); strip.Show(); */ // -- neopixel sunrise test //sunrise(40); //offblack(); /* // -- print IP address Serial.println(WiFi.localIP()); //Serial.println(".."); */ } yield(); }
int EWCDisplay::_stackptr = 0; uint8_t EWCDisplay::_testHours = 0; uint8_t EWCDisplay::_testMinutes = 0; #if FEATURE_WEATHER() int8_t EWCDisplay::_testTemperature = -39; uint8_t EWCDisplay::_testWeather = 0; #endif uint8_t EWCDisplay::_testLED = 0; uint8_t EWCDisplay::_languageMode = RHEIN_RUHR_MODE; boolean EWCDisplay::_autoBrightness = false; NeoPixelBus<NeoRgbFeature, NeoEsp8266BitBang800KbpsMethod> _ledBus(NUM_LEDS, STRIP_DATA_PIN); NeoPixelAnimator _animations(1); RgbColor EWCDisplay::_leds[NUM_LEDS]; RgbColor EWCDisplay::_red = RgbColor(128, 0, 0); RgbColor EWCDisplay::_green = RgbColor(0, 128, 0); RgbColor EWCDisplay::_blue = RgbColor(0, 0, 128); RgbColor EWCDisplay::_white = RgbColor(128); RgbColor EWCDisplay::_black = RgbColor(0); RgbColor EWCDisplay::_defaultColor = _white; typedef void (*FunctPtr)(); FunctPtr EWCDisplay::_currentDisplay; // for the fire from https://github.com/giladaya/arduino-led-matrix/blob/master/fire/fire.ino // these values are substracetd from the generated values to give a shape to the animation uint8_t EWCDisplay::_valueMask[M_HEIGHT][M_WIDTH] = { {32 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 32 , 32 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 32 }, {48 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 48 , 48 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 48 }, {64 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 48 , 48 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 64 }, {96 , 32 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 32 , 64 , 64 , 32 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 32 , 96 },