Tasmota - Revision history

Leo: Added power meter calibration, link to Lenovo smart plug

2023-03-19T19:42:20Z

Added power meter calibration, link to Lenovo smart plug

@@ Line 411: / Line 411: @@
 Once this is done, you should see a color selector on the main web interface.
 ==Compiling==
 Compile instructions are available at https://tasmota.github.io/docs/Compile-your-build/. The simplest way for me was to use their Docker image which uses platform.io to do the builds. To get started, run:

Leo: /* Rules */

2022-02-18T05:34:52Z

Rules

← Older revision		Revision as of 05:34, 18 February 2022
Line 174:		Line 174:
	\|<code>MHZ19B#CarbonDioxide>600</code>		\|<code>MHZ19B#CarbonDioxide>600</code>
	\|}		\|}
	Tasmota supports the following comparison operators.		Tasmota supports the following comparison operators. Aside from the string based equality operators, I haven't come across any of the other string operators in any rule examples yet.
	{\| class="wikitable"		{\| class="wikitable"
	\|+		!Numeric
	!String		!String
	~~!Numeric~~
	!
	!
	\|-		\|-
	\|		\|Equal numeric <code>a==b</code>
	* = ~~equality~~		\|Equal strings <code>a=b</code>
	\|		\|-
	\|		\|Not equal <code>a!=b</code>
	\|		\|Not equal <code>a$!a</code>
			\|-
			\|Greater <code>a>b</code>
			\|Starts with <code>a$<b</code>
			\|-
			\|Less than <code>a<b</code>
			\|Ends with <code>a$>b</code>
	\|-		\|-
	\|		\|Modulo <code><nowiki>a\|b</nowiki></code>
	\|		\|Contains <code><nowiki>a$\|b</nowiki></code>
	\|
	\|
	\|-		\|-
	\|		\|
	\|		\|Does not contain <code>a$^b</code>
	\|
	\|
	\|}		\|}
	After the trigger, we specify the tasks we want to do after the <code>do</code> keyword. If you need to run multiple commands, use the <code>backlog</code> command to combine multiple commands together separated by a semicolon. You can add as many rules within a rule set as you can fit within the confines of your device's memory.		After the trigger, we specify the tasks we want to do after the <code>do</code> keyword. If you need to run multiple commands, use the <code>backlog</code> command to combine multiple commands together separated by a semicolon. You can add as many rules within a rule set as you can fit within the confines of your device's memory.

Leo: /* Rules */

2022-02-18T05:21:43Z

Rules

← Older revision		Revision as of 05:21, 18 February 2022
Line 143:		Line 143:
	Rules are defined within a rule set and always begin with <code>on</code> and end with either <code>endon</code> or <code>break</code>. A break causes stops the rule set from processing any further rules, which can be useful for behaviors that depend on a nested list of conditions (more on this later).		Rules are defined within a rule set and always begin with <code>on</code> and end with either <code>endon</code> or <code>break</code>. A break causes stops the rule set from processing any further rules, which can be useful for behaviors that depend on a nested list of conditions (more on this later).

	The trigger comes after the on keyword. Types of triggers include:		The trigger comes after the on keyword. Types of triggers include the following:
	{\| class="wikitable"		{\| class="wikitable"
	!Trigger when...		!Trigger when...
Line 151:		Line 151:
	\|Trigger on a specific trigger, such as timers, clocks, MQTT events, system events, variable changes, etc.		\|Trigger on a specific trigger, such as timers, clocks, MQTT events, system events, variable changes, etc.
	\|<code>[TriggerName]#[ValueName]</code>		\|<code>[TriggerName]#[ValueName]</code>
	\|Event#Update - Triggered when we run a custom event <code>event update</code>		\|<code>Event#Update</code> - Triggered when we run a custom event <code>event update</code>
	System#Init - Run when system starts, before WiFi and MQTT		<code>System#Init</code> - Run when system starts, before WiFi and MQTT

	System#Boot - Run when the system starts, after WiFi and MQTT		<code>System#Boot</code> - Run when the system starts, after WiFi and MQTT

	System#Save - Run before we reboot		<code>System#Save</code> - Run before we reboot

	Time#Minute - Run every minute		<code>Time#Minute</code> - Run every minute
	\|-		\|-
	\|Trigger on a specific trigger if the value meets the condition		\|Trigger on a specific trigger if the value meets the condition
	\|<code>[TriggerName]#[ValueName][comparison][value]</code>		\|<code>[TriggerName]#[ValueName][comparison][value]</code>
	\|<nowiki>Time#Minute\|5 - Run every 5 minutes~~</nowiki>~~		\|<code><nowiki>Time#Minute\|5</nowiki></code> - Run every 5 minutes

	Time#Minute=241 - Run at 04:01AM every day		<code>Time#Minute=241</code> - Run at 04:01AM every day
	\|-		\|-
	\|A sensor value changes		\|A sensor value changes
	\|<code>[SensorName]#[ValueName]</code>		\|<code>[SensorName]#[ValueName]</code>
	\|MHZ19B#CarbonDioxide		\|<code>MHZ19B#CarbonDioxide</code>
	\|-		\|-
	\|A sensor value changes and meets the condition		\|A sensor value changes and meets the condition
	\|<code>[SensorName]#[ValueName][comparison][value]</code>		\|<code>[SensorName]#[ValueName][comparison][value]</code>
	\|MHZ19B#CarbonDioxide>600		\|<code>MHZ19B#CarbonDioxide>600</code>
	\|}		\|}
	~~After~~ the ~~on keywor~~		Tasmota supports the following comparison operators.
			{\| class="wikitable"
	~~Rules are always defined within a rule set and always begin with '~~<code>on</code>~~' and end with '~~<code>~~endon~~</code>'.		\|+
			!String
			!Numeric
			!
			!
			\|-
			\|
			* = equality
			\|
			\|
			\|
			\|-
			\|
			\|
			\|
			\|
			\|-
			\|
			\|
			\|
			\|
			\|}
			After the trigger, we specify the tasks we want to do after the <code>do</code> keyword. If you need to run multiple commands, use the <code>backlog</code> command to combine multiple commands together separated by a semicolon. You can add as many rules within a rule set as you can fit within the confines of your device's memory.

	~~In this example, the rule is defined within <code>rule1</code> and would run <code>DisplayText</code> whenever the sensor~~'s ~~<code>CarbonDioxide</code> metric changes~~. We can ~~add additional rules~~ within ~~rule1 by appending additional rules as~~ a ~~list~~. ~~In another example with the INA219, we could write the following rules which will write the voltage, current, and wattage value to a display:~~		Here's a slightly more complex set of rules. Notice how we can enable and disable rule sets within a rule.

	{{Highlight		{{Highlight
Line 185:		Line 207:
	on INA219#Current do DisplayText [c1l2]I %value% A endon		on INA219#Current do DisplayText [c1l2]I %value% A endon
	on INA219#Power do DisplayText [c1l3]P %value% W endon		on INA219#Power do DisplayText [c1l3]P %value% W endon
			on button1#state=3 do backlog power1 1; rule1 1 endon
			on button1#state=10 do backlog rule1 1; power1 1; delay 500; power1 0; rule1 0 endon
	\| lang = text		\| lang = text
	}}		}}

	~~For~~ the ~~rules to take effect~~, enable the rule set:		To apply these rules, copy and paste the entire rule set and paste it as a command into Tasmota's console. This multi-line rule set will be converted into a single line and compressed in memory by Tasmota.

			Next, enable the rule set for the rules to take effect by running:

	{{Highlight		{{Highlight
	\| code = rule1 1		\| code = rule1 1
	~~\| lang = text~~
	}}

	For more complex rules that need to run multiple commands, chain them together with the <code>backlog</code> command. Rules can also enable or disable entire rule sets to enable or disable some behavior. Case in point, from one of my other projects, we could enable and later disable the screen from updating when a button is pressed:

	~~{{Highlight~~
	~~\| code = Rule2~~
	~~ON button1#state=3 do backlog power1 1; rule1 1 endon~~
	~~ON button1#state=10 do backlog rule1 1; power1 1; delay 500; power1 0; rule1 0 endon~~
	\| lang = text		\| lang = text
	}}		}}

Leo: /* Rules */

2022-02-18T05:12:41Z

Rules

@@ Line 129: / Line 129: @@
 ===Rules===
-Rules are sets of commands that should run when a specific condition is met. They are a way to program user defined behaviors to Tasmota without requiring a recompile. The ability to write rules allow for interesting behaviors between sensors and peripherals, such as updating an attached display when sensor values change.
+Rules are sets of commands that should run when a specific condition is met. They are a way to program user defined behaviors to Tasmota without needing to write real code and requiring a recompile. The ability to write rules allow for interesting behaviors between events, sensors, and peripherals, such as updating an attached display when sensor values change, or turning a light on when a specific condition is met.
-Rules are defined within a rule set. Tasmota out of the box has 3 rule sets called rule1, rule2, and rule3. Any number of rules can be placed in each set (though, limited by the device's memory, but the documentation says at least 1000 bytes). Rule sets can be enabled or disabled, which also enables or disables any rules within.  This allows for entire behaviors to be enabled or disabled simply by enabling or disabling a rule set.
+Rules are defined within a rule set which allows similar rules to be grouped togoether. Out of the box, Tasmota has 3 rule sets called <code>rule1</code>, <code>rule2</code>, and <code>rule3</code>. Any number of rules can be placed in each set (though in actuality, it's limited by the device's memory. Tasmota's documentation says each rule set can hold least 1000 bytes worth of rules). Each of the 3 rule sets can be enabled or disabled. When a rule set is enabled, all rules within it will be active and vice versa. The ability to toggle on or off entire sets of rules allows for some interesting behaviors which we will explore later on.
 ====Quick start with rules====
-Frequently, we want to do something with a sensor reading. In the case of a CO2 monitor, we could possibly want to update a display when the PPM value changes. {{Highlight
+Frequently, we want to do something with a sensor reading. In the case of a CO2 monitor, we may want to update a display when the PPM value changes. To do this, we create a new rule within the rule1 set by the following command: {{Highlight
 | code = Rule1
    on MHZ19B#CarbonDioxide do DisplayText [zc1l1]%value%ppm endon
 | lang = text
 }}
-Rules are always defined within a rule set and always begin with '<code>on</code>' and end with '<code>endon</code>'. In this example, the rule is defined within <code>rule1</code> and would run <code>DisplayText</code> whenever the sensor's <code>CarbonDioxide</code> metric changes. We can add additional rules within rule1 by appending additional rules as a list. In another example with the INA219, we could write the following rules which will write the voltage, current, and wattage value to a display:
+Rules are defined within a rule set and always begin with <code>on</code> and end with either <code>endon</code> or <code>break</code>. A break causes stops the rule set from processing any further rules, which can be useful for behaviors that depend on a nested list of conditions (more on this later).
 {{Highlight

Leo at 06:39, 17 February 2022

2022-02-17T06:39:43Z

← Older revision		Revision as of 06:39, 17 February 2022
Line 343:		Line 343:

	====Light Dependent Resistors (LDR) / photoresistors to the ADC input====		====Light Dependent Resistors (LDR) / photoresistors to the ADC input====
	~~I had~~ a ~~protoboard with~~ a ~~LDR connected to the ADC. The input range is supposed to be 3.3v (in full darkness) to 0.0v (in full brightness)~~. ~~When selecting~~ the ~~ADC input~~ to ADC ~~Light,~~ the ~~light reading is inverted~~.		The ADC input pins can detect a voltage and convert it into a digital value. Tasmota has the option to read a ADC pin and convert the value into a luminance value measured in Lux.

	~~There are 4 values: The type~~ (3 ~~for light~~), ~~resistor constant, lux scalar~~, ~~and lux exponent. Out of sheer laziness~~, ~~I opted to just change the values until I got a value that was reasonable and increases with more light. While doing so~~, ~~I noticed that~~ the ~~bridge~~ resistor ~~value adjusts the magnitude of the lux reading~~, the lux scalar ~~adjusts the offset~~, and the lux exponent ~~adjusts~~ the ~~weight of the input reading~~.		A full voltage (1V directly to the ESP8266 or 3.3v if you're using the Wemos D1 board) registers as full brightness to no voltage (0V) as full darkness. The min/max/scaling of lux values can be adjusted by the <code>AdcParam 3,arg1,arg2,arg3</code> command, where arg1 is the resistor constant, arg2 is the lux scalar, and arg3 is the lux exponent used in the [https://www.allaboutcircuits.com/projects/design-a-luxmeter-using-a-light-dependent-resistor/ Lux equation].

	What seemed to work for me was the ADC param values: <code>adcparam 3,3,10,1</code>.		On my own custom Wemos D1 boards, I inadvertently inverted the inputs (so 0v was full brightness). I noticed that the bridge resistor value adjusts the magnitude of the lux reading, the lux scalar adjusts the offset, and the lux exponent adjusts the weight of the input reading. What seemed to work for me was the ADC param values: <code>adcparam 3,3,10,1</code>.

			==== RGB LED ====
			Tasmota can control 3 separate PWM channels as a single RGB LED light using the MultiPwm feature.

			On the hardware side, connect your LED to your ESP on PWM capable output pins. On Tasmota, configure the pin as 'PWM' or 'PWM_i' with each pin on a separate channel (1 as red, 2 as green, 3 as blue). You should use PWM if your pins will be sourcing current (for common-cathode lights) and PWM_i if your pins will be sinking current (for common-anode lights). Ensure that SetOption68 is disabled so that all 3 channels are treated as a single light.

			Once this is done, you should see a color selector on the main web interface.

	==Compiling==		==Compiling==

Leo: /* Displaytext commands */

2022-02-15T07:23:31Z

Displaytext commands

← Older revision		Revision as of 07:23, 15 February 2022
Line 204:		Line 204:
	====Displays====		====Displays====
	All supported displays can be found at https://tasmota.github.io/docs/Displays/#supported-displays. You may need to tweak the Tasmota compile options and rebuild a firmware file for your particular display. Once Tasmota is able to see your display, you should be able to draw or write text to it using the common display commands that are included in Tasmota.		All supported displays can be found at https://tasmota.github.io/docs/Displays/#supported-displays. You may need to tweak the Tasmota compile options and rebuild a firmware file for your particular display. Once Tasmota is able to see your display, you should be able to draw or write text to it using the common display commands that are included in Tasmota.

			See also: https://github.com/tasmota/docs/blob/master/docs/Displays.md

	===== SSD1306 =====		===== SSD1306 =====
Line 239:		Line 241:
	Save and restart Tasmota (with <code>Restart 1</code>) and then confirm that the display is working by running <code>Displaytext [zl1c1]hello</code>.		Save and restart Tasmota (with <code>Restart 1</code>) and then confirm that the display is working by running <code>Displaytext [zl1c1]hello</code>.

	===== ~~16x02~~ LCD display via i2c =====		===== HD44780 LCD display via i2c =====
	The 1602 LCD i2c adapter ~~works similarly~~. ~~Just enable~~ <code>USE_I2C</code>, <code>USE_DISPLAY</code>. ~~Once Tasmota is running, configure it~~ with the following commands.{{Highlight		The HD44780 family of LCD displays, which includes the 1602 LCD display, can be interfaced using a i2c adapter. After connecting the adapter to Tasmota via the i2c bus, you should be able to start drawing text to the display using the Displaytext command.

			To get started, use the display Tasmotao firmware or compile Tasmota with <code>USE_I2C</code>, <code>USE_DISPLAY</code> options. Configure the display with the following commands:{{Highlight
	\| code = DisplayAddress 0x27 # the address discovered by i2cscan		\| code = DisplayAddress 0x27 # the address discovered by i2cscan
	DisplayModel 1 # for LCD display		DisplayModel 1 # for LCD display
Line 248:		Line 252:
	DisplayMode 0 # enter text mode		DisplayMode 0 # enter text mode
	\| lang = text		\| lang = text
	}}		}}The special characters that are available to the HD44780 can be written to by escaping the hex code with tilda. Eg. ~e4 to write the character 0xe4.

	=====Displaytext commands=====		=====Displaytext commands=====
	All text is drawn using the Displaytext command.		All text is drawn using the Displaytext command.


	You may have noticed that there are some letters in square brackets passed to the <code>Displaytext</code> command. These are options that control the behavior of where and how the text should be drawn and can control the font size and location of the text. For example, to print "Hello World" across two separate lines, we write hello on line 1 column 1 (<code>l1c1</code>) and world on line 2 column 1 (<code>l2c1</code>):{{Highlight		You may have noticed that there are some letters in square brackets passed to the <code>Displaytext</code> command. These are options that control the behavior of where and how the text should be drawn and can control the font size and location of the text. For example, to print "Hello World" across two separate lines, we write hello on line 1 column 1 (<code>l1c1</code>) and world on line 2 column 1 (<code>l2c1</code>):{{Highlight
	\| code = Displaytext [l1c1]hello		\| code = Displaytext [l1c1]hello
	Displaytext [l2c1]world!		Displaytext [l2c1]world!
	\| lang = terminal		\| lang = terminal
	}}There are many other parameters which can be found at: https://tasmota.github.io/docs/Displays/#displaytext-use. The most important ones you should know are listed below. You may chain any number of these together and they will run in the order they appear. Eg. <code>[zl1c1f0s1]Hello</code> would clear, then write the world <code>Hello</code> in the smallest font on line 1 column 1 ~~after clearing the screen~~.		}}There are many other parameters which can be found at: https://tasmota.github.io/docs/Displays/#displaytext-use. The most important ones you should know are listed below. You may chain any number of these together and they will run in the order they appear. Eg. <code>[zl1c1f0s1]Hello</code> would clear, then write the world <code>Hello</code> in the smallest font on line 1 column 1.
	{\| class="wikitable"		{\| class="wikitable"
	!Command/parameter		!Command/parameter

Leo at 04:07, 14 February 2022

2022-02-14T04:07:54Z

← Older revision		Revision as of 04:07, 14 February 2022
Line 191:		Line 191:

	====Setting up I2C====		====Setting up I2C====
	[[File:Tasmota I2C GPIO Configuration.jpg\|alt=Tasmota I2C GPIO Configuration\|thumb\|Tasmota I2C GPIO Configuration]]Some sensors and displays use the I2C protocol. The ESP8266 uses ~~GPIO4~~ and ~~GPIO5 as~~ the ~~I2C data~~ and ~~clock~~, respectively. ~~When using I2C devices with Tasmota, configure~~ the ~~template as shown~~ on the ~~right~~. Save and activate the template. If configured properly, the <code>i2cscan</code> command should return a list of addresses that was found on the I2C bus.		[[File:Tasmota I2C GPIO Configuration.jpg\|alt=Tasmota I2C GPIO Configuration\|thumb\|Tasmota I2C GPIO Configuration for a ESP8266]]Some sensors and displays use the I2C protocol which requires 2 wires for data and clock.

			The ESP8266 uses GPIO 4 and GPIO 5 while the ESP32 uses GPIO 21 and GPIO 22 for SDA and SCL, respectively. You can set these under the 'Configure Module' page on the web interface.

			Save and activate the template. If configured properly, the <code>i2cscan</code> command should return a list of addresses that was found on the I2C bus.
	{{Highlight		{{Highlight
	\| code = CMD: i2cscan		\| code = CMD: i2cscan
Line 198:		Line 202:
	}}		}}

	====SSD1306 ~~display~~====		====Displays====
			All supported displays can be found at https://tasmota.github.io/docs/Displays/#supported-displays. You may need to tweak the Tasmota compile options and rebuild a firmware file for your particular display. Once Tasmota is able to see your display, you should be able to draw or write text to it using the common display commands that are included in Tasmota.

			===== SSD1306 =====
	The SSD1306 is an OLED display that comes in various sizes. These displays use I2C. The Wemos D1 OLED module is one such device with a screen size of 64x48. Tasmota supports this display through the <code>tasmota-displays.bin</code> image or you may compile support in by creating a <code>user_config_override.h</code> file with:		The SSD1306 is an OLED display that comes in various sizes. These displays use I2C. The Wemos D1 OLED module is one such device with a screen size of 64x48. Tasmota supports this display through the <code>tasmota-displays.bin</code> image or you may compile support in by creating a <code>user_config_override.h</code> file with:

Line 216:		Line 223:
	}}		}}

	After flashing Tasmota with the proper peripheral support, attach the display to the ~~ESP on~~ GPIOs 4 and 5. Once connected, running <code>i2cscan</code> on the console should return the display device at address <code>0x3c</code>.{{Highlight		After flashing Tasmota with the proper peripheral support, attach the display to the ESP8266 via I2C (GPIOs 4 and 5 for SDA/SCL on the ESP8266, or GPIOs 21 and 22 for SDA/SCL on the ESP32). Once connected, running <code>i2cscan</code> on the console should return the display device at address <code>0x3c</code>.{{Highlight
	\| code = 05:26:20.151 CMD: i2cscan		\| code = 05:26:20.151 CMD: i2cscan
	05:26:20.173 MQT: tasmota/D1-2/RESULT = {"I2CScan":"Device(s) found at 0x3c"}		05:26:20.173 MQT: tasmota/D1-2/RESULT = {"I2CScan":"Device(s) found at 0x3c"}
Line 232:		Line 239:
	Save and restart Tasmota (with <code>Restart 1</code>) and then confirm that the display is working by running <code>Displaytext [zl1c1]hello</code>.		Save and restart Tasmota (with <code>Restart 1</code>) and then confirm that the display is working by running <code>Displaytext [zl1c1]hello</code>.

			===== 16x02 LCD display via i2c =====
			The 1602 LCD i2c adapter works similarly. Just enable <code>USE_I2C</code>, <code>USE_DISPLAY</code>. Once Tasmota is running, configure it with the following commands.{{Highlight
			\| code = DisplayAddress 0x27 # the address discovered by i2cscan
			DisplayModel 1 # for LCD display
			DisplayWidth 16 # the display resolution
			DisplayHeight 2
			DisplayDimmer 100 # turn the display on
			DisplayMode 0 # enter text mode
			\| lang = text
			}}
	=====Displaytext commands=====		=====Displaytext commands=====
			All text is drawn using the Displaytext command.


	You may have noticed that there are some letters in square brackets passed to the <code>Displaytext</code> command. These are options that control the behavior of where and how the text should be drawn and can control the font size and location of the text. For example, to print "Hello World" across two separate lines, we write hello on line 1 column 1 (<code>l1c1</code>) and world on line 2 column 1 (<code>l2c1</code>):{{Highlight		You may have noticed that there are some letters in square brackets passed to the <code>Displaytext</code> command. These are options that control the behavior of where and how the text should be drawn and can control the font size and location of the text. For example, to print "Hello World" across two separate lines, we write hello on line 1 column 1 (<code>l1c1</code>) and world on line 2 column 1 (<code>l2c1</code>):{{Highlight
	\| code = Displaytext [l1c1]hello		\| code = Displaytext [l1c1]hello

Leo: /* Compiling */

2022-02-13T23:26:52Z

Compiling

← Older revision		Revision as of 23:26, 13 February 2022
Line 327:		Line 327:

	==Compiling==		==Compiling==
	Compile instructions are available at https://tasmota.github.io/docs/Compile-your-build/. The ~~most simple~~ way ~~I've used is~~ to use their ~~docker~~ image ~~with~~ the ~~following commands~~:		Compile instructions are available at https://tasmota.github.io/docs/Compile-your-build/. The simplest way for me was to use their Docker image which uses platform.io to do the builds. To get started, run:
	{{Highlight		{{Highlight
	\| code = $ git clone https://github.com/tasmota/docker-tasmota		\| code = $ git clone https://github.com/tasmota/docker-tasmota
Line 336:		Line 336:
	$ docker run -ti --rm -v $(pwd)/Tasmota:/tasmota -u $UID:$GID docker-tasmota -e tasmota		$ docker run -ti --rm -v $(pwd)/Tasmota:/tasmota -u $UID:$GID docker-tasmota -e tasmota
	\| lang = terminal		\| lang = terminal
	}}~~The different builds are~~ available at https://github.com/arendst/Tasmota/blob/063611314777d4dd9dc8c25905f19f8b25f510aa/platformio.ini#L18		}}What you want to build is controlled by the environment (provided by the <code>-e</code> option). A list of all available environments can be found in the [https://github.com/arendst/Tasmota/blob/063611314777d4dd9dc8c25905f19f8b25f510aa/platformio.ini#L18 platformio.ini file]. By default, if no environment is specified, it will build everything for you. For a standard Tasmota firmware, use the <code>tasmota</code> environment.

			To include additional drivers (like displays, sensors, etc), edit the <code>tasmota/my_user_config.h</code> file and uncomment (to add) or comment out (to remove) each feature as desired. Be aware that Tasmota groups features together and you may need to enable an entire group of features (eg. displays, power monitoring) for a specific feature to become included.

			To compile a ESP32 version, pass in <code>-e tasmota32</code>.

			Once the compile is complete, you'll find your firmware under the <code>build_output</code> directory.

	===Project structure===		===Project structure===

Leo: /* ESP32 */

2022-02-13T21:43:10Z

ESP32

← Older revision		Revision as of 21:43, 13 February 2022
Line 49:		Line 49:
	Download the ESP32 bootloader files from https://github.com/arendst/Tasmota-firmware/tree/main/static/esp32, the latest Tasmota firmware file, and then run:		Download the ESP32 bootloader files from https://github.com/arendst/Tasmota-firmware/tree/main/static/esp32, the latest Tasmota firmware file, and then run:
	{{Highlight		{{Highlight
	\| code = # esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 921600 --before default_reset --after hard_reset write_flash -z --flash_mode dout --flash_freq 40m --flash_size detect 0x1000 bootloader_dout_40m.bin 0x8000 partitions.bin 0xe000 boot_app0.bin 0x10000 tasmota32.bin		\| code = # esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 921600 --before default_reset --after hard_reset \
			write_flash -z --flash_mode dout --flash_freq 40m --flash_size detect \
			0x1000 bootloader_dout_40m.bin \
			0x8000 partitions.bin \
			0xe000 boot_app0.bin \
			0x10000 tasmota32.bin
	esptool.py v3.2		esptool.py v3.2
	Serial port /dev/ttyUSB0		Serial port /dev/ttyUSB0

Leo: /* ESP32 */

2022-02-13T21:40:59Z

ESP32

← Older revision		Revision as of 21:40, 13 February 2022
Line 84:		Line 84:
	Hard resetting via RTS pin...		Hard resetting via RTS pin...
	\| lang = terminal		\| lang = terminal
	\| style = max-height: ~~20px~~		\| style = max-height:350px;overflow:scroll;
	}}		}}