WANTED Berry LED effect examples for documentation

[blakadder]

Documentation for https://tasmota.github.io/docs/Berry_Addressable-LED is lacking in working berry examples of simple LED strip effects like breathe, chase, pulse and similar.

We need some working examples to kickstart users making and adapting their own

[refthoom]

I'd love to have examples for ledstrips indeed although not for pretty light effects. Using ledstrips as scales I think are much more in line with the IoT/OT devices idea of Tasmota.

I have an SCD41 CO2 sensor connected to an ESP32-C3 that works fine. I also have a circular ws2812 ledstrip that I would like to add to it, as a scale. It has 16 pixels for a scale of 0 - 2000, with the intention to use green for 0 - 750, yellow for 750 - 1250 and red for 1250 - 2000.

Reading the sensor value in Berry was easy, but I'm totally stuck at how to get that value on the ledstrip as a readout. The examples in the documentation did not help. For me as a hobbyist, it is way to complex, sorry. So any examples would greatly help.

[sfromis]

Here's two example animations, I have the cylon one running right now.
https://github.com/s-hadinger/Tasmota-Berry-emulator/tree/main/tasmota

You don't need to run that emulator, that's just a tool making it possible to try out animations without using ESP32 and normal Tasmota setup. That can be handy for experimentation, animations (and most other Berry code) should work the same on both platforms.

[refthoom]

Thanks @sfromis, but I think that is way too complicated for me, for what I'm trying to make. I just need to set each pixel in a row of pixels. Last time I programmed was 20+ years ago in PHP and I'm pretty much overwhelmed when classes and objects are involved :-)

This is the hardware and config;

This all functions as expected. The main page shows the sensor values and I can also use the sliders etc. to change colours etc.

These are the requirements I have set for this little project, using 14.4.1 (release-tasmota32);

And this is the berry script part that I have got running without errors;

import json
var led_count = 16
var strip = Leds(led_count, gpio.pin(gpio.WS2812, 0))
var sensors = json.load(tasmota.read_sensors())
var sensorA = sensors['SCD40']['CarbonDioxide']
var sensorB = sensors['SCD40']['eCO2']
var sensor = int((sensorA + sensorB)/2)
print (sensor) # debug

  var leds_on = int(sensor / 160)
  if leds_on > led_count
    leds_on = led_count
  end
  print(leds_on) # debug

  var g = 0
  var r = 0
  var b = 0
  if sensor <= 800 # green
    g = 255
  elif sensor <= 1300 # yellow
    r = 255
    g = 255
  else # red
    r = 255
  end
  print(g,' ',r,' ',b) # debug

 var lum_perc = 40 + (leds_on * 4)
  if lum_perc > 100 lum_perc = 100 end
  
 var lum_bin = 80 + (leds_on * 11)
  if lum_bin > 255 lum_bin = 255 end
  print(lum_perc, ' ', lum_bin) # debug

But from there on I'm stuck because I can't find how to simply set the pixels. I would expect (or really like) something simple like this;

  for i:0..(led_count-1)
   if i < leds_on
      strip.set_pixel_color(i, g, r, 0, lum_bin) # blue is unused so always 0
    else
      strip.set_pixel_color(i, 0, 0, 0, 0) # leds off
    end
  end

Besides what's on the berry plaground and wiki(s) I have looked at projects from your page and I have tried to understand several berry examples from there (leollo98/Tasmota_berryscript-13.5, Hypfer/ulanzi-tc001-tasmota, Staars/berry-examples, dilpish/tasmo-berry-sensor2ws2812, and more) and use them for my script but so far without success.

If you. or anyone else, could point me to a description. tutorial or other examples that are simple, so no animation or matrix, I would appreciate that very much. Or maybe a better place to ask my question?

Once working I would post it to the playground of course

[sfromis]

As mentioned in the docs, the arguments for set_pixel_color is index, color and optional brightness, meaning that RGB are not separate fields.
https://tasmota.github.io/docs/Berry_Addressable-LED/#led-strips-matrix-and-sub-strips

Here's a basic example of quickly cycling a few colors:

pixels = 25
if global.strip == nil
  global.strip = Leds(pixels, gpio.pin(gpio.WS2812, 1))
end
var strip = global.strip
def show(color)
  strip.clear()
  for n : 0..pixels-1
    strip.set_pixel_color(n, color)
  end
  strip.show()
end

tasmota.set_timer(100, /->show(0xff0000))
tasmota.set_timer(200, /->show(0x00ff00))
tasmota.set_timer(300, /->show(0x0000ff))
tasmota.set_timer(400, /->show(0xffff00))
tasmota.set_timer(500, /->show(0x00ffff))
tasmota.set_timer(600, /->show(0xff00ff))
tasmota.set_timer(700, /->show(0xffffff))
tasmota.set_timer(800, /->show(0x222222))

This example assumes a pin configured as WS2812 index 2, instead of having the pin number hardcoded. The 2nd parameter of gpio.pin is the index minus 1. The start of the code ensures that it will only create the strip once even if you run multiple times. This is important, as you cannot just grab another RMT for the strip.

Note that if all you want is a single static color on the whole strip, you have an easier option in simply treating it as a bulb, configured as WS2812 index 1, command Pixels 8 or whatever your count of pixels in the strip is, and then you can power the "bulb" on/off with the Power command, use commands like Color and Dimmer to manage what you get.

[refthoom]

Hi @sfromis , thank you very much for your help, I have a working script now, yay! (below)
For now it runs once after a restart of the ESP, so all that is left is to run this every minute or so. 'tasmota.add_cron' seems like it is fit for purpose here.
Documentation seems hard to find (for me) but from online examples something like this seems to be appropriate for an update every minute.

var cronName ="show_scale"
tasmota.remove_cron(cronName)
tasmota.add_cron("1 * * * * *",show(),"show_scale")

Could you please tell me what the (best) place is to put it? In autoexec.be or inside the script, or somewhere else? Or maybe there is a better option than this or even better than cron?

##########################################################
# berry script to show sensor values on a pixel strip, in 
# three different colors for three sequential ranges.
#
# Developed march 2025 with an 'ESP32-C3 super mini',
# 'SCD41 CO2 sensor' and '16 pixel WS2812 RGB LED Ring',
# on 'release-Tasmota32 14.4.1' and with my honest 
# appreciation for help from @sfromis
#
# User values to configure are any sensor as long as it
# uses integer values, maximum sensor range, pixel 
# colors, color range, number of pixels per color,
# minimum brightness, minimum pixels to be on and
# fixed or dynamic brightness (to draw extra attention to
# high values)
#
# Use this script as file WS2812_scale.be: 
# main >> tools >> manage files system >> 
# create or upload. Then, if not already there, 
# create file autoexec.be and add WS2812_scale.be 
# as a line in there. Then restart Tasmota from 
# the main menu
##########################################################

# json lib to read sensors
import json
# sensor name (see console /SENSOR lines)
var sensor_name = 'SCD40'
var sensor_data_A = 'CarbonDioxide'
var sensor_data_B = 'eCO2'
# define min-max value for the strip to display
var sensor_min_range = 0
var sensor_max_range = 2600
# colors to be used on the strip in hex format 0xRRGGBB
var pixels_a_color = 0x00FF00 # green
var pixels_b_color = 0xFFFF00 # yellow
var pixels_c_color = 0xFF0000 # red
# number of pixels per color, on the strip
var pixels_a = 5
var pixels_b = 3
var pixels_c = 8
var pixels_all = pixels_a + pixels_b + pixels_c # total pixels in use
var pixels_min_lit = 1 # minimum pixels to be lit on the strip
# step value per pixel from sensor range and number of pixels
var pixel_step = int((sensor_max_range - sensor_min_range) / pixels_all)
# define luminosity (brightness) boundaries
var lum_min = 80 # appr. 30%
var lum_max = 255
var lum_fix = 0 # boolean, if 1 then use lum_min as fixed value for brightness
# define the luminosity step per pixel
var lum_step = int((lum_max - lum_min)/(pixels_all - pixels_min_lit))
# define and initiate the strip
var strip = global.strip
if global.strip == nil
	global.strip = Leds(pixels_all, gpio.pin(gpio.WS2812, 1))
end

# calculate sensor value
#############################
def calc_sensor()
	var sensors = json.load(tasmota.read_sensors())
	var sensorA = sensors[sensor_name][sensor_data_A]
	var sensorB = sensors[sensor_name][sensor_data_B]
	var sensor = int((sensorA + sensorB)/2)
	print (sensor) # debug
	return sensor
end
#############################

# number of pixels that are on, derived from the sensor value
#############################
def calc_num_pxs(snsr)
	# calculate the number of pixels to be lit up
	var nums = pixels_min_lit # minimum pixels to be on
	if snsr > 0
		nums = int(snsr / pixel_step)
		if nums >= pixels_all
			nums = pixels_all
		end
		if nums <= pixels_min_lit
			nums = pixels_min_lit
		end
	end
	print(nums) # debug
	return nums
end
#############################

# luminosity (brightness) of pixels that are on
#############################
def calc_lum_pxs(numpxs)
	var lums = lum_min
	if !lum_fix
		lums = lum_min + (numpxs * lum_step)
		if lums > lum_max
			lums = lum_max
		end
	end
	print(lums) # debug
	return lums
end
#############################

# set the pixels and push to buffer
#############################
def show()
	strip.clear()
	var sens_val = calc_sensor()
	var num_pxs = calc_num_pxs(sens_val)
	var lum_pxs = calc_lum_pxs(num_pxs)
	# color_a pixels
	if num_pxs <= pixels_a
		for i : 0..num_pxs - 1
			strip.set_pixel_color(i, pixels_a_color, lum_pxs)
		end
	else # num_pxs > pixels_a
		for i : 0..pixels_a
			strip.set_pixel_color(i, pixels_a_color, lum_pxs)
		end
		# color_b pixels
		if num_pxs <= (pixels_a + pixels_b)
			for i : pixels_a..num_pxs - 1
				strip.set_pixel_color(i, pixels_b_color, lum_pxs)
			end
		else # num_pxs > (pixels_a + pixels_b)
			for i : pixels_a..(pixels_a + pixels_b)
				strip.set_pixel_color(i, pixels_b_color, lum_pxs)
			end
			# color_c pixels
			if num_pxs <= pixels_all
				for i : pixels_b..num_pxs - 1
					strip.set_pixel_color(i, pixels_c_color, lum_pxs)
				end
			else # num_pxs = pixels_all
				for i : (pixels_a + pixels_b)..pixels_all
					strip.set_pixel_color(i, pixels_b_color, lum_pxs)
				end
			# end color_c
			end
		# end color_b
		end
	# end color_a
	end
	strip.show()
end
#############################

# show results
show()

[refthoom]

If I add this to autoexec.be ...

load "WS2812_scale.be"
var cronName ="show_scales"
tasmota.remove_cron(cronName)
tasmota.add_cron("1 * * * * *", show(),"show_scales") # run show() every minute

... and restart, this error leaves me stuck
BRY: failed to load '/autoexec.be' (syntax_error - /autoexec.be:2: strict: expression without side effect detected)

Also, putting all code in autoexec.be and putting the three cron lines in there at the end fails with an error as well.
BRY: failed to run compiled code (type_error - value 'nil' does not support subscriptable)

I'm resorting to trial and error here but no succes so far. Any help is greatly appreciated :-)

[sfromis]

Your calc_sensor() will fail badly in case of not getting the expected data from tasmota.read_sensors. As the debug print is after the data access, you do not get useful debugging info. This looks like the cause of the type error. More later.

Importantly, what you have as second parameter for tasmota.add_cron should be a function, not a function invocation. What you have now would execute the function once, and then it would fail as you are not returning a function to be called in the future. You could refer to show instead of show(), but the more general approach would be to have /->show() (this closure use a short form of a function definition to create a function for the purpose of calling your function, with local context available.

If you want to have a purpose with that cronName variable, you should probably use it in add_cron, instead of repeating the constant there in the last parm.

Your first autoexec.be line is bad syntax, as load is a function call instead of a command. Hence the syntax should be load("WS2812_scale.be")

To only start your code after Tasmota is fully initialized, you could have this in autoexec.be
tasmota.add_rule_once('System#Boot', /->load('WS2812_scale.be'))
This would likely fix the type error, but you could still consider if you want your calc_sensor to be robust enough to tolerate "incomplete" data, or bail out with a clear error message.

[refthoom]

Wow, very fast respons, thank you. I should've taken a break earlier, that would have avoided the CronName thingy and the load thingy. Just sloppyness from looking at my screen without a break for too long :-)

So autoexec.be I made this

tasmota.add_rule_once('System#Boot', /->load('WS2812_scale.be'))
tasmota.remove_cron('show_scale')
tasmota.add_cron("1 * * * * *",/->show(),'show_scale')

but this throws an error
BRY: failed to load '/autoexec.be' (syntax_error - /autoexec.be:3: 'show' undeclared (first use in this function))

The werid thing is that if use the berry scripting console on my actual ESP32, and manually execute the following lines one by one

	load('WS2812_scale.be')
	tasmota.remove_cron('show_scale')
	tasmota.add_cron('1 * * * * *',/->show(),'show_scale')

it works as expected including the printed messages (except for a bug in the scale, but that's for a later moment) and it updates every minute. So it's not as if the lines of code are wrong.

So either I've missed something from your explanation or I'm more stupid than anticipated but either way I'm stuck again. Sorry.

...

About checks to calc_sensor, I've come up with two variants but both fail with an exception (instead of a printed error) when I introduce an error to either sensor name or sensor data name. For now I'll leave it at this but for reference see both below

This the first one, more of an occams type

def calc_sensor()
	var sensors = json.load(tasmota.read_sensors())
	var sensorA = sensors[sensor_name][sensor_data_A]
	var sensorB = sensors[sensor_name][sensor_data_B]
	if (sensorA && sensorB) # is explicit 'not nil' better, like 'if( sensorA != nil && sensorB != nil)'?
		var sensor = int((sensorA + sensorB)/2)
	else
		print ('no_sensor_data') # debug
	end
	print (sensor) # debug
	return sensor
end

The other one is

def calc_sensor()
	var sensors = json.load(tasmota.read_sensors())
	var sensor = 0
	if sensors[sensor_name] != nil
		if sensors[sensor_name][sensor_data_A] != nil && sensors[sensor_name][sensor_data_B] != nil
			var sensorA = sensors[sensor_name][sensor_data_A]
			var sensorB = sensors[sensor_name][sensor_data_B]
			sensor = int((sensorA + sensorB)/2)
			print ('sensor reading ',sensor) # debug
		else
			print ('no sensor data') # debug
		end
	else
		print ('sensor name error') # debug
	end
	if !sensor # 0 defines as false
		print ('sensor value is zero, check for erros')
	end
	return sensor
end

[sfromis]

I spotted your new repository, and have already added it to the mentioned list of Berry projects :-)

[refthoom]

Great, thanks! Almost finished there.

[refthoom]

Great, thanks! Almost finished there.

I'm done. Let me know if you see anything unexpected :-)

[sfromis]

Placement of the SCD41 close to the ESP32-C3 and WS2812 ring means that the temperature value may be off, but if you do not use it......

If you want more symmetry for the ends of the used part of the ring, you could twist it half a pixel position (15 degrees). OTOH, the 5th red pixel will hopefully not be used a lot.....

BTW. Some of your if statements could be simplified using the math.min function.
And no reason to "leave out" import json for repeated REPL testing, it does not hurt doing it again.

[refthoom]

Yeah, the SCD41 gets warmed by the ESP but I don't use that temperature data. It's weird though. I've used an IR thermometer and the CO2 sensor itself is around 20C while Tasmota says something like 37C. The pixels have the same temperature as the surrounding, either on or off. The top of the PCB, where the connections are show a higher temperature, around 27C so I think the temperature measuring parts are located there. The ESP and sensor are back to back on either side of the PVC and the ESP's antenna at the top seems to be the hotspot which is aligned with the top of the sensor PCB.

Indeed, the less red pixels the better :-) It's okay as it is now, hanging from a wall in the living room where it's clearly visible and it provides the information I need that is, knowing when to open a window for some 'Stoßlüften' (next project to do is a proper house ventilation system).

I'll leave the code as it is for now. It's not high level or super optimized but to me it seems like a good entry level functional setup, which may help adoption of these types of projects.

Good to know repeated imports don't result in an out of memory error or such. Thanks.

[refthoom]

Off topic, can someone explain what is going on here?

[sfromis]

First you divide two integers, getting an integer result. This is a common feature of how many programming languages work, having numbers as integers, and using integer-only math, unless already having non-integer values on either side of an arithmetic operation.

Next you divide two integers, and convert the integer result to a real (floating-point), which does not change the number, only the type.

If you wanted the result to be 7.53, you could do tings like
753/100. - having a decimal point makes it a "real" value before the division, which will cast the first number to be "real" too, before performing the divide.

The same more explicit: 753/real(100) or superfluously: real(753)/real(100)

[refthoom]

Right, clear. Thank you.