Introduction and Music

The instructor introduces the topic of Shelley basic scripting basics and checks if the sound is clear.

Introduction

• The instructor greets the audience and asks if they can hear him clearly.

• He mentions that they will continue with exercises in this session.

Course Overview and Schedule

The instructor provides an overview of the course schedule and timing.

Course Schedule

• The course will run from May 25th to July 6th, inclusive, for a total of seven weeks.

• Each lecture or session will be three to four hours long, with breaks every hour.

• There will be two sessions per week. Thursdays will focus on theory or lectures, while Tuesdays will be dedicated to exercise sessions.

• Exercises will be published between Thursday and Tuesday for participants to work on over the weekend.

Material Covered in Previous Lecture

The instructor briefly recaps the topics covered in the previous lecture.

Recap of Previous Lecture

• The previous lecture covered an introduction to IoT water controllers and how they communicate.

• An overview of Shelly devices was provided, along with an introduction to scripting.

• It was emphasized that scripting works only on Gen 2 devices (with "plus" or "pro" in their name).

• The reference device used throughout the course is Shelly Plug S+.

Scripting Basics and Resources

The instructor discusses scripting basics and available resources for participants.

Scripting Basics

• Participants need a Gen 2 device (with "plus" or "pro" in its name) to run scripts.

• The main programming interface for Shelly devices is the Json RPC API.

• The web UI is used to write and execute scripts.

• Two ways to connect to Shelly devices are through the Shelly Smart Control mobile app or a web browser.

Resources

• Participants can find exercises and resources on the Shelley Academy website under the resources section.

• Questions can be asked through various channels, including email, Slido, and the Facebook group.

Connecting to Shelly Devices

The instructor explains how to connect to Shelly devices using different methods.

Connecting to Shelly Devices

• Two ways to connect are through the Shelley Smart Control mobile app or a web browser.

• Detailed steps for device discovery using both methods are provided in slides 44, 45, 46, and 47.

• Discovering the IP address of the device is crucial for initial connection.

Updating Firmware and Scripting Basics

The instructor discusses updating firmware and provides an overview of scripting basics.

Updating Firmware

• It is important to update firmware to the latest beta version for optimal scripting experience.

• Steps for updating firmware can be found in slides 63 onwards.

Scripting Basics

• A script or program is a sequence of commands executed in order.

• Simple examples of scripting were covered in previous sessions.

• More examples will be provided gradually, starting from simple ones and progressing towards more complex scripts.

These notes provide a summary of the transcript by organizing key points into sections. Each section covers a specific topic discussed in the transcript. Bullet points are used within each section to highlight important details. Timestamps are included where available to help locate specific parts of the video.

Shelly Web UI and Development Environments

The Shelly web UI provides a simplified version of the development environment for writing scripts. More advanced users can use complicated development environments like Visual Studio Code. In this section, the instructor will introduce how to explore and debug programs in both the Shelly environment and Visual Studio Code.

Shelly Web UI

• The Shelly web UI has a section for scripts, which provides a simplified version of the development environment.

• It offers features like highlighting and assistance to help users write their scripts.

• Users can develop their scripts through a web browser under the Shelley web development environment.

• No need to have Visual Studio code for this course.

Visual Studio Code

• More advanced users can use Visual Studio Code as their development environment.

• The instructor will show how to explore and debug programs using Visual Studio Code.

• This is not mandatory for the course but provides additional options for more advanced users.

Creating Scripts in Shelley Web Development Environment

This section focuses on creating small scripts in the Shelley web development environment. The instructor will explain the initial configuration required and provide a reminder about previous exercises.

Initial Configuration

• When creating an empty script, there are certain configurations that need to be set up.

• The instructor will repeat this process briefly before moving on to new topics.

Reminder about Previous Exercises

• There is a reminder in the exercise section regarding completing certain tasks from previous sessions.

• If these tasks have not been completed, it is important to do so before proceeding further.

• Previous sessions involved running various scripts, including more complex ones with examples such as changing book colors and controlling switches with other shell devices.

Accessing Exercise Files

This section provides information on accessing the exercise files for the current session.

• The exercise files are available as a Microsoft doc file on the Shelley Academy resources page.

• Users can access the Shelly Academy website and navigate to "My Training" > "Shelly Basic Scripts" > "Exercise Session" to find the link to the doc file.

• It is recommended to download the document from there.

Using Paste Bin for Code Sharing

This section explains how to use Paste Bin, a code-sharing service, for sharing code during the session.

• If participants have questions or want to share code, they can use Paste Bin instead of Slido.

• Slido does not format code well, so using Paste Bin will make it easier for others to understand.

• Participants do not need to sign in to use Paste Bin; they can simply create a new paste and share the link in the chat.

• The instructor demonstrates how to use Paste Bin by showing an example of writing and highlighting JavaScript code.

Types of Exercises

This section discusses the two types of exercises that will be covered in this course.

Algorithmic Based Problems

• The first type of exercise focuses on algorithmic-based problems.

• These exercises start with simple algorithms and gradually progress towards more complex ones.

• They are not directly related to Shelly devices but serve as a foundation for learning programming concepts.

Shelly Related Examples

• Alongside algorithmic exercises, there will also be examples related specifically to Shelly devices.

• These examples provide a mix of algorithmic problem-solving and practical applications using Shelly devices.

• As the course progresses, there will be more emphasis on Shelly-related scripts.

Introduction to Web UI and Script Creation

In this section, the speaker introduces the web user interface (UI) and explains how to create scripts using the Shelly device.

Accessing the Web UI

• To access the web UI, open the device's IP address in a browser.

• The speaker suggests zooming in for better visibility on different resolutions.

Script Creation

• In the web UI, navigate to the "Scripts" tab.

• If no scripts exist, click on "Create New Script" or add a script from the top.

• Each script has a name and control buttons.

• Save the script by clicking on the "Save" button.

Console Section

• The console section allows communication with the device and displays messages from scripts.

• It can be used for troubleshooting and monitoring device activity.

Enabling Console Debugging

• To enable console debugging, go to settings and enable WebSocket Debugging.

• This feature is essential for displaying information on the console.

Creating Your First Script

This section covers creating a simple script that displays a greeting message on the console.

Creating a Hello Script

• Click on "New Script" and give it a name (e.g., "Hello Shelly").

• Define a variable called greeting with a string value (e.g., "Shelly").

• Variables are placeholders for information stored in memory.

• Strings can be enclosed in either double quotes or single quotes.

• Use semicolons at the end of each command for clarity.

Logging to Console

• Use console.log() to display information on the console.

• Provide greeting as an argument inside parentheses after console.log().

• This extracts and logs the value of greeting to the console.

Saving and Starting the Script

• Save the script to the device's memory.

• Start the script by clicking on the "Start" link.

• The console will display the greeting message and a timestamp.

Execution and Output

This section explains how scripts are executed and how output is displayed in the console.

Script Execution

• After saving and starting a script, it is stored in the device's memory.

• The JavaScript engine executes the script's commands sequentially.

Output Display

• When using console.log(), information is sent back to the web browser.

• The web browser displays this information, such as the greeting message.

Timestamps are provided throughout this summary to help locate specific parts of the video.

Understanding Script Execution and Stopping

In this section, the speaker explains how scripts run continuously unless manually stopped. They also address questions related to script execution.

How Scripts Run and Need for Manual Stopping

• Scripts run continuously and perform tasks based on events.

• Once a script is started, it will not stop automatically.

• To ensure a script stops running, it needs to be manually stopped.

Addressing Questions

• The speaker acknowledges that there are interesting questions from the audience.

• They express their intention to answer these questions in an interactive manner throughout the session.

Making Sessions More Interactive

The speaker emphasizes their commitment to addressing audience questions and making sessions more interactive.

Engaging with Audience Questions

• The speaker aims to make sessions more interactive by directly answering relevant questions.

• They apologize for not immediately addressing all the questions but assure that they will cover them during the session.

Full Walk Functionality in Scripting Console

The speaker explains the purpose of the "Full Walk" button in the scripting console and its role in displaying system information and debug messages from various scripts.

Purpose of Full Walk Button

• The "Full Walk" button displays system information and debug messages from other scripts as well.

• It provides internal insights into system operations but may not be necessary for general use.

• System-generated text appears in blue, while other components' output is displayed in black text.

• The console can be cleared using the red circle button if needed.

Clearing Console and Testing Code

This section covers clearing the console and utilizing it for testing code snippets or executing live code during script execution.

Clearing Console and Testing Code

• The console can be cleared by clicking the red circle button, which erases previous output.

• Testing code snippets or executing live code in the console requires the script to be running.

• The console provides a useful environment for testing specific code segments.

Understanding Full Walk Functionality

The speaker further explains the purpose of the "Full Walk" functionality and clarifies its role in displaying system information and other component outputs.

Full Walk Functionality

• The full walk displays system work and information from various components, not just our script.

• It shows internal details that may not be relevant for general use.

No Need to Sign In for Code Pasting

The speaker addresses a question regarding signing in to paste code and clarifies that it is not necessary.

Signing In for Code Pasting

• There is no need to sign in to paste code into the scripting console.

Semicolon Usage in Interval Statements

The speaker discusses the usage of semicolons in interval statements and clarifies their importance.

Semicolon Usage

• While Visual Studio Code does not require semicolons in interval statements, it is recommended for consistency with other programming languages.

• Semicolons are not mandatory but can be beneficial in certain cases.

Importance of Using Empty Spaces between Commands

The speaker explains when empty spaces should be used between commands within a string and when they are unnecessary.

Using Empty Spaces

• An empty space should be used between keywords like "let" and other code elements to ensure proper recognition.

• Variables or placeholders should be one word without spaces.

• Spaces within strings become part of the string itself when defined between quotes.

New Section

In this section, the speaker discusses the importance of being careful with spaces when using quotes in code and mentions that starting from scratch will be covered in the next lecture.

Using Quotes and Spaces in Code

• Be cautious with spaces when using quotes in code as they become part of the defined string.

• It is important to sort out any confusion with different commands and their usage.

• The speaker skips discussing the use of flat instead of const for now, as it will be covered later.

New Section

This section provides an overview of the upcoming lectures and introduces good practices for using const and let.

Introduction to Good Practices

• The next lecture will delve into more detailed aspects of programming language.

• Good practices for using const and let will be discussed.

• The speaker mentions that older versions of Shelly firmware may not support certain functionalities like const.

• When using const, a variable's value cannot be changed. On the other hand, let allows for variable modification.

• An example is given where changing the value of a variable demonstrates how let works while attempting to modify a constant would result in an error.

New Section

This section explains how to comment code in Shell.

Commenting Code

• To comment a single line, use a double slash (//) before the line.

• For multiple lines, enclose them between slash-star (/*) at the beginning and star-slash (*/) at the end.

• Comments can also be placed before or after code blocks by using slash-star (/*) or star-slash (*/) respectively.

New Section

This section explores different ways to add meaning and explanations to code.

Adding Meaning to Code

• Comments can be used to provide additional context and explanations for code.

• Different methods, such as using single-line comments or block comments, can be employed.

• Commenting after the code or before it is also possible.

• Adding meaningful comments helps with understanding and maintaining the code.

New Section

This section addresses whether the code inside a script runs again automatically and how to make it run again.

Running Code Inside a Script

• Once started, the code inside a script runs only once by default.

• The script continues running but remains idle until manually stopped.

• To make the code run again, special constructs like loops need to be used.

• Stopping an error in the code may require refreshing the browser page.

New Section

This section discusses where commands are saved on the device and provides suggestions for adding comments without consuming excessive memory.

Saving Commands on the Device

• Commands are saved on the device along with the source code.

• It is important to consider memory limitations when adding comments as they consume resources.

• If needed, references to web links can be included instead of lengthy comments.

• Comments help improve understanding for both individual use and when sharing code with others.

How to Stop a Script with an Error

In this section, the speaker explains how to stop a script with an error and continue using it.

• To stop a script with an error, press F5 to refresh the browser.

• Refreshing the page allows you to continue using the script, but you won't be able to see the error message after refreshing.

• To view the error message, check the console in your browser before refreshing.

Using Console for Error Messages

This section discusses how to use the console to view error messages and fix them.

• If you encounter an error while running a script, check the console for the error message.

• After viewing the error message, you can refresh the browser and fix the issue.

• The console is a helpful tool for debugging and troubleshooting scripts.

Continuing with Next Example

The speaker pauses on comments and moves on to explain another example.

• The speaker stops discussing comments temporarily and proceeds with explaining another example.

Printing Numbers from 1 to 10

This section demonstrates how to print numbers from 1 to 10 in JavaScript.

• Create a new script file.

• Write console.log(1) and copy-paste it until console.log(10) for efficiency.

• Save and start running the script. It will display numbers from 1 to 10 in the console.

• Note that console.log is equivalent to print in other JavaScript engines like Shelly device but may not work in all environments like Visual Studio Code with Node.js.

Refreshing and Modifying Running Scripts

This section explains how to refresh and modify running scripts.

• To refresh a running script, stop it, save the changes, and start it again.

• If you save the script while it's running, it will automatically restart.

• The print command can be used instead of console.log, but it may not be supported in all JavaScript engines.

Difference Between console.log and print

This section clarifies the difference between console.log and print.

• In official JavaScript, console.log is used for printing output.

• Some JavaScript engines may support using print instead of console.log.

• However, note that using print is not widely supported and may not work in all environments.

Calculating Square Area

This section demonstrates how to calculate the area of a square given its side length.

• Create a new script file.

• Declare two variables using the let command: one for the side length (site) and another for the area (area).

• Calculate the area by multiplying the side length by itself (site * site).

• Use console.log to display the value of the area in the console.

• Modifying the side length won't automatically recalculate the area; you need to re-run the calculation.

Modifying Variables and Recalculating Area

This section explains how modifying variables affects calculations and how to recalculate areas.

• After calculating an initial area based on a specific side length, modifying that side length won't update or recalculate the area automatically.

• To recalculate the area, modify the side length again and re-run the calculation.

• The new value of the area will be displayed in the console.

Timestamps are approximate and may vary slightly.

Converting Celsius to Fahrenheit

In this section, the speaker explains how to convert temperatures from Celsius to Fahrenheit using a specific formula.

Converting Celsius to Fahrenheit

• To convert temperatures from Celsius to Fahrenheit, use the formula: multiply the Celsius value by 1.8 and then add 32.

• This formula will give you the Fahrenheit value for the temperature.

Working with Decimal Numbers

The speaker demonstrates how to work with decimal numbers in JavaScript.

Example with Decimal Numbers

• Create a variable with the desired Celsius value that you want to convert.

• Multiply the Celsius value by 1.8 and add 32 to calculate the Fahrenheit value.

• JavaScript follows normal mathematical sequence, performing multiplication first and then addition.

Printing Multiple Values on One Line

The speaker explains how to print multiple values on one line using console.log in JavaScript.

Printing Multiple Values on One Line

• Use console.log to print multiple things on one line.

• Separate different sections with commas.

• Mix numbers and strings by converting numbers into strings using quotation marks.

• Use commas between values and they will automatically add spaces between them.

Concatenating Strings

The speaker demonstrates how to concatenate strings in JavaScript.

Concatenating Strings

• Concatenating strings means combining two or more strings together.

• Use the "+" operator or template literals ($) for concatenation.

• You can concatenate static strings with dynamic variables or other string values.

Creating Dynamic Strings

The speaker explains how to create dynamic strings by combining static and dynamic values.

Creating Dynamic Strings

• Use the "+" operator or template literals ($) to create dynamic strings.

• Combine static strings with dynamic variables or other string values.

• This allows you to create more flexible and personalized output.

Overview of String Operations

The speaker provides an overview of string operations in JavaScript.

Overview of String Operations

• String operations involve manipulating and working with strings in JavaScript.

• Concatenation is a common task, where you combine two or more strings together.

• Understanding string operations is essential for handling text-based data effectively.

Creating a Title

In this section, the speaker discusses how to create a title for a greeting.

Creating the Greeting

• The greeting consists of three separate sections: "welcome," the title, and an exclamation mark.

• Each section is treated as a separate string.

• The title is stored in a variable.

• The greeting is created by concatenating the strings using the plus operator.

• The resulting string is displayed on the console.

Concatenating Strings

This section explains how strings are concatenated in JavaScript.

Using the Plus Operator for Concatenation

• Strings can be concatenated using the plus operator (+).

• When concatenating strings, JavaScript combines them into one single string.

• Variables containing strings can also be concatenated with other strings.

• The resulting string contains all the concatenated parts.

Using Push and Concatenate with Numbers

This section discusses using push and concatenation with numbers in JavaScript.

Behavior of Pushing Strings and Numbers Together

• When pushing a string and a number together, they are converted to strings before being concatenated.

• This behavior may cause issues when trying to concatenate strings with numbers.

Enabling Console Output in Visual Studio Code

Here, instructions are provided on enabling console output in Visual Studio Code.

Enabling WebSocket Debugging

• To see console output in Visual Studio Code, WebSocket debugging needs to be enabled.

• Go to settings and enable "Enable WebSocket Debug."

• Without enabling this option, no output will be visible on the console.

Print vs. Console.log in Visual Studio Code

This section explains why print does not work in Visual Studio Code and suggests using console.log instead.

Limitations of Print in Visual Studio Code

• The print function does not work in Visual Studio Code.

• To display output, use the console.log function instead.

Concatenating Strings with and without Spaces

This section compares concatenating strings with and without spaces.

Concatenation Examples

• When concatenating strings without spaces, they are combined into one word.

• When concatenating strings with spaces, each string is printed separately with a space between them.

These are the main topics covered in the transcript.

[t=1:08:39s] Difference between creating a string and printing separate values

In this section, the instructor explains the difference between creating a single string from multiple values and printing separate values.

Creating one string vs. printing separate values

• In the first example, a single string is created by combining three values and then printed.

• In the second example, three separate values are given to the console.log function, which prints them separately with some space in between.

[t=1:09:01s] Visibility of results on the console

The instructor addresses a question regarding the visibility of results on the console.

Refreshing browser for visibility

• If the results were visible once but not anymore, try refreshing your browser.

• The instructor suggests refreshing the browser to see if it resolves any visibility issues.

[t=1:09:11s] Break time and task suggestion

The instructor announces a break and suggests an optional task for participants during the break.

Task suggestion - Calculating area of different shapes

• Participants are encouraged to create a small script to calculate areas of various geometrical shapes such as circles, triangles, or rectangles.

• The instructor provides an example code snippet for calculating circle area using Math.PI.

• Participants can directly use Math.PI or approximate it with 3.14 if desired.

[t=1:10:31s] Providing code snippet for task

The instructor shares a code snippet related to the suggested task during the break.

Code snippet for calculating area

• The instructor posts a small task related to calculating areas of different shapes.

• Participants can refer to this code snippet while working on their own solutions during the break.

[t=1:12:22s] Break ends and addressing questions asked during break

The instructor returns from the break and addresses questions asked during the break.

Console visibility issue resolved

• The instructor confirms that refreshing the browser can resolve the issue of results not being visible on the console.

• Participants are advised to refresh their browsers if they encounter similar issues.

[t=1:13:08s] Monitoring memory status and code correction

The instructor answers questions related to monitoring memory status and corrects a code error.

Monitoring memory status

• Participants inquire about monitoring memory status.

• The instructor explains that it is possible to observe memory status by accessing the IP address of the Shelly device followed by /RPC/CS.getStatus.

Code correction - Capitalization matters

• A participant's solution had an error due to incorrect capitalization.

• The instructor points out that M in Math and P in PI should be capitalized for it to work correctly.

[t=1:15:27s] Clarification on using 'let' command

The instructor clarifies how to use the 'let' command for variable assignment.

Using 'let' command once

• A participant asks if 'let' command needs to be used multiple times when reassigning values to a variable.

• The instructor explains that 'let' command is used only once to define a variable, and later its value can be modified multiple times without redefining it.

[t=1:16:47s] Viewing memory status and executing commands

The instructor provides information on viewing memory status and executing commands.

Viewing memory status

• Participants ask how to view memory status.

• The instructor suggests accessing the IP address of the Shelly device followed by /RPC/CS.getStatus in a browser or executing it from a shell script.

Summary:

This transcript section covers the difference between creating a string and printing separate values, addressing console visibility issues, suggesting a task to calculate areas of different shapes, providing code snippets for the task, resolving console visibility issues after the break, monitoring memory status, correcting code errors related to capitalization, clarifying the usage of 'let' command for variable assignment, and viewing memory status and executing commands.

System Information

The system information includes details about the RAM size and free memory.

• The device has 250 kilobytes of RAM.

• Currently, there is 86,000 bytes of free memory.

File System Information

This section provides information about the file system and available memory.

• The file system size is 956 bytes.

• It shows how much memory is left for storing files and configurations.

• The system status can be accessed through a browser or a Shelley script.

Additional Example with Shelley Script

An additional example using a Shelley script will be added later.

Shared Scripts Memory Issue

There might be an issue with shared scripts causing errors related to type conversion. To resolve this:

• Ensure that you are running the latest beta version of the software.

• Update your firmware through settings firmware.

Implicit Type Conversions and Firmware Version

Older firmware versions have limited capabilities, including implicit type conversions. To address this:

• Update your firmware to the latest beta version.

• As a temporary workaround, try using explicit type conversion in your code (e.g., Circle = 20.0 * math.pi).

Updating Firmware for Memory Issue

It is recommended to update the firmware to resolve any memory-related issues.

Trying Workaround for Memory Issue

A small workaround is suggested by using a specific code snippet. However, it is still advised to update the firmware.

Trying Different Approach for Memory Issue

Another approach is suggested by trying a different value (e.g., 20.0) to avoid implicit type conversions. However, updating the firmware is still recommended.

Testing the Workaround

The suggested workaround can be tested to see if it resolves the memory issue.

Next Example - Calculating Project Completion Time

The next example involves writing a script to calculate how many hours an architect will take to complete multiple construction projects.

• Each project takes three hours to complete.

• Two input parameters are required: architect's name and number of projects.

• The goal is to calculate the total number of hours needed and display this information on the console.

Writing the Script for Project Completion Time Calculation

Steps for writing the script:

• Define variables for architect's name and number of projects.

• Calculate the total number of hours by multiplying the number of projects by three (hours per project).

• Display the information on the console in a specific format.

Conclusion and Final Remarks

The completion time calculation script has been implemented successfully.

Understanding the Script Structure

In this section, the speaker explains the structure of a script and how different elements are represented.

Script Structure

• The script starts with the information about the architect and their name.

• It includes the number of projects multiplied by three as the hours needed to complete them.

• There is a string for "hours to complete" followed by the number of projects.

Using Parameters in Scripts

• The language engine detects parameters within parentheses after calling a function.

• Multiple parameters can be separated by commas.

• White space, including new lines, is considered as part of the code but does not affect its functionality or execution.

Formatting and Organization

• New lines and spaces can be used to improve code readability.

• Adding new lines helps fit the program on one screen for better visibility during coding.

Firmware Update and Running Scripts Simultaneously

This section addresses questions related to firmware updates and running multiple scripts simultaneously.

Firmware Update

• Updating firmware does not delete any stored scripts on the device. Scripts should remain intact after updating.

Running Scripts Simultaneously

• The number of scripts that can run simultaneously on Shelley Port Plus depends on their size and memory usage.

• While there is no exact limit, larger scripts may overload memory and prevent running too many at once.

Continuing with Examples and Answering Questions

The speaker continues with an example involving calculations for repainting a living room. They also answer some additional questions from viewers.

Example - Repainting a Living Room

• Robert wants to repaint his living room and has specific requirements for materials, costs, and additional expenses.

• A script needs to be written to calculate the total cost of repairs based on given prices and additional factors.

• The result should be formatted with two digits after the decimal point.

Answering Viewer Questions

• Firmware updates do not delete stored scripts.

• The number of scripts that can run simultaneously depends on their size and memory usage. There is no exact limit, but larger scripts may cause memory overload.

Implementing the Repainting Script

The speaker demonstrates how to implement the script for calculating the cost of repainting a living room using Visual Studio Code.

Setting Up the Script

• Create a new file in Visual Studio Code named "painting_repainting.js" (or any desired name).

• Define four variables to hold input information: nylon, paint, paint thinner, and hours.

• Assign values to these variables based on the given example or specific requirements.

Understanding Variables

• Variables are used to store and manipulate data in programming.

• In this case, nylon represents the required amount of nylon in square meters, paint represents liters of paint needed, paint thinner represents liters of paint thinner needed, and hours represent the time required by a craftsman to finish the work.

Exploring Visual Studio Code for Debugging

The speaker explains that they will demonstrate an example using Visual Studio Code for debugging purposes.

Example Demonstration

• The example involves calculations for repainting a living room.

• Visual Studio Code is used as an IDE (Integrated Development Environment) for coding and debugging purposes.

• While not necessary for viewers to use Visual Studio Code themselves, it provides insights into working with this development environment.

Defining Integers and Starting Coding Example

The speaker introduces integers and begins coding the example in Visual Studio Code.

Integers

• Integers are whole numbers without decimal points.

• In this context, integers between 1 and 100 are used to represent specific quantities or ranges.

Coding Example

• The speaker demonstrates coding the example using Visual Studio Code.

• The script involves calculations for repainting a living room based on given prices and additional factors.

• Specific variables are initialized and assigned values according to the example's requirements.

Calculation of Material Costs

In this section, the speaker discusses the calculation of material costs for a project.

Calculation of Material Costs

• The total cost for nylon is calculated by multiplying the area by the price per square meter.

• The cost for paint is determined by multiplying the volume by the price per liter.

• The cost for paint thinner is calculated by multiplying the volume by the price per liter.

• The total material cost is obtained by summing up the costs of nylon, paint, and paint thinner.

Calculation of Labor Cost

This section focuses on calculating labor costs for a project.

Calculation of Labor Cost

• The labor cost is determined as 30% of the total material cost multiplied by the number of hours worked.

Variable Definitions and Calculations

Here, variable definitions and calculations are discussed in detail.

Variable Definitions and Calculations

• Variables are defined for nylon area, paint volume, paint thinner volume, and hours worked.

• The amount for nylon is calculated based on its area and price per square meter.

• The amount for paint is calculated by adding 10% to its original price per liter and then multiplying it with the volume.

• The amount for paint thinner is obtained simply by multiplying its volume with 5.

• The total expense is calculated as the sum of all material costs plus an additional amount for bags.

Wage Calculation

This section explains how to calculate wages for a craftsman.

Wage Calculation

• The wage paid to the craftsman is determined as 30% of the total expense multiplied by the number of hours worked.

Displaying the Result

Here, the speaker discusses how to display the calculated expenses.

Displaying the Result

• The total expense is displayed using console.log() with two decimal places.

Rounding Decimal Numbers

This section explains how to round decimal numbers in JavaScript.

Rounding Decimal Numbers

• The toFixed() method is used to convert a number into a string representation with a fixed number of decimal places.

• By providing the desired number of fractional digits as an argument, we can control the rounding behavior.

Running the Script in Visual Studio Code

In this section, the speaker demonstrates how to run a script in Visual Studio Code and explains the process of specifying a JavaScript engine to use. They also mention that Visual Studio Code works on Windows, Linux, and Mac OS.

Running the Script in Visual Studio Code

• To run the script in Visual Studio Code, click on the "Run" button.

• When prompted on how to run it, specify the JavaScript engine to use (e.g., node.js for Visual Studio Code).

• The result of running the script is displayed as 270 727.09.

Running the Script on Shelly Device

The speaker discusses running the same script on a Shelly device and introduces debugging techniques to understand program execution.

Running the Script on Shelly Device

• Copy the code from Visual Studio Code.

• Go to the Shelley web interface and create a new script.

• Paste the code into the editor and save it.

• The code runs successfully on Shelly device as well.

Introduction to Debugging

The speaker introduces debugging as a way to inspect program execution and run it step by step. They explain breakpoints and demonstrate setting breakpoints in Visual Studio Code.

Introduction to Debugging

• Debugging allows you to inspect your program's behavior and run it step by step.

• Breakpoints are used to specify where your program should stop during execution.

• Breakpoints can be set by clicking on line numbers or using shortcut keys (F10).

Setting Breakpoints and Inspecting Variables

The speaker demonstrates how to set breakpoints in Visual Studio Code and inspect variables during program execution.

Setting Breakpoints and Inspecting Variables

• Set a breakpoint by clicking on the line number where you want the program to stop.

• The script will pause at the breakpoint, allowing you to inspect variables and step through the code.

• The debugging window shows the current line of execution and provides information about variables.

• Use the "Watch" section to monitor specific variables of interest.

Debugging Process

The speaker explains how to execute the program step by step using debugging tools in Visual Studio Code.

Debugging Process

• Execute the program step by step using either the "Step Over" button or shortcut key (F10).

• The script executes one line at a time, allowing you to observe each step's outcome.

• The debugging window displays variable values and their changes throughout execution.

Please note that these summaries are based on limited portions of the transcript provided.

[t=1:53:20s] Understanding Variables and Values

In this section, the speaker explains how to view and manipulate variables in a programming environment. They demonstrate how to view variable values by hovering over them with the mouse cursor.

Viewing Variable Values

• The speaker demonstrates how to view variable values by hovering over them with the mouse cursor.

• Different values for variables are shown, such as paint thinner and hours.

• The total calculated value is displayed, but it's important to note that computer calculations may not always be precise due to floating point number representation.

[t=1:55:11s] Handling Calculation Errors

This section discusses the potential errors that can occur during calculations in computer programs, particularly when working with floating point numbers.

Precision of Calculations

• Computers represent floating point numbers in a certain way, which can lead to small calculation errors.

• While there are ways to perform exact calculations for financial purposes, faster methods may introduce errors that need to be taken into account.

[t=1:56:48s] Debugging Code in Visual Studio

The speaker explains how to debug code using Visual Studio's console window and provides tips on finding and fixing mistakes in code.

Using Console Logs for Debugging

• The speaker demonstrates using console logs in Visual Studio for debugging purposes.

• Console logs help track intermediate values and identify mistakes in code.

• By adding console logs at different steps, developers can understand the flow of their code and identify errors.

[t=1:58:39s] Questions and Answers

The speaker addresses some questions from the audience regarding script limitations, data retention during updates, and debugging in Shelly.

Script Limitations and Memory

• There is a limitation on the number of scripts that can be created due to resource constraints.

• The speaker mentions that an official comment will be provided later regarding script limitations and memory usage.

Data Retention during Updates

• It is unclear what happens to history data for devices when updating to a new version. This question should be directed to the outerco team for hardware-related inquiries.

Debugging in Shelly

• The speaker explains that console logs can be used for debugging in Shelly scripts as well, similar to Visual Studio's console window.

Due to limited information provided in the transcript, some sections may not have extensive details.

[t=2:01:59s] Understanding Specific Cases and Using Brackets

In this section, the speaker discusses the importance of being cautious with specific cases when using certain techniques. They recommend getting familiar with using brackets to modify the order of operations.

Specific Cases and Cautionary Approach

• The speaker mentions that while a technique may work fine in generic cases, there are specific cases where one needs to be careful.

• It is recommended to get used to using brackets to modify the default order of operations.

[t=2:02:17s] Removing a Technique

In this section, the speaker acknowledges the need to remove a certain technique.

Removing a Technique

• The speaker agrees to remove a particular technique.

[t=2:02:34s] Clarification on Brackets Usage

In this section, there is some confusion regarding the usage of brackets after each amount.

Clarification on Brackets Usage

• The speaker clarifies that there is no need for brackets after each amount.

• There were some answers and further conversation related to this topic.

[t=2:03:11s] Order of Operations and Bracket Placement

This section focuses on understanding the order of operations and why bracket placement is important.

Order of Operations and Bracket Placement

• The speaker explains that in mathematical calculations, there is a default order of operations defined.

• By using brackets, one can change the default order of operation.

• Without brackets, calculations will follow the default order specified by mathematics.

[t=2:04:21s] Examples for Shell Scripting

This section briefly mentions that there are shell script examples available for reference.

Examples for Shell Scripting

• Some participants have posted shell script examples for others to review.

[t=2:05:00s] Debugging Errors in Shell Console

This section discusses how to debug errors in the shell console.

Debugging Errors in Shell Console

• To debug logical errors, such as incorrect calculations, one can use console.log and check intermediate results.

• If the issue is not clear, placing console.log statements at different points can help identify where the problem occurred.

• In case of division by zero or other similar errors, the speaker suggests opening a new script to demonstrate the error.

[t=2:07:08s] Error Messages and Code Fixing

This section explains how error messages are displayed in the console and how to fix code issues.

Error Messages and Code Fixing

• The console displays error messages indicating what went wrong, including line numbers and column positions.

• Due to a firmware defect, there may be some issues with displaying error messages properly.

• Refreshing the page allows users to go back to their code and fix any identified issues.

[t=2:09:26s] Opening Left Head Cone in Visual Studio Code

This section provides instructions on how to open left head cone in Visual Studio Code.

Opening Left Head Cone in Visual Studio Code

• To open left head cone in Visual Studio Code, click on the fourth icon from the top display button or press Ctrl+Shift+D.

Fish Tank Example

In this section, the speaker introduces a fish tank example and explains how to calculate the amount of water it can hold. The calculations involve parameters such as length, width, height, and a percentage representing occupied space.

Calculating Water Capacity for the Fish Tank

• The fish tank is in the shape of a parallel pipette and was received by Leonardo for his birthday.

• Parameters for the aquarium include length, width, and height.

• The volume of the aquarium is calculated by multiplying these three parameters.

• To convert the volume from cubic centimeters to cubic decimeters (liters), divide it by 1000.

• Certain percentages of the aquarium's capacity are taken up by sand, points, a heater, and a pump.

• Calculate the effective volume of water needed to fill the aquarium by subtracting the percentage of occupied space from 1 and multiplying it with the total volume.

Implementing the Calculation in Shelley

• Define variables for length, width, height, and percentage of occupied space.

• Calculate the volume in cubic centimeters using length * width * height.

• Convert the volume to cubic decimeters (liters) by dividing it by 1000.

• Divide the percentage value by 100 to get its decimal representation.

• Calculate the total liters needed using volume * (1 - percent).

• Format and display the result with one digit after the decimal point.

Debugging Variable Modifications

• Use Visual Studio Code to debug variable changes during calculation steps.

• Set breakpoints at specific lines to observe variable values at different stages.

The remaining part of this transcript does not contain relevant information for note-taking purposes.

Calculating Volume and Percentage

In this section, the speaker explains how to calculate volume in cubic decimeters and convert percentages to a decimal format for calculations.

Calculating Volume

• The value given in cubic centimeters is divided by 1000 to calculate the volume in cubic decimeters. Link to timestamp

• After the calculation, the volume is recalculated as 299.625 cubic decimeters. Link to timestamp

Converting Percentages

• Whole numbers representing percentages need to be converted into a decimal format between zero and one for calculations. Link to timestamp

• The percentage is modified accordingly, making it suitable for further calculations. Link to timestamp

Displaying Liters

• The calculated volume is shown as 248.68875 liters. Link to timestamp

• To display only one digit after the decimal point, the "toFixed" method with a parameter of 1 is used, resulting in 248.7 liters being displayed. Link to timestamp

Mathematical Functions

• Various mathematical functions such as absolute value, cosine, sine, etc., can be utilized for different calculations. These functions are available in libraries like "Math" or can be found online. Link to timestamp

Required Plugins for Java Development in Visual Studio Code

In this section, the speaker discusses the required plugins for Java development using Visual Studio Code.

• No specific plugins are needed for Java development in Visual Studio Code.

• JavaScript debugging is already included as part of Visual Studio Code.

• When debugging a new file for the first time, it may prompt for the debugger to use, and Node.js should be selected.

• To debug JavaScript in Visual Studio Code, Node.js is required. Link to timestamp

Visual Studio Code Version and Download

In this section, the speaker addresses questions related to the version of Visual Studio Code being used and how to download it.

• The speaker is using the latest version of Visual Studio Code (Visual Studio 2022). It is important to note that there is a difference between Visual Studio Code and Visual Studio.

• To download Visual Studio Code, users can visit the official website or search for it online. Link to timestamp

Executing RPC Calls with Shelly Device Protected by Password

In this section, the speaker explains how to execute RPC calls with a password-protected Shelly device using different web browsers.

• When accessing a password-protected Shelly device through Chrome or Edge browsers, an error (HPR 401) may occur due to authentication issues.

• One workaround is to use Firefox browser, where users will be prompted for a username (admin) and password (device password).

• Chrome and Edge browsers do not support certain authentication methods required for accessing password-protected devices. Link to timestamp

Timestamps are provided wherever available in the transcript.

[t=2:29:12s] Setting up HTTP Admin Password

In this section, the speaker explains how to set up an HTTP admin password for a device.

Steps to Set Up HTTP Admin Password

• Start by writing "HTTP-" followed by "admin" and your desired password. For example, if your password is "password," write "HTTP-admin:password."

• You can either let the browser ask you for a username and password or have it open automatically.

• Note that using Chrome or Edge browsers may not work with devices that have password protection. Firefox is recommended.

• Leave the RPC over UDP field empty as it is unrelated to these steps.

[t=2:31:24s] Deposit Calculator Example

This section covers an example of a deposit calculator, explaining the formula and input parameters required.

Deposit Calculator Example

• t=2:31:24s The goal is to calculate the amount received at the end of a deposit period with a given interest rate.

• t=2;31;51ss The formula for calculating the amount is deposited amount + (term of deposit * positive amount * interest rate / 12).

• Three input parameters are needed:

• Deposited amount

• Term of deposit in months

• Annual interest rate

• The result should be printed on the console with two digits after the decimal point.

[t=2:36:55s] Calculating the Price of Greening a Yard

This section introduces an example of calculating the price for greening a yard.

Calculating the Price of Greening a Yard

• The task is to calculate the amount needed to pay a contractor for greening a yard.

• The price per square meter is fixed at 761 units.

• There is an 18% discount on this price.

• Initialize one variable, which represents the square meters to be landscaped.

• Calculate the final price and display it with two digits after the decimal point, along with showing the discount.

Timestamps are provided in English.

Counting the Number of Items

The speaker counts the number of items they have, which is 10, and realizes that it is the limit. They decide to delete some items.

Counting the Items

• The speaker counts their items and finds that they have a total of 10.

• They realize that this is the limit and decide to delete some items.

Calculating Yard Cost

The speaker discusses calculating the cost of a yard based on its area in square meters. They mention an example with an area of 550 square meters and a cost of $761 per square meter.

Yard Area Calculation

• The yard area is measured in square meters.

• An example is given with an area of 550 square meters.

Calculating Yard Cost

• The cost per square meter is $761.

• To calculate the total cost, multiply the garden area by the cost per square meter.

Discount Calculation

• A discount needs to be calculated.

• Multiply the total cost by 18% (0.18) to get the discount amount.

Final Cost Calculation

• Subtract the discount from the total cost to get the final cost.

Wrapping Up Algorithmic Examples

The speaker concludes algorithmic examples that involve calculations rather than Shelly functionality. They emphasize practicing these types of calculations in order to create scripts for apps APIs and algorithms.

Importance of Algorithmic Examples

• Algorithmic examples are essential for creating scripts.

• Scripts interact with app APIs and perform various algorithmic tasks.

Turning On/Off Shelly Device

The speaker demonstrates how to turn on and off a Shelly device using RPC methods. They explain the RPC protocol and provide an example of setting the switch on or off.

Using RPC Methods

• The RPC protocol is used to communicate with the Shelly device.

• RPC methods are executed through shelly.com.

Setting the Switch On/Off

• To turn on the switch, set the "on" field to true.

• To turn off the switch, set the "on" field to false.

Script for Turning On/Off Shelly Device

The speaker creates a script to communicate with the Shelly device and turn it on/off. They explain how to use the Shelly.call function and provide an example of turning on/off a switch.

Communicating with Shelly Device

• Use Shelly.call function to communicate with the Shelly device.

• Provide two parameters: method and configuration object.

Setting Switch Configuration

• Use switch.set method to set the switch configuration.

• Specify ID 0 for our device's switch.

• Set "on" field as true to turn it on.

Changing Device Color

• Change colors in Shelly device configuration settings.

• Set off color as red and on color as blue.

Testing Script

• Save and call the script.

• The Shelly device should change its cover color accordingly.

Executing Code with Comments

In this section, the speaker demonstrates how to execute code with comments in order to test different functionalities. The code is written in a way that only certain parts will be executed while others are grayed out and not executed.

Executing Code with Comments

• By adding two slashes (//) at the beginning of a line, it becomes a comment and will not be executed.

• Only the lines without comments will be executed.

• This allows for testing different scenarios and functionalities.

• The speaker demonstrates turning off a switch using this method.

Toggling Switches

In this section, the speaker explains how to toggle switches on and off using different methods.

Toggling Switches

• It is possible to toggle switches by checking their current status and deciding whether to turn them on or off.

• Alternatively, there is a special method called toggle that can be used without knowing the current state of the switch.

• By calling toggle with just the ID of the switch, it will change its state to the opposite of what it currently is.

• The speaker demonstrates toggling switches using both script execution and through a web browser by making an API call.

Using Shelly Call Toggle Method

In this section, the speaker explains how to use the Shelly.callToggle method to toggle switches without needing additional information about their current state.

Using Shelly Call Toggle Method

• The Shelly.callToggle method can be used by providing only the ID of the switch as an argument.

• This method does not require any other information because it automatically changes the state of the switch to the opposite of what it currently is.

• The speaker demonstrates using this method to toggle switches and shows how the device turns on and off accordingly.

Toggling Switches via Web Browser

In this section, the speaker explains how to toggle switches using a web browser by making an API call.

Toggling Switches via Web Browser

• It is possible to toggle switches by making an API call through a web browser.

• By accessing the URL your_device_IP/RPC/switch.toggle, with the ID of the switch as a parameter, it will toggle its state.

• The speaker demonstrates this method and mentions that it can be used for other commands as well.

Getting Shelly ID

In this section, the speaker explains how to retrieve the unique ID of a Shelly device.

Getting Shelly ID

• Each Shelly device has a unique ID.

• The speaker mentions that the ID can be found in the device information settings but does not show it directly in this example.

• To retrieve the device info, Shelly.getDeviceInfo is called, which returns information about the device.

• Due to some current limitations, JSON.parse needs to be used before extracting specific information from deviceInfo.

• The speaker demonstrates retrieving and displaying only the ID from deviceInfo.

Displaying Device Info with JSON Parsing

In this section, the speaker demonstrates how to display device information by parsing JSON data.

Displaying Device Info with JSON Parsing

• To display device information, Shelly.getDeviceInfo is called.

• Due to current limitations, JSON.parse needs to be used before extracting specific information from deviceInfo.

• The speaker demonstrates using console.log to display the device information, including the ID.

Reviewing Device Info

In this section, the speaker reviews the device information and showcases various fields available in deviceInfo.

Reviewing Device Info

• The speaker reviews the device information displayed using console.log.

• Multiple fields are present in deviceInfo, including the name and ID of the device.

• The speaker points out that there was a typo in the code but proceeds to explain the structure of deviceInfo.

The transcript does not provide further sections or timestamps beyond this point.

Firmware Version and Device ID

This section explains how to extract the firmware version and device ID from a Shelly device.

Extracting Device ID

• To extract the device ID, use the following code: console.walk device info.ID.

• The device ID will be displayed as part of the returned object.

• Example output: "Device ID is Shelley postbook."

Extracting Firmware Version

• The firmware version can be obtained using the same method as extracting the device ID.

• Example output: "Firmware version is Gen 2."

Getting Current Script ID

This section demonstrates how to retrieve the current script ID in Shelly devices.

• Use the API Shelly.getCurrentScriptID to get the current script ID.

• Print the script ID using console.log("Current script ID is", scriptID).

• Example output: "Current script ID is 3."

Changing Color of Shelly Device

This section explains how to change the color of a Shelly device's LED cover.

• Use the RPC code poorgas_UI.setConfig to set different configuration parameters for the LED cover.

• Create a special configuration object with desired color settings. Refer to documentation for structure details.

• Change colors by modifying specific fields in the configuration object.

• Example task: Change Switched Off state color to Black and Switched On state color to Green.

Defining Configuration Object for Color Change

This section covers defining a configuration object for changing colors of a Shelly device's LED cover.

• Define a config object similar to the one specified in the documentation.

• Define all necessary fields and embedded objects within the config object.

The transcript continues with further details, but this summary provides an overview of the main topics covered.

Configuring LEDs on Switch Zero

In this section, the speaker explains how to configure the LEDs on switch zero using the Shelley API.

Configuring LED Colors

• The speaker starts by explaining that they have pores and want to configure the LEDs on switch zero.

• They mention that they will use the Shelley API to perform this configuration.

• The first step is to specify the ID of the switch, which in this case is switch zero.

• Next, they explain that they want to configure the LEDs and their colors.

• They clarify that these steps can be performed on multiple switches if needed, but for this example, they only have one switch (switch zero).

• To modify the colors of a specific state (in this case, when it's on), RGB values need to be specified.

• The RGB values consist of three numbers representing red, green, and blue values respectively.

• The numbers should be between 0 and 100 inclusively. Values above 100 won't change the color.

• After specifying the RGB values for when it's on, brightness can also be provided as a percentage (0 to 100).

Setting Lights with Shelley API

In this section, the speaker demonstrates how to set lights using the Shelley API.

Calling Shelley API

• The speaker mentions that now they will call the Shelley API to set the lights.

• They provide an example command: UI.setConfig.

• The configuration that needs to be changed is stored in a variable called config.

• Once executed, turning on the device should result in a blue light.

Modifying Off State Color

In this section, the speaker explains how to modify the color of the off state.

Modifying Off State Color

• The speaker explains that they want to change the off state color as well.

• They mention that after specifying the on state colors, a comma can be used to specify different colors for the off state.

• The RGB values for the off state are set to make it red (100, 0, 0).

• The brightness is also set to 100.

• After making these changes, both on and off states will have different colors.

Controlling Switch Covers

In this section, the speaker discusses how switch covers can be controlled using special RPC APIs.

Generating Random Lights for On State

• The speaker mentions that they will show an example of generating random lights for the on state.

• To achieve this, they use the Math.random function along with rounding and multiplication operations.

• By multiplying Math.random() by 100 and rounding it, a random number between 0 and 100 is generated.

• This process is repeated for each RGB value (red, green, blue) to generate random colors.

Timestamps are not available for some parts of the transcript.

Changing Colors of the Device

The speaker demonstrates how to change the colors of a device using different values.

Changing Colors

• Different color values are shown, such as 45, 93, and 62.

• The speaker explains that certain values appear more white while others appear more green.

• This example showcases how colors can be randomly changed on a device.

Wrapping Up Examples Session

The speaker concludes the examples session and prepares to answer questions.

Conclusion

• The speaker mentions that they will now move on to answering questions.

• Due to time constraints, only a limited number of questions can be addressed.

• Complicated questions will be answered quickly but may require further explanation later.

Creating a Script for Memory Information

The speaker discusses creating a script to retrieve memory information from the device.

Script for Memory Information

• The speaker mentions their previous demonstration of retrieving memory information using the "get" command.

• They plan to create a script specifically for retrieving memory information.

• However, they realize that explaining callback functions is necessary before proceeding with the script.

Using Web Browser to Detect Free Memory

The speaker suggests using a web browser to detect free memory until they can provide a script for it.

Detecting Free Memory

• To determine available free memory, the speaker suggests calling HTTP sys.get_status_rpc/system_get_status.

• They acknowledge that there might be existing code or examples related to this topic.

• Callback functions are mentioned as being important for understanding and implementing this feature effectively.

Delaying Switch Off After Switching On

The speaker addresses a question about introducing a delay between switching on and switching off.

Delaying Switch Off

• The speaker confirms that it is possible to introduce a delay before switching off.

• They mention that timers can be used for this purpose.

• However, they note that the current knowledge level may not be sufficient to implement this feature yet.

Finding Different Methods of Switches

The speaker explains how to find different methods available for switches.

Finding Switch Methods

• To find different switch methods, the speaker instructs the audience to access the documentation page.

• In the documentation, under "Device Stop," users can select their specific device (in this case, Shelley Postbook).

• By exploring the switch section, users can discover various RPC methods supported by the switch component.

Exploring Documentation for Switch Component

The speaker demonstrates how to access and explore documentation related to the switch component.

Accessing Documentation

• Within the documentation page, users can navigate to their specific device (Shelley Postbook in this case).

• The switch component is opened as an example.

• Users can see different RPC methods supported by the switch, such as switch.set.

• Each method's request parameters are explained in detail.

Using Documentation for Device Support Information

The speaker highlights how documentation provides information about device support and capabilities.

Device Support Information

• Users can access comprehensive information about their device's capabilities through documentation.

• By selecting their device from the documentation page (Shelley Postbook), they can view supported features and components.

• For example, the switch component supports features like LEDs, RGB values, and brightness ranges.

Utilizing Snippets for Ready-to-Use Code

The speaker explains how to use snippets to quickly insert ready-to-use code into scripts.

Using Snippets

• Snippets provide pre-written code for specific functionalities.

• Users can access snippets by clicking on the "Snippets" link in the development environment or script section.

• Within the snippets, users can find examples related to switches and other components.

• Clicking on a snippet will insert the corresponding code into the script.

Activating Another Device with Shelly Commands

The speaker addresses a question about activating another device using Shelly commands.

Activating Another Device

• The speaker confirms that it is possible to activate another device from their own device using Shelly commands.

• They mention that this can be done through HTTP calls, similar to using a web browser.

• Further details and demonstrations regarding this topic will be covered later in the course.

[t=3:22:09s] Introduction and Finding Commands

The speaker introduces the topic and mentions that the commands like "not round" can be found by searching for them in the mathematical Library. They suggest using URLs to find more information about different methods available. They also mention a command to check how much memory is left.

Finding Commands

• Use URLs to find more information about different methods in the mathematical Library.

• There is a command to check how much memory is left.

[t=3:24:13s] Wi-Fi Switching and Script Example

The speaker addresses a question about switching between Wi-Fi and Wi-Fi 2. They explain that Wi-Fi 2 acts as a backup for Wi-Fi 1, but demonstrate how to simulate controlling which Wi-Fi network is used by turning off one and turning on the other. They provide a script example for reference.

Simulating Wi-Fi Switching

• To control which Wi-Fi network is used, turn off one network and turn on the other.

• A script example demonstrates how to switch between Wi-Fi networks programmatically.

[t=3:27:11s] Node.js Installation and Visual Studio Code

The speaker answers a question regarding Node.js installation for working with Visual Studio Code. They mention that Node.js needs to be installed separately from Visual Studio, and provide reference links for installing Node.js on Macintosh.

Node.js Installation

• Install Node.js separately from Visual Studio Code.

• Reference links are provided for installing Node.js on Macintosh.

[t=3:28:16s] Next Topic and Agenda

The speaker concludes the session and mentions that the next topic will be Shelly scripting introduction. They clarify that they will discuss more about the Java language itself, including variables, expressions, and calculations.

Next Topic and Agenda

• The next topic is Shelly scripting introduction.

• The speaker will cover the implementation of the Java language, including variables, expressions, and calculations.