Upstream/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2024-10-01 04:38:51 +02:00
Code Issues Projects Releases Wiki Activity

Merge branch 'dev' of https://github.com/esphome/esphome into dev

Browse Source
This commit is contained in:
Guillermo Ruffino 2020-07-10 18:55:38 -03:00
commit dd4ea51d1f
34 changed files with 683 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
esphome/components/display/display_buffer.cpp
View File

@ -1,4 +1,5 @@
#include "display_buffer.h"
#include "esphome/core/color.h"
#include "esphome/core/log.h"
#include "esphome/core/application.h"
@ -7,8 +8,8 @@ namespace display {
static const char *TAG = "display";
const Color COLOR_OFF = 0;
const Color COLOR_ON = 1;
const Color COLOR_OFF(0, 0, 0, 0);
const Color COLOR_ON(1, 1, 1, 1);
void DisplayBuffer::init_internal_(uint32_t buffer_length) {
this->buffer_ = new uint8_t[buffer_length];
@ -214,13 +215,13 @@ void DisplayBuffer::image(int x, int y, Color color, Image *image, bool invert)
this->draw_pixel_at(x + img_x, y + img_y, image->get_pixel(img_x, img_y) ? color : COLOR_OFF);
}
}
} else if (image->get_type() == GRAYSCALE4) {
} else if (image->get_type() == GRAYSCALE) {
for (int img_x = 0; img_x < image->get_width(); img_x++) {
for (int img_y = 0; img_y < image->get_height(); img_y++) {
this->draw_pixel_at(x + img_x, y + img_y, image->get_grayscale4_pixel(img_x, img_y));
this->draw_pixel_at(x + img_x, y + img_y, image->get_grayscale_pixel(img_x, img_y));
}
}
} else if (image->get_type() == RGB565) {
} else if (image->get_type() == RGB) {
for (int img_x = 0; img_x < image->get_width(); img_x++) {
for (int img_y = 0; img_y < image->get_height(); img_y++) {
this->draw_pixel_at(x + img_x, y + img_y, image->get_color_pixel(img_x, img_y));
@ -449,22 +450,20 @@ bool Image::get_pixel(int x, int y) const {
const uint32_t pos = x + y * width_8;
return pgm_read_byte(this->data_start_ + (pos / 8u)) & (0x80 >> (pos % 8u));
}
int Image::get_color_pixel(int x, int y) const {
Color Image::get_color_pixel(int x, int y) const {
if (x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
return 0;
const uint32_t pos = (x + y * this->width_) * 2;
int color = (pgm_read_byte(this->data_start_ + pos) << 8) + (pgm_read_byte(this->data_start_ + pos + 1));
return color;
const uint32_t pos = (x + y * this->width_) * 3;
const uint32_t color32 = (pgm_read_byte(this->data_start_ + pos + 2) << 0) |
(pgm_read_byte(this->data_start_ + pos + 1) << 8) |
(pgm_read_byte(this->data_start_ + pos + 0) << 16);
return Color(color32);
}
int Image::get_grayscale4_pixel(int x, int y) const {
Color Image::get_grayscale_pixel(int x, int y) const {
if (x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
return 0;
const uint32_t pos = (x + y * this->width_) / 2;
// 2 = number of pixels per byte, 4 = pixel shift
uint8_t shift = (x % 2) * 4;
int color = (pgm_read_byte(this->data_start_ + pos) >> shift) & 0x0f;
return color;
const uint32_t pos = (x + y * this->width_);
return Color(pgm_read_byte(this->data_start_ + pos) << 24);
}
int Image::get_width() const { return this->width_; }
int Image::get_height() const { return this->height_; }

6
esphome/components/display/display_buffer.h
View File

@ -68,7 +68,7 @@ extern const Color COLOR_OFF;
/// Turn the pixel ON.
extern const Color COLOR_ON;
enum ImageType { BINARY = 0, GRAYSCALE4 = 1, RGB565 = 2 };
enum ImageType { BINARY = 0, GRAYSCALE = 1, RGB = 2 };
enum DisplayRotation {
DISPLAY_ROTATION_0_DEGREES = 0,
@ -384,8 +384,8 @@ class Image {
Image(const uint8_t *data_start, int width, int height);
Image(const uint8_t *data_start, int width, int height, int type);
bool get_pixel(int x, int y) const;
int get_color_pixel(int x, int y) const;
int get_grayscale4_pixel(int x, int y) const;
Color get_color_pixel(int x, int y) const;
Color get_grayscale_pixel(int x, int y) const;
int get_width() const;
int get_height() const;
ImageType get_type() const;

2
esphome/components/ethernet/ethernet_component.cpp
View File

@ -37,7 +37,7 @@ void EthernetComponent::setup() {
}
void EthernetComponent::loop() {
const uint32_t now = millis();
if (!this->connected_ && !this->last_connected_ && now - this->last_connected_ > 15000) {
if (!this->connected_ && !this->last_connected_ && now - this->connect_begin_ > 15000) {
ESP_LOGW(TAG, "Connecting via ethernet failed! Re-connecting...");
this->start_connect_();
return;

32
esphome/components/image/__init__.py
View File

@ -11,7 +11,7 @@ _LOGGER = logging.getLogger(__name__)
DEPENDENCIES = ['display']
MULTI_CONF = True
ImageType = {'binary': 0, 'grayscale4': 1, 'rgb565': 2}
ImageType = {'binary': 0, 'grayscale': 1, 'rgb': 2}
Image_ = display.display_ns.class_('Image')
@ -41,38 +41,34 @@ def to_code(config):
image.thumbnail(config[CONF_RESIZE])
if CONF_TYPE in config:
if config[CONF_TYPE].startswith('GRAYSCALE4'):
if config[CONF_TYPE].startswith('GRAYSCALE'):
width, height = image.size
image = image.convert('L', dither=Image.NONE)
pixels = list(image.getdata())
data = [0 for _ in range(height * width // 2)]
data = [0 for _ in range(height * width)]
pos = 0
for pixnum, pix in enumerate(pixels):
pixshift = (pixnum % 2) * 4
data[pos] |= (pix >> 4) << pixshift
if pixshift != 0:
pos += 1
for pix in pixels:
data[pos] = pix
pos += 1
rhs = [HexInt(x) for x in data]
prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
cg.new_Pvariable(config[CONF_ID], prog_arr, width, height, ImageType['grayscale4'])
elif config[CONF_TYPE].startswith('RGB565'):
cg.new_Pvariable(config[CONF_ID], prog_arr, width, height, ImageType['grayscale'])
elif config[CONF_TYPE].startswith('RGB'):
width, height = image.size
image = image.convert('RGB')
pixels = list(image.getdata())
data = [0 for _ in range(height * width * 2)]
data = [0 for _ in range(height * width * 3)]
pos = 0
for pix in pixels:
r = (pix[0] >> 3) & 0x1F
g = (pix[1] >> 2) & 0x3F
b = (pix[2] >> 3) & 0x1F
p = (r << 11) + (g << 5) + b
data[pos] = (p >> 8) & 0xFF
data[pos] = pix[0]
pos += 1
data[pos] = p & 0xFF
data[pos] = pix[1]
pos += 1
data[pos] = pix[2]
pos += 1
rhs = [HexInt(x) for x in data]
prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
cg.new_Pvariable(config[CONF_ID], prog_arr, width, height, ImageType['rgb565'])
cg.new_Pvariable(config[CONF_ID], prog_arr, width, height, ImageType['rgb'])
else:
image = image.convert('1', dither=Image.NONE)
width, height = image.size

22
esphome/components/light/light_color_values.h
View File

@ -179,22 +179,28 @@ class LightColorValues {
}
/// Convert these light color values to an RGB representation and write them to red, green, blue.
void as_rgb(float *red, float *green, float *blue, float gamma = 0) const {
*red = gamma_correct(this->state_ * this->brightness_ * this->red_, gamma);
*green = gamma_correct(this->state_ * this->brightness_ * this->green_, gamma);
*blue = gamma_correct(this->state_ * this->brightness_ * this->blue_, gamma);
void as_rgb(float *red, float *green, float *blue, float gamma = 0, bool color_interlock = false) const {
float brightness = this->state_ * this->brightness_;
if (color_interlock) {
brightness = brightness * (1.0f - this->white_);
}
*red = gamma_correct(brightness * this->red_, gamma);
*green = gamma_correct(brightness * this->green_, gamma);
*blue = gamma_correct(brightness * this->blue_, gamma);
}
/// Convert these light color values to an RGBW representation and write them to red, green, blue, white.
void as_rgbw(float *red, float *green, float *blue, float *white, float gamma = 0) const {
this->as_rgb(red, green, blue, gamma);
void as_rgbw(float *red, float *green, float *blue, float *white, float gamma = 0,
bool color_interlock = false) const {
this->as_rgb(red, green, blue, gamma, color_interlock);
*white = gamma_correct(this->state_ * this->brightness_ * this->white_, gamma);
}
/// Convert these light color values to an RGBWW representation with the given parameters.
void as_rgbww(float color_temperature_cw, float color_temperature_ww, float *red, float *green, float *blue,
float *cold_white, float *warm_white, float gamma = 0, bool constant_brightness = false) const {
this->as_rgb(red, green, blue, gamma);
float *cold_white, float *warm_white, float gamma = 0, bool constant_brightness = false,
bool color_interlock = false) const {
this->as_rgb(red, green, blue, gamma, color_interlock);
const float color_temp = clamp(this->color_temperature_, color_temperature_cw, color_temperature_ww);
const float ww_fraction = (color_temp - color_temperature_cw) / (color_temperature_ww - color_temperature_cw);
const float cw_fraction = 1.0f - ww_fraction;

56
esphome/components/light/light_state.cpp
View File

@ -400,26 +400,51 @@ LightColorValues LightCall::validate_() {
this->green_ = optional<float>(1.0f);
this->blue_ = optional<float>(1.0f);
}
// make white values binary aka 0.0f or 1.0f...this allows brightness to do its job
if (traits.get_supports_color_interlock()) {
if (*this->white_ > 0.0f) {
this->white_ = optional<float>(1.0f);
} else {
this->white_ = optional<float>(0.0f);
}
}
}
// White to 0% if (exclusively) setting any RGB value
// White to 0% if (exclusively) setting any RGB value that isn't 255,255,255
else if (this->red_.has_value() || this->green_.has_value() || this->blue_.has_value()) {
if (!this->white_.has_value()) {
if (*this->red_ == 1.0f && *this->green_ == 1.0f && *this->blue_ == 1.0f && traits.get_supports_rgb_white_value() &&
traits.get_supports_color_interlock()) {
this->white_ = optional<float>(1.0f);
} else if (!this->white_.has_value() || !traits.get_supports_rgb_white_value()) {
this->white_ = optional<float>(0.0f);
}
}
// if changing Kelvin alone, change to white light
else if (this->color_temperature_.has_value()) {
if (!this->red_.has_value() && !this->green_.has_value() && !this->blue_.has_value()) {
this->red_ = optional<float>(1.0f);
this->green_ = optional<float>(1.0f);
this->blue_ = optional<float>(1.0f);
if (!traits.get_supports_color_interlock()) {
if (!this->red_.has_value() && !this->green_.has_value() && !this->blue_.has_value()) {
this->red_ = optional<float>(1.0f);
this->green_ = optional<float>(1.0f);
this->blue_ = optional<float>(1.0f);
}
}
// if setting Kelvin from color (i.e. switching to white light), set White to 100%
auto cv = this->parent_->remote_values;
bool was_color = cv.get_red() != 1.0f || cv.get_blue() != 1.0f || cv.get_green() != 1.0f;
bool now_white = *this->red_ == 1.0f && *this->blue_ == 1.0f && *this->green_ == 1.0f;
if (!this->white_.has_value() && was_color && now_white) {
this->white_ = optional<float>(1.0f);
if (traits.get_supports_color_interlock()) {
if (cv.get_white() < 1.0f) {
this->white_ = optional<float>(1.0f);
}
if (was_color && !this->red_.has_value() && !this->green_.has_value() && !this->blue_.has_value()) {
this->red_ = optional<float>(1.0f);
this->green_ = optional<float>(1.0f);
this->blue_ = optional<float>(1.0f);
}
} else {
if (!this->white_.has_value() && was_color && now_white) {
this->white_ = optional<float>(1.0f);
}
}
}
@ -704,17 +729,20 @@ void LightState::current_values_as_binary(bool *binary) { this->current_values.a
void LightState::current_values_as_brightness(float *brightness) {
this->current_values.as_brightness(brightness, this->gamma_correct_);
}
void LightState::current_values_as_rgb(float *red, float *green, float *blue) {
this->current_values.as_rgb(red, green, blue, this->gamma_correct_);
void LightState::current_values_as_rgb(float *red, float *green, float *blue, bool color_interlock) {
auto traits = this->get_traits();
this->current_values.as_rgb(red, green, blue, this->gamma_correct_, traits.get_supports_color_interlock());
}
void LightState::current_values_as_rgbw(float *red, float *green, float *blue, float *white) {
this->current_values.as_rgbw(red, green, blue, white, this->gamma_correct_);
void LightState::current_values_as_rgbw(float *red, float *green, float *blue, float *white, bool color_interlock) {
auto traits = this->get_traits();
this->current_values.as_rgbw(red, green, blue, white, this->gamma_correct_, traits.get_supports_color_interlock());
}
void LightState::current_values_as_rgbww(float *red, float *green, float *blue, float *cold_white, float *warm_white,
bool constant_brightness) {
bool constant_brightness, bool color_interlock) {
auto traits = this->get_traits();
this->current_values.as_rgbww(traits.get_min_mireds(), traits.get_max_mireds(), red, green, blue, cold_white,
warm_white, this->gamma_correct_, constant_brightness);
warm_white, this->gamma_correct_, constant_brightness,
traits.get_supports_color_interlock());
}
void LightState::current_values_as_cwww(float *cold_white, float *warm_white, bool constant_brightness) {
auto traits = this->get_traits();

6
esphome/components/light/light_state.h
View File

@ -266,12 +266,12 @@ class LightState : public Nameable, public Component {
void current_values_as_brightness(float *brightness);
void current_values_as_rgb(float *red, float *green, float *blue);
void current_values_as_rgb(float *red, float *green, float *blue, bool color_interlock = false);
void current_values_as_rgbw(float *red, float *green, float *blue, float *white);
void current_values_as_rgbw(float *red, float *green, float *blue, float *white, bool color_interlock = false);
void current_values_as_rgbww(float *red, float *green, float *blue, float *cold_white, float *warm_white,
bool constant_brightness = false);
bool constant_brightness = false, bool color_interlock = false);
void current_values_as_cwww(float *cold_white, float *warm_white, bool constant_brightness = false);

5
esphome/components/light/light_traits.h
View File

@ -20,6 +20,10 @@ class LightTraits {
void set_supports_color_temperature(bool supports_color_temperature) {
this->supports_color_temperature_ = supports_color_temperature;
}
bool get_supports_color_interlock() const { return this->supports_color_interlock_; }
void set_supports_color_interlock(bool supports_color_interlock) {
this->supports_color_interlock_ = supports_color_interlock;
}
float get_min_mireds() const { return this->min_mireds_; }
void set_min_mireds(float min_mireds) { this->min_mireds_ = min_mireds; }
float get_max_mireds() const { return this->max_mireds_; }
@ -32,6 +36,7 @@ class LightTraits {
bool supports_color_temperature_{false};
float min_mireds_{0};
float max_mireds_{0};
bool supports_color_interlock_{false};
};
} // namespace light

13
esphome/components/pid/climate.py
View File

@ -7,6 +7,7 @@ from esphome.const import CONF_ID, CONF_SENSOR
pid_ns = cg.esphome_ns.namespace('pid')
PIDClimate = pid_ns.class_('PIDClimate', climate.Climate, cg.Component)
PIDAutotuneAction = pid_ns.class_('PIDAutotuneAction', automation.Action)
PIDResetIntegralTermAction = pid_ns.class_('PIDResetIntegralTermAction', automation.Action)
CONF_DEFAULT_TARGET_TEMPERATURE = 'default_target_temperature'
@ -64,6 +65,18 @@ def to_code(config):
cg.add(var.set_default_target_temperature(config[CONF_DEFAULT_TARGET_TEMPERATURE]))
@automation.register_action(
'climate.pid.reset_integral_term',
PIDResetIntegralTermAction,
automation.maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(PIDClimate),
})
)
def pid_reset_integral_term(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action('climate.pid.autotune', PIDAutotuneAction, automation.maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(PIDClimate),
cv.Optional(CONF_NOISEBAND, default=0.25): cv.float_,

2
esphome/components/pid/pid_climate.cpp
View File

@ -148,5 +148,7 @@ void PIDClimate::start_autotune(std::unique_ptr<PIDAutotuner> &&autotune) {
});
}
void PIDClimate::reset_integral_term() { this->controller_.reset_accumulated_integral(); }
} // namespace pid
} // namespace esphome

11
esphome/components/pid/pid_climate.h
View File

@ -39,6 +39,7 @@ class PIDClimate : public climate::Climate, public Component {
default_target_temperature_ = default_target_temperature;
}
void start_autotune(std::unique_ptr<PIDAutotuner> &&autotune);
void reset_integral_term();
protected:
/// Override control to change settings of the climate device.
@ -90,5 +91,15 @@ template<typename... Ts> class PIDAutotuneAction : public Action<Ts...> {
PIDClimate *parent_;
};
template<typename... Ts> class PIDResetIntegralTermAction : public Action<Ts...> {
public:
PIDResetIntegralTermAction(PIDClimate *parent) : parent_(parent) {}
void play(Ts... x) { this->parent_->reset_integral_term(); }
protected:
PIDClimate *parent_;
};
} // namespace pid
} // namespace esphome

2
esphome/components/pid/pid_controller.h
View File

@ -40,6 +40,8 @@ struct PIDController {
return proportional_term + integral_term + derivative_term;
}
void reset_accumulated_integral() { accumulated_integral_ = 0; }
/// Proportional gain K_p.
float kp = 0;
/// Integral gain K_i.

3
esphome/components/rgb/rgb_light_output.h
View File

@ -12,6 +12,7 @@ class RGBLightOutput : public light::LightOutput {
void set_red(output::FloatOutput *red) { red_ = red; }
void set_green(output::FloatOutput *green) { green_ = green; }
void set_blue(output::FloatOutput *blue) { blue_ = blue; }
light::LightTraits get_traits() override {
auto traits = light::LightTraits();
traits.set_supports_brightness(true);
@ -20,7 +21,7 @@ class RGBLightOutput : public light::LightOutput {
}
void write_state(light::LightState *state) override {
float red, green, blue;
state->current_values_as_rgb(&red, &green, &blue);
state->current_values_as_rgb(&red, &green, &blue, false);
this->red_->set_level(red);
this->green_->set_level(green);
this->blue_->set_level(blue);

3
esphome/components/rgbw/light.py
View File

@ -5,6 +5,7 @@ from esphome.const import CONF_BLUE, CONF_GREEN, CONF_RED, CONF_OUTPUT_ID, CONF_
rgbw_ns = cg.esphome_ns.namespace('rgbw')
RGBWLightOutput = rgbw_ns.class_('RGBWLightOutput', light.LightOutput)
CONF_COLOR_INTERLOCK = 'color_interlock'
CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(RGBWLightOutput),
@ -12,6 +13,7 @@ CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend({
cv.Required(CONF_GREEN): cv.use_id(output.FloatOutput),
cv.Required(CONF_BLUE): cv.use_id(output.FloatOutput),
cv.Required(CONF_WHITE): cv.use_id(output.FloatOutput),
cv.Optional(CONF_COLOR_INTERLOCK, default=False): cv.boolean,
})
@ -27,3 +29,4 @@ def to_code(config):
cg.add(var.set_blue(blue))
white = yield cg.get_variable(config[CONF_WHITE])
cg.add(var.set_white(white))
cg.add(var.set_color_interlock(config[CONF_COLOR_INTERLOCK]))

5
esphome/components/rgbw/rgbw_light_output.h
View File

@ -13,16 +13,18 @@ class RGBWLightOutput : public light::LightOutput {
void set_green(output::FloatOutput *green) { green_ = green; }
void set_blue(output::FloatOutput *blue) { blue_ = blue; }
void set_white(output::FloatOutput *white) { white_ = white; }
void set_color_interlock(bool color_interlock) { color_interlock_ = color_interlock; }
light::LightTraits get_traits() override {
auto traits = light::LightTraits();
traits.set_supports_brightness(true);
traits.set_supports_color_interlock(this->color_interlock_);
traits.set_supports_rgb(true);
traits.set_supports_rgb_white_value(true);
return traits;
}
void write_state(light::LightState *state) override {
float red, green, blue, white;
state->current_values_as_rgbw(&red, &green, &blue, &white);
state->current_values_as_rgbw(&red, &green, &blue, &white, this->color_interlock_);
this->red_->set_level(red);
this->green_->set_level(green);
this->blue_->set_level(blue);
@ -34,6 +36,7 @@ class RGBWLightOutput : public light::LightOutput {
output::FloatOutput *green_;
output::FloatOutput *blue_;
output::FloatOutput *white_;
bool color_interlock_{false};
};
} // namespace rgbw

3
esphome/components/rgbww/light.py
View File

@ -9,6 +9,7 @@ rgbww_ns = cg.esphome_ns.namespace('rgbww')
RGBWWLightOutput = rgbww_ns.class_('RGBWWLightOutput', light.LightOutput)
CONF_CONSTANT_BRIGHTNESS = 'constant_brightness'
CONF_COLOR_INTERLOCK = 'color_interlock'
CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(RGBWWLightOutput),
@ -20,6 +21,7 @@ CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend({
cv.Required(CONF_COLD_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
cv.Required(CONF_WARM_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
cv.Optional(CONF_CONSTANT_BRIGHTNESS, default=False): cv.boolean,
cv.Optional(CONF_COLOR_INTERLOCK, default=False): cv.boolean,
})
@ -42,3 +44,4 @@ def to_code(config):
cg.add(var.set_warm_white(wwhite))
cg.add(var.set_warm_white_temperature(config[CONF_WARM_WHITE_COLOR_TEMPERATURE]))
cg.add(var.set_constant_brightness(config[CONF_CONSTANT_BRIGHTNESS]))
cg.add(var.set_color_interlock(config[CONF_COLOR_INTERLOCK]))

6
esphome/components/rgbww/rgbww_light_output.h
View File

@ -17,19 +17,22 @@ class RGBWWLightOutput : public light::LightOutput {
void set_cold_white_temperature(float cold_white_temperature) { cold_white_temperature_ = cold_white_temperature; }
void set_warm_white_temperature(float warm_white_temperature) { warm_white_temperature_ = warm_white_temperature; }
void set_constant_brightness(bool constant_brightness) { constant_brightness_ = constant_brightness; }
void set_color_interlock(bool color_interlock) { color_interlock_ = color_interlock; }
light::LightTraits get_traits() override {
auto traits = light::LightTraits();
traits.set_supports_brightness(true);
traits.set_supports_rgb(true);
traits.set_supports_rgb_white_value(true);
traits.set_supports_color_temperature(true);
traits.set_supports_color_interlock(this->color_interlock_);
traits.set_min_mireds(this->cold_white_temperature_);
traits.set_max_mireds(this->warm_white_temperature_);
return traits;
}
void write_state(light::LightState *state) override {
float red, green, blue, cwhite, wwhite;
state->current_values_as_rgbww(&red, &green, &blue, &cwhite, &wwhite, this->constant_brightness_);
state->current_values_as_rgbww(&red, &green, &blue, &cwhite, &wwhite, this->constant_brightness_,
this->color_interlock_);
this->red_->set_level(red);
this->green_->set_level(green);
this->blue_->set_level(blue);
@ -46,6 +49,7 @@ class RGBWWLightOutput : public light::LightOutput {
float cold_white_temperature_;
float warm_white_temperature_;
bool constant_brightness_;
bool color_interlock_{false};
};
} // namespace rgbww

8
esphome/components/ssd1325_base/__init__.py
View File

@ -2,7 +2,8 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import display
from esphome.const import CONF_EXTERNAL_VCC, CONF_LAMBDA, CONF_MODEL, CONF_RESET_PIN
from esphome.const import CONF_BRIGHTNESS, CONF_EXTERNAL_VCC, CONF_LAMBDA, CONF_MODEL, \
CONF_RESET_PIN
from esphome.core import coroutine
ssd1325_base_ns = cg.esphome_ns.namespace('ssd1325_base')
@ -22,12 +23,13 @@ SSD1325_MODEL = cv.enum(MODELS, upper=True, space="_")
SSD1325_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend({
cv.Required(CONF_MODEL): SSD1325_MODEL,
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
cv.Optional(CONF_EXTERNAL_VCC): cv.boolean,
}).extend(cv.polling_component_schema('1s'))
@coroutine
def setup_ssd1036(var, config):
def setup_ssd1325(var, config):
yield cg.register_component(var, config)
yield display.register_display(var, config)
@ -35,6 +37,8 @@ def setup_ssd1036(var, config):
if CONF_RESET_PIN in config:
reset = yield cg.gpio_pin_expression(config[CONF_RESET_PIN])
cg.add(var.set_reset_pin(reset))
if CONF_BRIGHTNESS in config:
cg.add(var.init_brightness(config[CONF_BRIGHTNESS]))
if CONF_EXTERNAL_VCC in config:
cg.add(var.set_external_vcc(config[CONF_EXTERNAL_VCC]))
if CONF_LAMBDA in config:

142
esphome/components/ssd1325_base/ssd1325_base.cpp
View File

@ -8,7 +8,11 @@ namespace ssd1325_base {
static const char *TAG = "ssd1325";
static const uint8_t BLACK = 0;
static const uint8_t WHITE = 1;
static const uint8_t WHITE = 15;
static const uint8_t SSD1325_MAX_CONTRAST = 127;
static const uint8_t SSD1325_COLORMASK = 0x0f;
static const uint8_t SSD1325_COLORSHIFT = 4;
static const uint8_t SSD1325_PIXELSPERBYTE = 2;
static const uint8_t SSD1325_SETCOLADDR = 0x15;
static const uint8_t SSD1325_SETROWADDR = 0x75;
@ -33,6 +37,7 @@ static const uint8_t SSD1325_SETROWPERIOD = 0xB2;
static const uint8_t SSD1325_SETCLOCK = 0xB3;
static const uint8_t SSD1325_SETPRECHARGECOMP = 0xB4;
static const uint8_t SSD1325_SETGRAYTABLE = 0xB8;
static const uint8_t SSD1325_SETDEFAULTGRAYTABLE = 0xB9;
static const uint8_t SSD1325_SETPRECHARGEVOLTAGE = 0xBC;
static const uint8_t SSD1325_SETVCOMLEVEL = 0xBE;
static const uint8_t SSD1325_SETVSL = 0xBF;
@ -44,40 +49,57 @@ static const uint8_t SSD1325_COPY = 0x25;
void SSD1325::setup() {
this->init_internal_(this->get_buffer_length_());
this->command(SSD1325_DISPLAYOFF); /* display off */
this->command(SSD1325_SETCLOCK); /* set osc division */
this->command(0xF1); /* 145 */
this->command(SSD1325_SETMULTIPLEX); /* multiplex ratio */
this->command(SSD1325_DISPLAYOFF); // display off
this->command(SSD1325_SETCLOCK); // set osc division
this->command(0xF1); // 145
this->command(SSD1325_SETMULTIPLEX); // multiplex ratio
if (this->model_ == SSD1327_MODEL_128_128)
this->command(0x7f); // duty = height - 1
else
this->command(0x3f); // duty = 1/64
this->command(SSD1325_SETOFFSET); /* set display offset --- */
this->command(0x3f); // duty = 1/64
this->command(SSD1325_SETOFFSET); // set display offset
if (this->model_ == SSD1327_MODEL_128_128)
this->command(0x00); // 0
else
this->command(0x4C); // 76
this->command(SSD1325_SETSTARTLINE); /*set start line */
this->command(0x00); /* ------ */
this->command(SSD1325_MASTERCONFIG); /*Set Master Config DC/DC Converter*/
this->command(0x4C); // 76
this->command(SSD1325_SETSTARTLINE); // set start line
this->command(0x00); // ...
this->command(SSD1325_MASTERCONFIG); // Set Master Config DC/DC Converter
this->command(0x02);
this->command(SSD1325_SETREMAP); /* set segment remap------ */
this->command(SSD1325_SETREMAP); // set segment remapping
if (this->model_ == SSD1327_MODEL_128_128)
this->command(0x55); // 0x56 is flipped horizontally: enable column swap, disable nibble remap
this->command(0x53); // COM bottom-up, split odd/even, enable column and nibble remapping
else
this->command(0x56);
this->command(SSD1325_SETCURRENT + 0x2); /* Set Full Current Range */
this->command(0x50); // COM bottom-up, split odd/even
this->command(SSD1325_SETCURRENT + 0x2); // Set Full Current Range
this->command(SSD1325_SETGRAYTABLE);
this->command(0x01);
this->command(0x11);
this->command(0x22);
this->command(0x32);
this->command(0x43);
this->command(0x54);
this->command(0x65);
this->command(0x76);
this->command(SSD1325_SETCONTRAST); /* set contrast current */
this->command(0x7F); // max!
// gamma ~2.2
if (this->model_ == SSD1327_MODEL_128_128) {
this->command(0);
this->command(1);
this->command(2);
this->command(3);
this->command(6);
this->command(8);
this->command(12);
this->command(16);
this->command(20);
this->command(26);
this->command(32);
this->command(39);
this->command(46);
this->command(54);
this->command(63);
} else {
this->command(0x01);
this->command(0x11);
this->command(0x22);
this->command(0x32);
this->command(0x43);
this->command(0x54);
this->command(0x65);
this->command(0x76);
}
this->command(SSD1325_SETROWPERIOD);
this->command(0x51);
this->command(SSD1325_SETPHASELEN);
@ -87,22 +109,25 @@ void SSD1325::setup() {
this->command(SSD1325_SETPRECHARGECOMPENABLE);
this->command(0x28);
this->command(SSD1325_SETVCOMLEVEL); // Set High Voltage Level of COM Pin
this->command(0x1C); //?
this->command(SSD1325_SETVSL); // set Low Voltage Level of SEG Pin
this->command(0x1C);
this->command(SSD1325_SETVSL); // set Low Voltage Level of SEG Pin
this->command(0x0D | 0x02);
this->command(SSD1325_NORMALDISPLAY); /* set display mode */
this->command(SSD1325_DISPLAYON); /* display ON */
this->command(SSD1325_NORMALDISPLAY); // set display mode
set_brightness(this->brightness_);
this->fill(BLACK); // clear display - ensures we do not see garbage at power-on
this->display(); // ...write buffer, which actually clears the display's memory
this->turn_on(); // display ON
}
void SSD1325::display() {
this->command(SSD1325_SETCOLADDR); /* set column address */
this->command(0x00); /* set column start address */
this->command(0x3F); /* set column end address */
this->command(SSD1325_SETROWADDR); /* set row address */
this->command(0x00); /* set row start address */
this->command(SSD1325_SETCOLADDR); // set column address
this->command(0x00); // set column start address
this->command(0x3F); // set column end address
this->command(SSD1325_SETROWADDR); // set row address
this->command(0x00); // set row start address
if (this->model_ == SSD1327_MODEL_128_128)
this->command(0x7F); // 127 is last row
this->command(127); // set last row
else
this->command(0x3F); // 63 is last row
this->command(63); // set last row
this->write_display_data();
}
@ -110,6 +135,27 @@ void SSD1325::update() {
this->do_update_();
this->display();
}
void SSD1325::set_brightness(float brightness) {
// validation
if (brightness > 1)
this->brightness_ = 1.0;
else if (brightness < 0)
this->brightness_ = 0;
else
this->brightness_ = brightness;
// now write the new brightness level to the display
this->command(SSD1325_SETCONTRAST);
this->command(int(SSD1325_MAX_CONTRAST * (this->brightness_)));
}
bool SSD1325::is_on() { return this->is_on_; }
void SSD1325::turn_on() {
this->command(SSD1325_DISPLAYON);
this->is_on_ = true;
}
void SSD1325::turn_off() {
this->command(SSD1325_DISPLAYOFF);
this->is_on_ = false;
}
int SSD1325::get_height_internal() {
switch (this->model_) {
case SSD1325_MODEL_128_32:
@ -141,23 +187,25 @@ int SSD1325::get_width_internal() {
}
}
size_t SSD1325::get_buffer_length_() {
return size_t(this->get_width_internal()) * size_t(this->get_height_internal()) / 8u;
return size_t(this->get_width_internal()) * size_t(this->get_height_internal()) / SSD1325_PIXELSPERBYTE;
}
void HOT SSD1325::draw_absolute_pixel_internal(int x, int y, Color color) {
if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0)
return;
uint16_t pos = x + (y / 8) * this->get_width_internal();
uint8_t subpos = y % 8;
if (color.is_on()) {
this->buffer_[pos] |= (1 << subpos);
} else {
this->buffer_[pos] &= ~(1 << subpos);
}
uint32_t color4 = color.to_grayscale4();
// where should the bits go in the big buffer array? math...
uint16_t pos = (x / SSD1325_PIXELSPERBYTE) + (y * this->get_width_internal() / SSD1325_PIXELSPERBYTE);
uint8_t shift = (x % SSD1325_PIXELSPERBYTE) * SSD1325_COLORSHIFT;
// ensure 'color4' is valid (only 4 bits aka 1 nibble) and shift the bits left when necessary
color4 = (color4 & SSD1325_COLORMASK) << shift;
// first mask off the nibble we must change...
this->buffer_[pos] &= (~SSD1325_COLORMASK >> shift);
// ...then lay the new nibble back on top. done!
this->buffer_[pos] |= color4;
}
void SSD1325::fill(Color color) {
uint8_t fill = color.is_on() ? 0xFF : 0x00;
const uint32_t color4 = color.to_grayscale4();
uint8_t fill = (color4 & SSD1325_COLORMASK) | ((color4 & SSD1325_COLORMASK) << SSD1325_COLORSHIFT);
for (uint32_t i = 0; i < this->get_buffer_length_(); i++)
this->buffer_[i] = fill;
}

7
esphome/components/ssd1325_base/ssd1325_base.h
View File

@ -26,6 +26,11 @@ class SSD1325 : public PollingComponent, public display::DisplayBuffer {
void set_model(SSD1325Model model) { this->model_ = model; }
void set_reset_pin(GPIOPin *reset_pin) { this->reset_pin_ = reset_pin; }
void set_external_vcc(bool external_vcc) { this->external_vcc_ = external_vcc; }
void init_brightness(float brightness) { this->brightness_ = brightness; }
void set_brightness(float brightness);
bool is_on();
void turn_on();
void turn_off();
float get_setup_priority() const override { return setup_priority::PROCESSOR; }
void fill(Color color) override;
@ -45,6 +50,8 @@ class SSD1325 : public PollingComponent, public display::DisplayBuffer {
SSD1325Model model_{SSD1325_MODEL_128_64};
GPIOPin *reset_pin_{nullptr};
bool external_vcc_{false};
bool is_on_{false};
float brightness_{1.0};
};
} // namespace ssd1325_base

2
esphome/components/ssd1325_spi/display.py
View File

@ -19,7 +19,7 @@ CONFIG_SCHEMA = cv.All(ssd1325_base.SSD1325_SCHEMA.extend({
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield ssd1325_base.setup_ssd1036(var, config)
yield ssd1325_base.setup_ssd1325(var, config)
yield spi.register_spi_device(var, config)
dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN])

19
esphome/components/ssd1325_spi/ssd1325_spi.cpp
View File

@ -21,9 +21,11 @@ void SPISSD1325::setup() {
void SPISSD1325::dump_config() {
LOG_DISPLAY("", "SPI SSD1325", this);
ESP_LOGCONFIG(TAG, " Model: %s", this->model_str_());
LOG_PIN(" CS Pin: ", this->cs_);
if (this->cs_)
LOG_PIN(" CS Pin: ", this->cs_);
LOG_PIN(" DC Pin: ", this->dc_pin_);
LOG_PIN(" Reset Pin: ", this->reset_pin_);
ESP_LOGCONFIG(TAG, " Initial Brightness: %.2f", this->brightness_);
ESP_LOGCONFIG(TAG, " External VCC: %s", YESNO(this->external_vcc_));
LOG_UPDATE_INTERVAL(this);
}
@ -48,20 +50,7 @@ void HOT SPISSD1325::write_display_data() {
this->cs_->digital_write(false);
delay(1);
this->enable();
for (uint16_t x = 0; x < this->get_width_internal(); x += 2) {
for (uint16_t y = 0; y < this->get_height_internal(); y += 8) { // we write 8 pixels at once
uint8_t left8 = this->buffer_[y * 16 + x];
uint8_t right8 = this->buffer_[y * 16 + x + 1];
for (uint8_t p = 0; p < 8; p++) {
uint8_t d = 0;
if (left8 & (1 << p))
d |= 0xF0;
if (right8 & (1 << p))
d |= 0x0F;
this->write_byte(d);
}
}
}
this->write_array(this->buffer_, this->get_buffer_length_());
if (this->cs_)
this->cs_->digital_write(true);
this->disable();

40
esphome/components/ssd1351_base/__init__.py Normal file
View File

@ -0,0 +1,40 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import display
from esphome.const import CONF_BRIGHTNESS, CONF_LAMBDA, CONF_MODEL, CONF_RESET_PIN
from esphome.core import coroutine
ssd1351_base_ns = cg.esphome_ns.namespace('ssd1351_base')
SSD1351 = ssd1351_base_ns.class_('SSD1351', cg.PollingComponent, display.DisplayBuffer)
SSD1351Model = ssd1351_base_ns.enum('SSD1351Model')
MODELS = {
'SSD1351_128X96': SSD1351Model.SSD1351_MODEL_128_96,
'SSD1351_128X128': SSD1351Model.SSD1351_MODEL_128_128,
}
SSD1351_MODEL = cv.enum(MODELS, upper=True, space="_")
SSD1351_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend({
cv.Required(CONF_MODEL): SSD1351_MODEL,
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
}).extend(cv.polling_component_schema('1s'))
@coroutine
def setup_ssd1351(var, config):
yield cg.register_component(var, config)
yield display.register_display(var, config)
cg.add(var.set_model(config[CONF_MODEL]))
if CONF_RESET_PIN in config:
reset = yield cg.gpio_pin_expression(config[CONF_RESET_PIN])
cg.add(var.set_reset_pin(reset))
if CONF_BRIGHTNESS in config:
cg.add(var.init_brightness(config[CONF_BRIGHTNESS]))
if CONF_LAMBDA in config:
lambda_ = yield cg.process_lambda(
config[CONF_LAMBDA], [(display.DisplayBufferRef, 'it')], return_type=cg.void)
cg.add(var.set_writer(lambda_))

193
esphome/components/ssd1351_base/ssd1351_base.cpp Normal file
View File

@ -0,0 +1,193 @@
#include "ssd1351_base.h"
#include "esphome/core/log.h"
#include "esphome/core/helpers.h"
namespace esphome {
namespace ssd1351_base {
static const char *TAG = "ssd1351";
static const uint16_t BLACK = 0;
static const uint16_t WHITE = 0xffff;
static const uint16_t SSD1351_COLORMASK = 0xffff;
static const uint8_t SSD1351_MAX_CONTRAST = 15;
static const uint8_t SSD1351_BYTESPERPIXEL = 2;
// SSD1351 commands
static const uint8_t SSD1351_SETCOLUMN = 0x15;
static const uint8_t SSD1351_SETROW = 0x75;
static const uint8_t SSD1351_SETREMAP = 0xA0;
static const uint8_t SSD1351_STARTLINE = 0xA1;
static const uint8_t SSD1351_DISPLAYOFFSET = 0xA2;
static const uint8_t SSD1351_DISPLAYOFF = 0xAE;
static const uint8_t SSD1351_DISPLAYON = 0xAF;
static const uint8_t SSD1351_PRECHARGE = 0xB1;
static const uint8_t SSD1351_CLOCKDIV = 0xB3;
static const uint8_t SSD1351_PRECHARGELEVEL = 0xBB;
static const uint8_t SSD1351_VCOMH = 0xBE;
// display controls
static const uint8_t SSD1351_DISPLAYALLOFF = 0xA4;
static const uint8_t SSD1351_DISPLAYALLON = 0xA5;
static const uint8_t SSD1351_NORMALDISPLAY = 0xA6;
static const uint8_t SSD1351_INVERTDISPLAY = 0xA7;
// contrast controls
static const uint8_t SSD1351_CONTRASTABC = 0xC1;
static const uint8_t SSD1351_CONTRASTMASTER = 0xC7;
// memory functions
static const uint8_t SSD1351_WRITERAM = 0x5C;
static const uint8_t SSD1351_READRAM = 0x5D;
// other functions
static const uint8_t SSD1351_FUNCTIONSELECT = 0xAB;
static const uint8_t SSD1351_DISPLAYENHANCE = 0xB2;
static const uint8_t SSD1351_SETVSL = 0xB4;
static const uint8_t SSD1351_SETGPIO = 0xB5;
static const uint8_t SSD1351_PRECHARGE2 = 0xB6;
static const uint8_t SSD1351_SETGRAY = 0xB8;
static const uint8_t SSD1351_USELUT = 0xB9;
static const uint8_t SSD1351_MUXRATIO = 0xCA;
static const uint8_t SSD1351_COMMANDLOCK = 0xFD;
static const uint8_t SSD1351_HORIZSCROLL = 0x96;
static const uint8_t SSD1351_STOPSCROLL = 0x9E;
static const uint8_t SSD1351_STARTSCROLL = 0x9F;
void SSD1351::setup() {
this->init_internal_(this->get_buffer_length_());
this->command(SSD1351_COMMANDLOCK);
this->data(0x12);
this->command(SSD1351_COMMANDLOCK);
this->data(0xB1);
this->command(SSD1351_DISPLAYOFF);
this->command(SSD1351_CLOCKDIV);
this->data(0xF1); // 7:4 = Oscillator Freq, 3:0 = CLK Div Ratio (A[3:0]+1 = 1..16)
this->command(SSD1351_MUXRATIO);
this->data(127);
this->command(SSD1351_DISPLAYOFFSET);
this->data(0x00);
this->command(SSD1351_SETGPIO);
this->data(0x00);
this->command(SSD1351_FUNCTIONSELECT);
this->data(0x01); // internal (diode drop)
this->command(SSD1351_PRECHARGE);
this->data(0x32);
this->command(SSD1351_VCOMH);
this->data(0x05);
this->command(SSD1351_NORMALDISPLAY);
this->command(SSD1351_SETVSL);
this->data(0xA0);
this->data(0xB5);
this->data(0x55);
this->command(SSD1351_PRECHARGE2);
this->data(0x01);
this->command(SSD1351_SETREMAP);
this->data(0x34);
this->command(SSD1351_STARTLINE);
this->data(0x00);
this->command(SSD1351_CONTRASTABC);
this->data(0xC8);
this->data(0x80);
this->data(0xC8);
set_brightness(this->brightness_);
this->fill(BLACK); // clear display - ensures we do not see garbage at power-on
this->display(); // ...write buffer, which actually clears the display's memory
this->turn_on(); // display ON
}
void SSD1351::display() {
this->command(SSD1351_SETCOLUMN); // set column address
this->data(0x00); // set column start address
this->data(0x7F); // set column end address
this->command(SSD1351_SETROW); // set row address
this->data(0x00); // set row start address
this->data(0x7F); // set last row
this->command(SSD1351_WRITERAM);
this->write_display_data();
}
void SSD1351::update() {
this->do_update_();
this->display();
}
void SSD1351::set_brightness(float brightness) {
// validation
if (brightness > 1)
this->brightness_ = 1.0;
else if (brightness < 0)
this->brightness_ = 0;
else
this->brightness_ = brightness;
// now write the new brightness level to the display
this->command(SSD1351_CONTRASTMASTER);
this->data(int(SSD1351_MAX_CONTRAST * (this->brightness_)));
}
bool SSD1351::is_on() { return this->is_on_; }
void SSD1351::turn_on() {
this->command(SSD1351_DISPLAYON);
this->is_on_ = true;
}
void SSD1351::turn_off() {
this->command(SSD1351_DISPLAYOFF);
this->is_on_ = false;
}
int SSD1351::get_height_internal() {
switch (this->model_) {
case SSD1351_MODEL_128_96:
return 96;
case SSD1351_MODEL_128_128:
return 128;
default:
return 0;
}
}
int SSD1351::get_width_internal() {
switch (this->model_) {
case SSD1351_MODEL_128_96:
case SSD1351_MODEL_128_128:
return 128;
default:
return 0;
}
}
size_t SSD1351::get_buffer_length_() {
return size_t(this->get_width_internal()) * size_t(this->get_height_internal()) * size_t(SSD1351_BYTESPERPIXEL);
}
void HOT SSD1351::draw_absolute_pixel_internal(int x, int y, Color color) {
if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0)
return;
const uint32_t color565 = color.to_rgb_565();
// where should the bits go in the big buffer array? math...
uint16_t pos = (x + y * this->get_width_internal()) * SSD1351_BYTESPERPIXEL;
this->buffer_[pos++] = (color565 >> 8) & 0xff;
this->buffer_[pos] = color565 & 0xff;
}
void SSD1351::fill(Color color) {
const uint32_t color565 = color.to_rgb_565();
for (uint32_t i = 0; i < this->get_buffer_length_(); i++)
if (i & 1) {
this->buffer_[i] = color565 & 0xff;
} else {
this->buffer_[i] = (color565 >> 8) & 0xff;
}
}
void SSD1351::init_reset_() {
if (this->reset_pin_ != nullptr) {
this->reset_pin_->setup();
this->reset_pin_->digital_write(true);
delay(1);
// Trigger Reset
this->reset_pin_->digital_write(false);
delay(10);
// Wake up
this->reset_pin_->digital_write(true);
}
}
const char *SSD1351::model_str_() {
switch (this->model_) {
case SSD1351_MODEL_128_96:
return "SSD1351 128x96";
case SSD1351_MODEL_128_128:
return "SSD1351 128x128";
default:
return "Unknown";
}
}
} // namespace ssd1351_base
} // namespace esphome

54
esphome/components/ssd1351_base/ssd1351_base.h Normal file
View File

@ -0,0 +1,54 @@
#pragma once
#include "esphome/core/component.h"
#include "esphome/core/esphal.h"
#include "esphome/components/display/display_buffer.h"
namespace esphome {
namespace ssd1351_base {
enum SSD1351Model {
SSD1351_MODEL_128_96 = 0,
SSD1351_MODEL_128_128,
};
class SSD1351 : public PollingComponent, public display::DisplayBuffer {
public:
void setup() override;
void display();
void update() override;
void set_model(SSD1351Model model) { this->model_ = model; }
void set_reset_pin(GPIOPin *reset_pin) { this->reset_pin_ = reset_pin; }
void init_brightness(float brightness) { this->brightness_ = brightness; }
void set_brightness(float brightness);
bool is_on();
void turn_on();
void turn_off();
float get_setup_priority() const override { return setup_priority::PROCESSOR; }
void fill(Color color) override;
protected:
virtual void command(uint8_t value) = 0;
virtual void data(uint8_t value) = 0;
virtual void write_display_data() = 0;
void init_reset_();
void draw_absolute_pixel_internal(int x, int y, Color color) override;
int get_height_internal() override;
int get_width_internal() override;
size_t get_buffer_length_();
const char *model_str_();
SSD1351Model model_{SSD1351_MODEL_128_96};
GPIOPin *reset_pin_{nullptr};
bool is_on_{false};
float brightness_{1.0};
};
} // namespace ssd1351_base
} // namespace esphome

0
esphome/components/ssd1351_spi/__init__.py Normal file
View File

26
esphome/components/ssd1351_spi/display.py Normal file
View File

@ -0,0 +1,26 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import spi, ssd1351_base
from esphome.const import CONF_DC_PIN, CONF_ID, CONF_LAMBDA, CONF_PAGES
AUTO_LOAD = ['ssd1351_base']
DEPENDENCIES = ['spi']
ssd1351_spi = cg.esphome_ns.namespace('ssd1351_spi')
SPISSD1351 = ssd1351_spi.class_('SPISSD1351', ssd1351_base.SSD1351, spi.SPIDevice)
CONFIG_SCHEMA = cv.All(ssd1351_base.SSD1351_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(SPISSD1351),
cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
}).extend(cv.COMPONENT_SCHEMA).extend(spi.spi_device_schema()),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield ssd1351_base.setup_ssd1351(var, config)
yield spi.register_spi_device(var, config)
dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN])
cg.add(var.set_dc_pin(dc))

72
esphome/components/ssd1351_spi/ssd1351_spi.cpp Normal file
View File

@ -0,0 +1,72 @@
#include "ssd1351_spi.h"
#include "esphome/core/log.h"
#include "esphome/core/application.h"
namespace esphome {
namespace ssd1351_spi {
static const char *TAG = "ssd1351_spi";
void SPISSD1351::setup() {
ESP_LOGCONFIG(TAG, "Setting up SPI SSD1351...");
this->spi_setup();
this->dc_pin_->setup(); // OUTPUT
if (this->cs_)
this->cs_->setup(); // OUTPUT
this->init_reset_();
delay(500); // NOLINT
SSD1351::setup();
}
void SPISSD1351::dump_config() {
LOG_DISPLAY("", "SPI SSD1351", this);
ESP_LOGCONFIG(TAG, " Model: %s", this->model_str_());
if (this->cs_)
LOG_PIN(" CS Pin: ", this->cs_);
LOG_PIN(" DC Pin: ", this->dc_pin_);
LOG_PIN(" Reset Pin: ", this->reset_pin_);
ESP_LOGCONFIG(TAG, " Initial Brightness: %.2f", this->brightness_);
LOG_UPDATE_INTERVAL(this);
}
void SPISSD1351::command(uint8_t value) {
if (this->cs_)
this->cs_->digital_write(true);
this->dc_pin_->digital_write(false);
delay(1);
this->enable();
if (this->cs_)
this->cs_->digital_write(false);
this->write_byte(value);
if (this->cs_)
this->cs_->digital_write(true);
this->disable();
}
void SPISSD1351::data(uint8_t value) {
if (this->cs_)
this->cs_->digital_write(true);
this->dc_pin_->digital_write(true);
delay(1);
this->enable();
if (this->cs_)
this->cs_->digital_write(false);
this->write_byte(value);
if (this->cs_)
this->cs_->digital_write(true);
this->disable();
}
void HOT SPISSD1351::write_display_data() {
if (this->cs_)
this->cs_->digital_write(true);
this->dc_pin_->digital_write(true);
if (this->cs_)
this->cs_->digital_write(false);
delay(1);
this->enable();
this->write_array(this->buffer_, this->get_buffer_length_());
if (this->cs_)
this->cs_->digital_write(true);
this->disable();
}
} // namespace ssd1351_spi
} // namespace esphome

30
esphome/components/ssd1351_spi/ssd1351_spi.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
#include "esphome/core/component.h"
#include "esphome/components/ssd1351_base/ssd1351_base.h"
#include "esphome/components/spi/spi.h"
namespace esphome {
namespace ssd1351_spi {
class SPISSD1351 : public ssd1351_base::SSD1351,
public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH, spi::CLOCK_PHASE_TRAILING,
spi::DATA_RATE_8MHZ> {
public:
void set_dc_pin(GPIOPin *dc_pin) { dc_pin_ = dc_pin; }
void setup() override;
void dump_config() override;
protected:
void command(uint8_t value) override;
void data(uint8_t value) override;
void write_display_data() override;
GPIOPin *dc_pin_;
};
} // namespace ssd1351_spi
} // namespace esphome

2
esphome/components/xiaomi_cgd1/sensor.py
View File

@ -40,4 +40,4 @@ def to_code(config):
sens = yield sensor.new_sensor(config[CONF_BATTERY_LEVEL])
cg.add(var.set_battery_level(sens))
cg.add_library("mbedtls", "cdf462088d")
cg.add_library("mbedtls", None)

2
esphome/components/xiaomi_lywsd03mmc/sensor.py
View File

@ -41,4 +41,4 @@ def to_code(config):
sens = yield sensor.new_sensor(config[CONF_BATTERY_LEVEL])
cg.add(var.set_battery_level(sens))
cg.add_library("mbedtls", "cdf462088d")
cg.add_library("mbedtls", None)

2
esphome/components/xiaomi_mjyd02yla/binary_sensor.py
View File

@ -44,4 +44,4 @@ def to_code(config):
sens = yield binary_sensor.new_binary_sensor(config[CONF_LIGHT])
cg.add(var.set_light(sens))
cg.add_library("mbedtls", "cdf462088d")
cg.add_library("mbedtls", None)

1
requirements.txt
View File

@ -10,3 +10,4 @@ pyserial==3.4
ifaddr==0.1.6
platformio==4.3.3
esptool==2.8
click==7.1.2

9
tests/test1.yaml
View File

@ -1114,6 +1114,7 @@ light:
green: pca_4
blue: pca_5
white: pca_6
color_interlock: true
- platform: rgbww
name: "Living Room Lights 2"
red: pca_3
@ -1123,6 +1124,7 @@ light:
warm_white: pca_6
cold_white_color_temperature: 153 mireds
warm_white_color_temperature: 500 mireds
color_interlock: true
- platform: cwww
name: "Living Room Lights 2"
cold_white: pca_6
@ -1592,6 +1594,13 @@ display:
reset_pin: GPIO23
lambda: |-
it.rectangle(0, 0, it.get_width(), it.get_height());
- platform: ssd1351_spi
model: "SSD1351 128x128"
cs_pin: GPIO23
dc_pin: GPIO23
reset_pin: GPIO23
lambda: |-
it.rectangle(0, 0, it.get_width(), it.get_height());
- platform: waveshare_epaper
cs_pin: GPIO23
dc_pin: GPIO23