<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>Blog on Ekorau LLC</title>
    <link>https://www.ekorau.com/posts/</link>
    <description>Recent content in Blog on Ekorau LLC</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>© 2020–2026 Ekorau LLC · [Privacy](/privacy/)</copyright>
    <lastBuildDate>Fri, 13 Oct 2023 11:00:00 -0700</lastBuildDate><atom:link href="https://www.ekorau.com/posts/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Some numbers</title>
      <link>https://www.ekorau.com/some-numbers/</link>
      <pubDate>Fri, 13 Oct 2023 11:00:00 -0700</pubDate>
      
      <guid>https://www.ekorau.com/some-numbers/</guid>
      <description>I was checking an old hard drive backup when I came across a webpage I posted in 1998 of benchmark results, for various Smalltalk implementations run on a 166MMX Pentium desktop computer (typical for the time).
The benchmark was published by the Smalltalk Industry Council (no longer in existence) and all I did was tweak the source to compare available Smalltalk implementations and Java.
The page is reproduced here.
Out of curiosity, I tweaked the code to run in Toit on an ESP32-WROOM-32E, which yielded the following numbers:</description>
    </item>
    
    <item>
      <title>Using TFTP</title>
      <link>https://www.ekorau.com/using-tftp/</link>
      <pubDate>Wed, 12 Apr 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.ekorau.com/using-tftp/</guid>
      <description>Recently I posted on using MQTT to collect air quality data from an IKEA VINDRIKTNING air quality sensor. The WiFi around my house appears to be subject to numerous, brief interruptions, causing problems for the TCP connection MQTT maintains between client and gateway. For the devices that need to deep-sleep, MQTT-SN is used, but it would preferable to use a single protocol for both wall and battery powered devices.
Trivial File Transfer Protocol (TFTP) offers a connectionless transport for file transfer, with a single outstanding response/request handshake over UDP.</description>
    </item>
    
    <item>
      <title>Interfacing to an IKEA VINDRIKTNING air sensor</title>
      <link>https://www.ekorau.com/interfacing-to-an-ikea-vindriktning-air-sensor/</link>
      <pubDate>Wed, 08 Mar 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.ekorau.com/interfacing-to-an-ikea-vindriktning-air-sensor/</guid>
      <description>Posted as a &amp;lsquo;Show and tell&amp;rsquo; on Toit Discussions, Interfacing to an IKEA VINDRIKTNING air sensor, including source and a video demonstration.</description>
    </item>
    
    <item>
      <title>Power consumption, revisited</title>
      <link>https://www.ekorau.com/power-consumption-revisited/</link>
      <pubDate>Sat, 04 Mar 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.ekorau.com/power-consumption-revisited/</guid>
      <description>About a year and a half ago I posted about the power consumption observed running Toit on the ESP32 Huzzah. Since then, there have been a couple of developments that significantly reduce power consumption.
Deep sleep The first, was support for deep sleeping the ESP32 while not being used.
In a lot of typical programs, the code starts, runs some initialization, then enters a potentially indefinite while true: loop where you do some task, then long sleep.</description>
    </item>
    
    <item>
      <title>Using websockets to update a browser page</title>
      <link>https://www.ekorau.com/using-websockets-to-update-a-browser-page/</link>
      <pubDate>Fri, 18 Nov 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.ekorau.com/using-websockets-to-update-a-browser-page/</guid>
      <description>Posted as a &amp;lsquo;Show and tell&amp;rsquo; on Toit Discussions, Using websockets to update a browser page, including source.
A counter is updated on button clicks, without refreshing the page:
This technique was used in the Fuzzy Logic project to directly manipulate the fuzzy model inputs on the ESP32, via an onboard webserver:</description>
    </item>
    
    <item>
      <title>A tank level simulation and control</title>
      <link>https://www.ekorau.com/a-tank-level-simulation-and-control/</link>
      <pubDate>Wed, 09 Nov 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.ekorau.com/a-tank-level-simulation-and-control/</guid>
      <description>I posted a &amp;lsquo;Show and tell&amp;rsquo; on Toit Discussions, A tank level simulation and control, including source and a demonstration video.</description>
    </item>
    
    <item>
      <title>Creating a library, using Jaguar</title>
      <link>https://www.ekorau.com/creating-a-library-using-jaguar/</link>
      <pubDate>Sun, 16 Oct 2022 01:00:00 -0001</pubDate>
      
      <guid>https://www.ekorau.com/creating-a-library-using-jaguar/</guid>
      <description>The original post on creating a Toit Library was written a year ago, when Toit was only offered as closed source. Since then, the Toit language has been open sourced and Jaguar tooling added. An update of the original article, using Jaguar v1.7.1 to revise and run the project FW_Keyboard was posted as a Show and tell on Toit Discussions.</description>
    </item>
    
    <item>
      <title>Reporting data from a sleepy device</title>
      <link>https://www.ekorau.com/reporting-data-from-a-sleepy-device/</link>
      <pubDate>Fri, 14 Oct 2022 01:00:00 -0001</pubDate>
      
      <guid>https://www.ekorau.com/reporting-data-from-a-sleepy-device/</guid>
      <description>I posted a &amp;lsquo;Show and tell&amp;rsquo; on Toit Discussions, Reporting data from a &amp;lsquo;sleepy&amp;rsquo; device, including source and demonstration video.</description>
    </item>
    
    <item>
      <title>Porting a Fuzzy Logic library to Toit</title>
      <link>https://www.ekorau.com/porting-a-fuzzy-logic-library-to-toit/</link>
      <pubDate>Tue, 07 Dec 2021 01:00:00 -0001</pubDate>
      
      <guid>https://www.ekorau.com/porting-a-fuzzy-logic-library-to-toit/</guid>
      <description>A while ago I used to design utility boiler control systems. Before machine learning (ML), there was a lot written in the control journals about fuzzy systems, but for me most of the articles were deeply theoretical and unapproachable. Recently there has been some comment that although the ML models are highly effective, they are largely opaque to inspection. That sparked my interest in fuzzy logic again, as fuzzy logic (FL) enables observed knowledge of system behaviour to be captured in rules and linguistic terms &amp;hellip; &amp;ldquo;if it is hot, then run the fan fast&amp;rdquo; &amp;hellip; and thus why the controller was running the fan fast could be deduced.</description>
    </item>
    
    <item>
      <title>An example of creating a Toit library</title>
      <link>https://www.ekorau.com/an-example-of-creating-a-toit-library/</link>
      <pubDate>Thu, 09 Sep 2021 11:00:00 -0001</pubDate>
      
      <guid>https://www.ekorau.com/an-example-of-creating-a-toit-library/</guid>
      <description>(updated Oct 29, to reflect CLI v1.14.0)
(updated Dec 22, to reflect CLI v1.17.0)
I have written a couple of toy applications in Toit and wanted to create a library for the Solder Party Keyboard FeatherWing. Following the Package quick start guidance I could not get the source to compile. The Toit team responded on Slack and got me going, so although the Toit documentation should be considered definitive, the following notes may be useful to some.</description>
    </item>
    
    <item>
      <title>Monitoring a switch, in Toit</title>
      <link>https://www.ekorau.com/monitoring-a-switch-in-toit/</link>
      <pubDate>Tue, 24 Aug 2021 11:00:00 -0700</pubDate>
      
      <guid>https://www.ekorau.com/monitoring-a-switch-in-toit/</guid>
      <description>The purpose of this trivial sample is to better understand how to write power efficient code in Toit. Warning, as is, it is not power efficient.
For a device to be able to operate without a battery change for a year, requires careful consideration of the power consumption of sensors, peripherals, power supply, processor and radio used. Modern processors, with a multitude of subsystems, have various sleep states with some combination of features and power.</description>
    </item>
    
    <item>
      <title>Power profiling the ESP32, running Toit</title>
      <link>https://www.ekorau.com/power-profiling-the-esp32-running-toit/</link>
      <pubDate>Mon, 16 Aug 2021 11:00:00 -0700</pubDate>
      
      <guid>https://www.ekorau.com/power-profiling-the-esp32-running-toit/</guid>
      <description>Updated 2021-09-14, see below
The temperature-humidity sensor that I wrote about here only has a battery life of several days on a 1200 mAh LiPo battery, making any usage longer than a test impractical. As originally configured, the data acquisition application ran every 15 minutes and the &amp;ldquo;Max offline&amp;rdquo; time was 17 minutes.
To understand the power consumption, the Nordic Semiconductor Power Profiler Kit II (PPK II) was connected to the breadboard, as shown in the photo:</description>
    </item>
    
    <item>
      <title>Serial interface to DYP-AO1 ultrasonic sensor, with Toit</title>
      <link>https://www.ekorau.com/serial-interface-to-dyp-ao1-ultrasonic-sensor-with-toit/</link>
      <pubDate>Sun, 15 Aug 2021 11:00:00 -0700</pubDate>
      
      <guid>https://www.ekorau.com/serial-interface-to-dyp-ao1-ultrasonic-sensor-with-toit/</guid>
      <description>An inexpensive way to measure longer distances is with an ultrasonic sensor, fitted with a horn, such as the DYP-A01. Range is nominated at 0.28-7.5m and the sensor has serial and PWM outputs. The serial connection is used in this sample, at 9600 baud. The sample app runs periodically, to range the distance and exit. Triggering of a measurement is possible, by driving the sensor RX line, but not implemented here.</description>
    </item>
    
    <item>
      <title>Measuring the Heat Index, with Toit</title>
      <link>https://www.ekorau.com/measuring-the-heat-index-with-toit/</link>
      <pubDate>Sun, 01 Aug 2021 11:50:45 -0700</pubDate>
      
      <guid>https://www.ekorau.com/measuring-the-heat-index-with-toit/</guid>
      <description>I live in Phoenix and they like to say “it’s a dry heat” when it is 117F (47C). However, less is said during the monsoon season (officially Jun 15 – Sep 30), when it might only be get to 105F but with high humidity. As I write this, it is 104F with a 30% relative humidity. According to the National Oceanic and Atmospheric Administration (NOAA), that is dangerous. Why? Because humans use evaporative cooling (sweat) to cool, and sweating becomes less efficient as the humidity climbs.</description>
    </item>
    
    <item>
      <title>First device driver in Toit</title>
      <link>https://www.ekorau.com/first-device-driver-in-toit/</link>
      <pubDate>Fri, 28 May 2021 11:50:45 -0700</pubDate>
      
      <guid>https://www.ekorau.com/first-device-driver-in-toit/</guid>
      <description>Toit is a language for embedded development on microcontrollers, targeting the ESP32. Like CircuitPython or TinyGo, language libraries provide access to microcontroller peripherals and developers are insulated from the OS. Toit goes significantly further, by addressing device onboarding/lifecycle, monitoring and fleet management, with both a command line and web console interfaces.
Programming on the device is in the Toit language, including drivers for devices connected over SPI or I2C, as described in the Write a driver guide.</description>
    </item>
    
    <item>
      <title>Wren as a CoAP handler</title>
      <link>https://www.ekorau.com/wren-as-a-coap-handler/</link>
      <pubDate>Mon, 09 Nov 2020 11:50:45 -0700</pubDate>
      
      <guid>https://www.ekorau.com/wren-as-a-coap-handler/</guid>
      <description>The Try Wren page allows you to execute Wren scripts directly in your browser, reducing the barrier to try language features and syntax, to zero. To emulate this simplicity in the IoT environment, the Constrained Application Protocol (CoAP) was leveraged to provide a lightweight RESTful protocol to a target board, the Adafruit Feather nRF52840 Express.
From the CoAP website, “The Constrained Application Protocol (CoAP) is a specialized web transfer protocol for use with constrained nodes and constrained networks in the Internet of Things.</description>
    </item>
    
    <item>
      <title>Wren on a nRF52840 ... does it fit?</title>
      <link>https://www.ekorau.com/wren-on-a-nrf52840-...-does-it-fit/</link>
      <pubDate>Thu, 05 Nov 2020 11:50:45 -0700</pubDate>
      
      <guid>https://www.ekorau.com/wren-on-a-nrf52840-...-does-it-fit/</guid>
      <description>Writing software for a microcontroller is significantly different than writing for other desktop, mobile, web or server platforms. There is large choice in chip vendor, chip architectures and operating systems with usually severe resource constraints. Likely because of this, there is no well developed application model, like there is say on mobile with iOS and Android. This leads to developers being responsible for the full software stack.
Several approaches have been taken to reduce the developer burden, including Arduino and CircuitPython, where for supported set of boards you can program in derivatives of Processing or Python languages.</description>
    </item>
    
  </channel>
</rss>
