Installing Ollama is a one-line command:

curl -fsSL https://ollama.com/install.sh | sh

Running a model is also a one liner:

ollama run gemma3

It includes a local server service that can be managed with:

sudo systemctl start ollama
sudo systemctl stop ollama

https://docs.ollama.com/quickstart

Open WebUI

While you can use Ollama from the command line, I prefer the Open WebUI interface. It’s essentially ChatGPT-style interface but fully self-hosted, fully local, and beautifully designed.

If you have non-technical family members or want a quick chat interface, Open WebUI is perfect. It remembers conversation history, handles formatting beautifully, and feels like using a cloud service, except everything stays on your own hardware.

It can be easily run in a Docker container:

docker run -d --network=host -v open-webui:/app/backend/data -e OLLAMA_BASE_URL=http://127.0.0.1:11434 --name open-webui --restart always ghcr.io/open-webui/open-webui:main

https://github.com/open-webui/open-webui

Home Assistant integration

Here’s where Ollama gets really interesting for home automators: Home Assistant has official integration with Ollama. I’ve set up my Home Assistant to use an Ollama model as a conversation agent, part of the voice assistant controlling the devices in my home.

https://www.home-assistant.io/integrations/ollama/

Local LLMs are improving rapidly

My current favorite is now GLM-4.7-flash. On my mini PC with an integrated GPU, it generates amazing responses in about one minute. Models that were unusable six months ago are now competitive with far more expensive options.

Cloud LLMs with Ollama

Here’s what I didn’t realize: Ollama added cloud hosting in September, with the exact same interface as local models. Same API, same CLI, same simplicity, just running on their infrastructure. They offer:

• Free tier: Great for evaluation and light use
• $20/month tier: Reasonable for regular personal use
• $100/month tier: For heavier workloads and teams

If you have a Raspberry Pi (or any modest device), the cloud option means you can run advanced models that would never fit in 2GB of RAM. The same ollama run command works across both local and cloud.

Enterprise-Grade privacy

Unlike other cloud LLM services, Ollama emphasizes enterprise-grade privacy. Your data isn’t used for training, and they offer compliance features that other services simply don’t have.

For me as a telecommunication engineer working with sensitive systems, this is a major advantage over alternatives like OpenAI or Anthropic.

Launching AI coding agents

Ollama can launch Claude Code, Codex or OpenCode, i.e.:

ollama launch claude --model qwen3-coder-next:cloud

Each of these works with any local model or cloud model.

OpenClaw integration

OpenClaw is the newest sensation in the AI agent world: https://openclaw.ai/

OpenClaw does not include a setup assistant for Ollama, and the config file is a bit tricky, but you can simply run:

ollama launch openclaw --model kimi-k2.5:cloud

Ollama generates the OpenClaw configuration and starts it.

I’m running OpenClaw in a Docker environment without access to my personal data, be careful, there are lots of security concerns.

https://openclaw.ai

The bottom line

Ollama is the easiest, most flexible, and most privacy-respecting way to run local and cloud LLMs today. The fact that it offers cloud options without forcing you to use them is amazing.

The downside: You do not have access to the top GPT or Opus closed models.

The post Ollama: The easiest way to run local and cloud LLM models appeared first on Alberto Ruibal.

I used a Yi Camera for several years, but their mobile app is overloaded with ads constantly pushing their cloud video storage services. I cannot recommend Yi or any other vendor whose business model relies on selling inexpensive cameras just to lock you into their cloud services. I also played with ESP-CAM (and a ESP32-S3-CAM), but the video quality is not enough (MJPEG, low framerate, no night vision…).

For devices as senstitive as cameras, I cannot trust closed firmware or Wi-Fi. Both are explotable security holes. I also can’t trust any camera vendor’s cloud service.

So my requirements were:

• Open source firmware.
• Ethernet only, no Wi-Fi.
• Ceiling mount.
• Power over Ethernet (PoE) to simplify the setup in the ceiling.
• Night vision.
• No vendor cloud service.
• RTSP streams for self-hosted recording services (I use Frigate).
• H.265 support to save storage, but I ended up using H.264 because Telegram doesn’t support H.265.
• On camera motion detection.

It is quite hard to find cameras that clearly show their chipset in the listing. Finally I bought an inexpensive Vanhua FJZ OEM camera from Aliexpress.

After opening the camera, the board didn’t match the images of the Aliexpress listing, so I thought it was a scam, but the camera is OK, the listing is outdated.

Camera specs

• Chipset: Ingenic T31X (should be enough for H.265 and basic motion detection)
• Sensor: GC4653 5 MP (with the resolution for 5 MP the image is distorted, I willl use QHD 2560×1440, 3.6 MP)
• Flash: 16 MB
• Connectivity: Ethernet only
• Power: PoE, 48 V
• Storage: No SD card
• Metal housing

Why switch firmware?

The camera shipped with an unreliable Chinese firmware. For example, viewing video through a browser required a plugin that didn’t work on Linux or Mac. So I decided to install Thingino (https://thingino.com/).

OpenIPC was another option, but Thingino seemed better maintained and feature-rich. However, Thingino isn’t perfect: There are bugs, and updates are frequent. Fixing bugs requires SSH access and manual edits.

Installing the firmware

Installing Thingino isn’t straightforward. You need to disassemble the camera and follow the steps in the Thingino wiki.

Some notes from my experience:

• I had to make a pogo-pin connector for the serial port.
• The camera has two serial ports. I lost a lot of time because I was trying to connect to the wrong one.
• The bootloader is locked. There is a clever trick to access it, triggering an error by shorting two pins of the flash chip during the boot sequence, so it fails to read the kernel .
• Firmware is uploaded via the serial port using ymodem (it is very slow, it reminded me of the BBS days).

The correct serial port and the pins to short during boot:

Accessing the camera

By default, the camera obtains an IP via DHCP.

• Web interface: http://<camera_ip>
• SSH: ssh root@<camera_ip> (default password: root, you’ll be prompted to change it on first login)

Configuring streams

In the web interface under Settings → Streamer/OSD, you can configure two streams:

• Main: I’m using 2560×1440 30 FPS H.264 15000 kbps
• Substream: For previews or motion detection. I set it to 640×360 10 FPS H.264 1000 kbps

Stream settings are saved in /etc/prudynt.json.

RTSP URLs:

• Main: rtsp://thingino:thingino@<camera_ip>:554/ch0
• Substream: rtsp://thingino:thingino@<camera_ip>:554/ch1

These streams can be used from recording apps like Frigate or tested from Linux using ffplay <stream_url>.

Motion detection

Motion detection is enabled from the web interface by clicking the person icon or from Services → Motion Guard. It was not working with the default settings because there were no secondary stream.

Thingino supports simple motion detection with rectangular zones defined in JSON. I think that the original chinese firmware had better detection options. But I will use Frigate for advanced detection options.

On motion detection Thingino has a lot of notification options:

• Email
• FTP
• MQTT
• Telegram
• Webhooks
• Ntfy.sh

Telegram is particularly useful as it sends notifications to the phone and can store video clips (for free!).

Some configuration quirks:

• The file /etc/prudynt.json stores motion detection settings under a “motion” object.
• The Send to Telegram option sometimes fails to save from the web UI. I needed to manually set "send2telegram": true.
• Motion triggers the script /sbin/motion, which has a bug: it starts a video recording and calls /sbin/send2telegram, which tries to start another recording and fails. I needed to comment out the redundant recording call in /sbin/motion.

Publishing to Telegram

To enable Telegram notifications:

1. Create a bot with @BotFather.
2. Create a channel and make the bot an administrator.
3. Enter the bot token and channel ID in the Thingino web interface: Tools → Send to Telegram.

By default, /sbin/motion tries to send a photo and video to Telegram. This did not work in this camera, and I needed to change the call to /sbin/send2telegram clip to send only the video.

Another drawback is that the Telegram app does not support playing H.265 videos, the main stream needs to be set to H.264.

Telegram bot

The bot can also respond to commands from authorized users to send live snapshots or video clips. Enable it in the web interface under Services → Telegram bot, and modify the wrong default actions to run binaries in /sbin/ instead of /usr/bin/.

Final thoughts

Installing Thingino on this camera is a rewarding but technical process. You gain better control and privacy, but it requires patience and careful troubleshooting. I will need another post to explain the Frigate setup.

The post Installing Thingino on a Vanhua FJZ camera appeared first on Alberto Ruibal.

I continue to learn what it means to be a father, and it’s proving to be as complicated as I had imagined.

I’m not active on social media, and after the collapse of Twitter, I’ve been trying to revive my activity here on the blog.

On the professional front, I made the decision to leave Netcentric, where I worked for the past five years. I had a great time there, and it was a tough decision, but an exciting new opportunity came my way. I left the AEM consultancy world to join Alén Space, a company focused on building satellites. I now work on their Mission Control System software. So, while I’m still pursuing my career as a Java developer, I’m also taking on a more managerial role, leading a developer team.

In another change, after seven years of working with a Mac, I’m back on Linux—and I’m very happy about it. I also replaced my old home lab Dell T3500 workhorse with a sleeker Minisforum UM890 Pro, and it’s been amazing. For my home office setup, I’ve also switched back to OpenWRT with a Xiaomi AX3000T (with WiFi 6). I had forgotten how easy it is to configure OpenWRT.

This has also been a great year for my home automation journey. I started the year by moving Home Assistant to a small and efficient Orange Pi 3B. I’m extremely happy with the combination of Home Assistant and ESPHome. Home Assistant has become an essential part of our daily routine, mainly for climate control and air quality monitoring.

On a personal note, we moved from an apartment in the city back to our country house. This means more commuting, but it also means more comfort and a better school for our little one. I was disappointed by Santiago de Compostela—it’s turning into a theme park focused solely on tourism.

Finally, I replaced my 20-year-old diesel car with an electric one. I would have switched sooner if I had known just how great and affordable electric cars are. I chose a Tesla primarily for its price-to-technology ratio. I’m not a fan of the brand or their CEO, but the car has made living in the country much cheaper.

Happy 2025!

The post 2024 appeared first on Alberto Ruibal.

Probably, iPhone users do not know that it is really easy to physically track them.

Apple’s “Find My” network was launched in 2019 and the AirTag in 2021. The AirTag emits BLE beacons with a public key that, when received by another Apple device, are sent along with the location of the device that received them to Apple servers, encrypted with the AirTag public key. The information on the Apple servers needs to be decrypted with the AirTag’s private key.

However, when the AirTag location is updated, the owner of the AirTag also knows that there is an Apple device nearby.

In theory it’s required to have an iPhone/iPad/iPod to activate an AirTag, but it’s very easy to build an AirTag clone with ESP32.

The Macless Haystack project, based on the original OpenHaystack, provides:

• The python utility to generate AirTag key pairs
• The firmware to flash an ESP32-WROOM-32 and convert it to an AirTag clone
• An Android app to check the location of your fake AirTags
• Two Docker containers needed to retrieve the info from the Apple servers, they need to be accesible by the Android app

And, of course, I built my own one:

These ESP clones are much bigger than AirTags but they are ok to track cars, suitcases or bags. There is a PR to the Macless Haystack repo alowing to use an ESP32-C3 Supermini, that makes a smaller device with a better battery duration.

Google launched the “Find My Device” network in April 2024, and the tags supporting it (i.e. the Chippolo Point or the Pebblebee) are slowly reaching the market. But the default security option only shares the location information if there are other Android devices nearby. That is much better for the privacy of Android device owners, but much worse for the owners of the tags.

So, if you own an Android device, it is still better to use AirTag clones, abusing the lack of privacy of the Apple devices.

The post Abusing Apple’s Find My network appeared first on Alberto Ruibal.

But the Mitrastar needed to be factory reset every 6 months because it had some problems with the DHCP in my network. Recently, I offloaded the DHCP to an OrangePi 3B, but now my home network was relying too much on the availability of this device. Also, the Mitrastar is starting to show its age without features like WiFi 6…

A couple of weeks ago I found on Aliexpress a new Xiaomi AX3000T router. It has an amazing set of specs:

• 2 ARMv8 cores @ 1.3GHz (MediaTek MT7981B)
• 128 MB ROM
• 256 MB RAM
• WiFi 6 (AX) in the 2.4 GHz and 5 GHz bands

And it’s compatible with the lastest snapshot of OpenWrt:

https://openwrt.org/inbox/toh/xiaomi/ax3000t

I was able to get it during the AliExpress ChoiceDay (this happens the first days of each month) for 26 EUR (including a 4 EUR coupon).

When it arrived, I found it a bit smaller than what I expected, and I liked its minimalist look. It has only one button for WPS (+ the reset pinhole), and one LED in the front panel (i.e. it does not have LEDs on the ethernet ports).

Everything was in Chinese, but it’s easy to read it using the Google Translate camera, only for the steps necessary to set up OpenWrt. I did a simple installation without the U-Boot boot loader.

So, I put again an OpenWrt router back in my home network moving the DHCP and WireGuard services to the router. I had forgotten the beauty and simplicity of OpenWrt.

I also tested adblock-lean and it works quite well on the router with big lists like https://oisd.nl/: It’s able to manage the 660K domains of both oisd big and osid nsfw lists. But at the moment I’ll continue using the Pi-hole on the OrangePi. I still need the OrangePi to run Home Assistant and the NAS.

The post Back to OpenWrt appeared first on Alberto Ruibal.

I wanted to add an LCD screen to my CO2 sensor, so I bought a white LCD 1602 with an I2C controller. The I2C controller needs to be soldered to the LCD, but my basic soldering skills were sufficient for the task.

I also wanted to place it in a box, so I purchased this plastic enclosure but I cannot recommend it. It required a lot of glue from a glue gun to install the LCD and the ESP. I also had to use the soldering iron to create space for the ESP and a hole for the USB connector. I installed the plastic buttons but they are only decorative.

I made room for the sensors inside the box, but finally left them outside because they are more precise that way.

The ESP32-WROOM-32 was too large for the enclosure, so I used a ESP32-C3 Supermini with an expansion board. This is a really amazing board with a 32-bit RISC-V 160MHz microcontroller, WiFi, Bluetooh, I2C and UART. It’s not as powerful as the ESP32-WROOM-32 with a dual core 32-bit Xtensa 240Mhz, but it’s more than capable to control the sensors and the LCD.

This is the ESPHome configuration, which includes a switch to control the LCD backlight and a clock synchronizing the time with Home Assistant:

esphome:
  name: co2sensor
  friendly_name: CO2 Sensor

esp32:
  board: esp32-c3-devkitm-1
  framework:
    type: arduino

logger:
  level: ERROR

api:
  password: ""

ota:
  platform: esphome
  password: ""

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  reboot_timeout: 90s
  ap:
    ssid: ${friendly_name} Hotspot
    password: !secret wifi_password

captive_portal:

web_server:
  port: 80

debug:

time:
  - platform: homeassistant
    id: homeassistant_time
    timezone: "Europe/Madrid"

uart:
  rx_pin: GPIO20
  tx_pin: GPIO21
  baud_rate: 9600

i2c:
  sda: GPIO8
  scl: GPIO9

sensor:
  - platform: uptime
    name: Uptime
    filters:
      - lambda: return x / 60.0;
    unit_of_measurement: minutes

  - platform: wifi_signal
    name: "WiFi signal sensor"
    update_interval: 60s

  - platform: dht
    model: AM2302
    pin: GPIO10
    temperature:
      id: "dht22_temperature"
      name: "DHT22 Temperature"
    humidity:
      id: "dht22_humidity"
      name: "DHT22 Humidity"
    update_interval: 50s

  - platform: mhz19
    co2:
      id: "mhz19_co2"
      name: "MH-Z19 CO2"
    temperature:
      id: "mhz19_temperature"
      name: "MH-Z19 Temperature"
    update_interval: 60s
    automatic_baseline_calibration: false

display:
  - platform: lcd_pcf8574
    dimensions: 16x2
    address: 0x27
    update_interval: 1s
    lambda: |-
        auto time =  id(homeassistant_time).now();
        it.printf(11, 0, "%02d:%02d", time.hour, time.minute);
        it.printf(11, 1, "%02d/%02d", time.day_of_month, time.month);
        auto co2 = id(mhz19_co2).state;
        if (!isnan(co2)) {
          it.printf(0, 0, "%.0fppm", co2);
        }
        it.printf(0, 1, "%.1fC", id(dht22_temperature).state);
        it.printf(6, 1, "%.0f%%", id(dht22_humidity).state);

switch:
  - platform: gpio
    pin: GPIO7
    name: "LED Backlight"
    id: led_backlight
    restore_mode: ALWAYS_OFF

And the full BOM:

• ESP32-C3 Supermini
• Expansion board
• MH-Z19B CO2 sensor
• AM2302 temperature and humidity sensor 
• White LCD 1602 with an I2C controller
• 10cm female-female Dupont cables
• Plastic enclosure

The post CO2 sensor with LCD and ESP32-C3 Supermini appeared first on Alberto Ruibal.

It’s measured in ppm (parts per million), indicating how many parts of CO2 there are in one million parts of air. As a reference:

• Less than 1000 ppm are healthy levels
• Between 1000 ppm and 2000 ppm, we need to reduce the CO2 levels
• Levels greater than 2000 ppm are associated with headaches, sleepiness, poor concentration, loss of attention…

To reduce the CO2 level, we need to ventilate the room. It can be manually done (opening the windows) or it can be automated with a ventilation system.

To measure it we need a proper CO2 sensor, and one of the most reliables sensors is the MH-Z19B. It is not cheap for the Aliexpress standards (it costs around 20 EUR), but other cheap sensors announced as “air quality” sensors or “eCO2” sensors are not really measuring the CO2 level (i.e. the MQ135).

I bought this MH-Z19B from Aliexpress and hooked it to an ESP32-WROOM-32 board. This board is going to be also purposed as a temperature and humidity sensor, so I also attached a DHT22 sensor. I bought this DHT22 sensor but it is not an original one, and the measures do not seem very correct, so I ordered again an original AM2302 (=DHT22). The MH-Z19B includes a temperature sensor, but it’s mainly used for calibration and it lacks precision, as it does not report decimals. I’m also using an expansion board to simplify the connections.

• The jumper in the expansion board needs to be set to 5V (because both of these sensors need 5V).
• Connected VCC and GND of both sensors to the expansion board
• Connected the RX and TX of the MH-Z19B to the TX and RX (GPIO1 and GPIO3) of the ESP
• Connected GPIO16 to the DAT of the DHT22

Finally, I installed ESPHome to the board with this configuration:

substitutions:
  devicename: co2sensor
  friendly_name: CO2 sensor

esphome:
  name: ${devicename}
  friendly_name: ${friendly_name}
  platform: ESP32
  board: nodemcu-32s

logger:

api:
  password: ""

ota:
  password: ""

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  reboot_timeout: 90s
  ap:
    ssid: ${friendly_name} Hotspot
    password: !secret wifi_password

captive_portal:

web_server:
  port: 80

debug:

time:
  - platform: homeassistant
    id: homeassistant_time

uart:
  rx_pin: GPIO3
  tx_pin: GPIO1
  baud_rate: 9600

sensor:
  - platform: uptime
    name: Uptime
    filters:
      - lambda: return x / 60.0;
    unit_of_measurement: minutes

  - platform: wifi_signal
    name: "WiFi signal sensor"
    update_interval: 60s

  - platform: dht
    model: DHT22
    pin: GPIO16
    temperature:
      id: "dht22_temperature"
      name: "DHT22 Temperature"
    humidity:
      id: "dht22_humidity"
      name: "DHT22 Humidity"
    update_interval: 60s

  - platform: mhz19
    co2:
      id: "mhz19_co2"
      name: "MH-Z19 CO2"
    temperature:
      id: "mhz19_temperature"
      name: "MH-Z19 Temperature"
    update_interval: 60s
    automatic_baseline_calibration: false

And It’s working nicely, this is the ESPHome web interface:

Keeping the CO2 levels under control is helping me create a healthier workplace environment and improve performance.

The post MH-Z19B CO2 sensor appeared first on Alberto Ruibal.

The heating system is in a different builng than the router and I was experiencing some WiFi coverage issues (the WiFi signal needs to cross two metallic window blinds…).

To diagnose the WiFi coverage is very useful the wifi_signal sensor in ESPHome:

sensor:
  - platform: wifi_signal
    name: Wifi Signal
    update_interval: 60s

It was showing a WiFi signal of -95 dBm in the board: This is very low, and it was experiencing some disconnections.

Usually the ESP32 boards have an antenna integrated in the board, but the ESP32-WROOM-32U has an IPEX connector for an external antenna:

So, I spent less than 10 EUR in Aliexpress buying (affiliate links):

• ESP32-WROOM-32U module
• IPEX to SMA 2.5 dBi external antenna
• Expansion board that makes screwing the ESP32 to the wood mount much easier and simplifies the connections

And replaced the previous ESP32-WROOM-32 module with an ESP32-WROOM-32U, installing the external antenna. This is how it looks now:

The WiFi signal shown in ESPHome increased from -95 dBm to –75 dBm and it’s no longer experiencing any interruptions.

The post Improving WiFi reception with an ESP32-WROOM-32U appeared first on Alberto Ruibal.

The first challenge was to open it without breaking it. I was able to open it by wrapping it in cardboard and gently tapping it with a hammer around the body.

You never know what chip you are going to find. In the past ESP8266 was very common but now they switched mainly to Beken chips. This smart switch has a T102_V1.1 board with a Realtek RTL8710BX chip:

Luckily the support for this chip was developed in the LibreTiny project:

https://github.com/libretiny-eu/libretiny

And now it’s integrated into ESPHome:

https://esphome.io/components/libretiny

This is the board:

https://fcc.report/FCC-ID/2AU7O-T102V11/4540736.pdf

And after investigating the outputs, I reached this conclusion about them:

ESPHome

I created one device this config in the ESPHome dashboard (without power monitoring, read below if you want to enable it):

substitutions:
  devicename: smartplug1
  friendly_name: Smart Plug 1

esphome:
  name: ${devicename}
  friendly_name: ${friendly_name}

rtl87xx:
  board: wr2
  framework:
    version: 1.5.1

logger:

api:
  password: ""

ota:
  password: ""

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  ap:
    ssid: ${friendly_name} Fallback Hotspot
    password: !secret wifi_password

captive_portal:

web_server:
  port: 80

status_led:
  pin:
    number: PA5
    inverted: true

text_sensor:
  - platform: libretiny
    version:
      name: LibreTiny Version

sensor:
  - platform: uptime
    name: Uptime
    filters:
      - lambda: return x / 60.0;
    unit_of_measurement: minutes

  - platform: wifi_signal
    name: Wifi Signal
    update_interval: 60s

binary_sensor:
  - platform: gpio
    device_class: power
    name: Button
    pin:
      number: PA18
      mode: INPUT_PULLUP
      inverted: true
    on_press:
      - switch.toggle: relay

switch:
  - platform: gpio
    id: relay
    name: ${friendly_name}
    pin: PA15
    restore_mode: RESTORE_DEFAULT_OFF

There is currently an open bug in LibreTiny and with the board t102-v1.1 the PA15 output does not work, so I needed to use the board wr2 on line 10.

I built it from the ESPHome dashboard and downloaded a .uf2 file.

Connecting an USB UART to the chip

I soldered four dupont cables to VDD, GND, GPIO_A29 and GPIO_A30 connecting them to an FTDI232 USB UART:

While connected to the FTDI232, the log from the chip can be viewed, i.e. with minicom (but remember to disable hardware flow control):

minicom -D /dev/ttyUSB0 -b 115200

Flashing

The official flashing guide does not recomment to power the chip with the USB flasher, but it worked for me:

https://docs.libretiny.eu/docs/platform/realtek-ambz/#flashing

You need the ltchiptool tool, I installed it in a Python virtualenv:

python3 -m venv .
source bin/activate
pip install ltchiptool zeroconf

The ltchiptool GUI caused some segmentation fault, so I used it from the commmand line.

To put the chip in flash mode, we need to power it with the TX pin connected to GND.

In flash mode, I created a backup of the previous firmware:

ltchiptool flash read realtek-ambz flash-backup.bin

And to write the ESPHome firmware:

ltchiptool flash write smartplug1.uf2

After the flashing, if I try to power it from USB the WiFi module did not start and it causes a boot loop, but It worked perfectly plugging it into the mains power. A new device appeared in the router and I can connect to the ESPHome web dashboard.

Adding power metering

The plug includes a power metering chip: the BL0936, that is supported by ESPHome:

https://esphome.io/components/sensor/hlw8012.html

However, after configuring and uploading the firmware with the power meter enabled to the board, the device enters a boot loop, displaying the following error:

[D][switch:016]: 'Smart Plug 1' Turning OFF.
[D][binary_sensor:034]: 'Button': Sending initial state OFF
[C][hlw8012:014]: Setting up HLW8012...
W [      0.109] CHANGE interrupts not supported

Luckily, after 10 reboots, the firmware enters in the “OTA safe mode”, disabling all the modules and connecting to the WiFi without the web dashboard but opening a port to allow remote flashing.

https://esphome.io/components/ota.html

It is a problem in the combination of the RTL8710 chip and the BL0936 module, there is an open issue about this:

https://github.com/libretiny-eu/libretiny/issues/155

It can be fixed with the workaround of SuperXL2023 modifying the .esphome/platformio/platforms/libretiny/cores/realtek-amb/arduino/src/wiring_irq.c file and adding the lines 64 and 65:

62: #if LT_RTL8720C
63:                        event = IRQ_FALL_RISE;
64: #elif LT_RTL8710B
65:                        event = IRQ_RISE;
66: #else
67:                        LT_W("CHANGE interrupts not supported !!!!!!");

In the ESPHome config I’m specifying the version of the framework to avoid losing this fix in an automatic update. It works perfectly after rebuilding the image with this fix and uploading it to the device.

This is the complete ESPHome configuration with power metering:

substitutions:
  devicename: smartplug1
  friendly_name: Smart Plug 1

  voltage_divider: "1400"
  current_resistor: "0.001"
  current_multiply: "1.0"

esphome:
  name: ${devicename}
  friendly_name: ${friendly_name}

rtl87xx:
  board: wr2
  framework:
    version: 1.5.1

logger:

api:
  password: ""

ota:
  password: ""

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  ap:
    ssid: ${friendly_name} Fallback Hotspot
    password: !secret wifi_password

captive_portal:

web_server:
  port: 80

status_led:
  pin:
    number: PA5
    inverted: true

text_sensor:
  - platform: libretiny
    version:
      name: LibreTiny Version

sensor:
  - platform: uptime
    name: Uptime
    filters:
      - lambda: return x / 60.0;
    unit_of_measurement: minutes

  - platform: wifi_signal
    name: Wifi Signal
    update_interval: 60s

  - platform: hlw8012
    model: BL0937
    sel_pin:
      number: PA14
      inverted: true
    cf_pin:
      number: PA0
    cf1_pin:
      number: PA12

    current:
      name: Current
      filters:
        - multiply: ${current_multiply}
    voltage:
      name: Voltage
    power:
      name: Power
    energy:
      name: Energy

    update_interval: 30s
    current_resistor: ${current_resistor}
    voltage_divider: ${voltage_divider}

binary_sensor:
  - platform: gpio
    device_class: power
    name: Button
    pin:
      number: PA18
      mode: INPUT_PULLUP
      inverted: true
    on_press:
      - switch.toggle: relay

switch:
  - platform: gpio
    id: relay
    name: ${friendly_name}
    pin: PA15
    restore_mode: RESTORE_DEFAULT_OFF

It needs to calibrate the sensor to obtain the proper values of voltage_divider, current_resistor and current_multiply. It can be done with a multimeter and entering the values in the hlw8012 page.

The post ESPHome in a RTL8710BX smart plug appeared first on Alberto Ruibal.

I always used OpenVPN in my servers, but now WireGuard is a better option:

https://www.wireguard.com/

• It’s simpler
• It’s more efficient
• It’s faster
• It uses modern cryptography algorithms

I’m using it to remotely access private services in my home server. I setup a star topology, where all the VPN clients connect to the home server and they can only see the server.

So I need a dynamic DNS and an open port in the router, I already have them for Home Assistant.

Eloy Coto recommended Tailscale, it is an amazing mesh VPN based in WireGuard. It’s much simpler to set up, and you do not need to open public ports, but it’s commercial and a bit overkill for my needs.

Generating the WireGuard configurations

The most tedious part of WireGuard is to generate the configurations, but there are some nice tools to ease that, like:

https://www.wireguardconfig.com/

The tool generates the configuration for the server and for the requested number of clients. It does everything in the frontend, so it is not leaking the VPN keys.

As I’m only acessing the server, I have removed the IP forwarding options in the Post-Up and Post-Down rules.

Installing and configuring the WireGuard server

WireGuard is in the official Ubuntu repos, so to install it in the server it’s enough to do:

sudo apt install wireguard

Then I needed to put the config in the /etc/wireguard/wg0.conf file and do:

sudo systemctl enable wg-quick@wg0.service
sudo systemctl start wg-quick@wg0.service

Installing and configuring the clients

WireGuard has clients for almost any OS:

https://www.wireguard.com/install/

To setup the client in the phones, the WireGuard Config web tool generates QR codes. In other devices you’ll need to create a file with it or paste the config contents.

Using Pi-hole from the VPN clients

To use the Pi-hole hosted in the same VPN server from the VPN clients, you can specify a DNS property in the client config, i.e. if the server is 100.100.1.1 and the client is 100.100.1.2:

[Interface]
PrivateKey = <client-private-key>
Address = 100.100.1.2/32
DNS = 100.100.1.1

[Peer]
PublicKey = <server-public-key>
PresharedKey = <preshared-key>
Endpoint = <my-home-server>:51820
AllowedIPs = 0.0.0.0/0, ::/0
PersistentKeepalive = 25

Every time that you connect the VPN, the DNS server in the client changes to 100.100.1.1 and it is reverted to the previous DNS server when the VPN is disconnected.

Additionally, Pi-hole needs to be listening in the wg0 interface, I explained how to make Pi-hole listen on multiple interfaces in the Pi-hole post.

The post WireGuard appeared first on Alberto Ruibal.

ChatGPT was launched in November 2022, and it changed our world as we knew it. Since then, Large Language Models (LLMs) have integrated into our daily workflows enhancing our productivity and the quality of our work.

Another interesting milestone happened in February 2023, when Meta released the Llama LLM under a noncommercial license:

https://llama.meta.com

This sparked the enthusiasm among numerous developers dedicated to advancing LLMs, leading to a increase in collaborative efforts and innovation within the field. A good example is the Hugging Face Model Hub where new models are constantly published:

https://huggingface.co/models

Developers started creating improved models and optimizing performance for local execution of LLMs on consumer-grade hardware.

Llama.cpp is a port of Llama to C++, started in March 2023 with a strong emphasis on performance and portability. It includes a web server and an API:

https://github.com/ggerganov/llama.cpp

Mistral 7B was released in October 2023, achieving better performance than larger Llama models and demonstrating the effectiveness of LLMs in compressing knowledge.:

https://huggingface.co/papers/2310.06825

And now it’s easier than ever to locally execute LLMs, especially since November 2023, with the Llamafile project that packs Llama.cpp and a full LLM into a multi-OS single executable file:

https://github.com/Mozilla-Ocho/llamafile

It’s even possible to run LLMs in a Raspberry Pi 4, like the TinyLlama-1.1B used from a llamafile in this project:

https://github.com/nickbild/local_llm_assistant

And about using LLMs for code generation (Github’s Copilot has been available since 2021), there are IntelliJ plugins like CodeGPT (with its first release in February 2023) that now allows you to run the code generation against a local LLM (running under llama.cpp):

https://github.com/carlrobertoh/CodeGPT

Google is a bit late to the party. In December 2023 they announced Gemini. In February 2024, they launched the Gemma open models, based on the same technology than Gemini:

https://blog.google/technology/developers/gemma-open-models

They also released a gemma.cpp inference engine:

https://github.com/google/gemma.cpp

And finally, if you are lost among so many LLM models, an interesting resource is the Chatbot Arena, released in August 2023. It allows humans to compare the results from different LLMs, keeping a leaderboard with chess-like ELO ratings:

https://chat.lmsys.org

And according to this leaderboard, at the moment GPT-4 is still the king.

The post The LLM revolution appeared first on Alberto Ruibal.

https://www.home-assistant.io/integrations/google_assistant/

But something that seems trivial, like publicly accessing services in your home server, has some complications, and you usually need to worry about dynamic IPs and security.

What do we need:

• An ISP not using CG-NAT
• Redirect ports in the router
• A dynamic DNS provider and a client to update the IP (or a static IP)
• An SSL certificate to securely access the HTTP services

ISP providers with CG-NAT

Some ISPs use CG-NAT (Carrier-Grade NAT), sharing the same IPv4 among multiple customers. In that case the only way to expose your services is using reverse proxy services such as ngrok.

Ngrok allows you to generate one static domain and it also automatically generates a SSL certificate, so most steps in this post do not apply.

My ISP (O2 Spain) assigns me a dynamic IP, and I prefer to not rely on these reverse proxy services, so I remotely access my home server redirecting ports in the router.

Dynamic DNS provider

Usually, and unless you have a static IP service (not very common, and not available in my ISP), you need to setup a dynamic DNS service.

I have been using the free Now-DNS service for years:

https://now-dns.com/

And to update the IP in my home server, I setup ddclient with this /etc/ddclient.conf file:

ssl=yes
protocol=dyndns2
daemon=60
mail=root                               # mail all msgs to root
mail-failure=root                       # mail failed update msgs to root
pid=/var/run/ddclient.pid               # record PID in file.
use=web, web=now-dns.com/ip             # get ip from server.
server=now-dns.com                      # default server
login=<your-login>
password=<your-password>
server=now-dns.com,<your-dynamic-domain>

Some of these dynamic DNS domains are blocked in the Pi-hole blocking lists, so, if you are using Pi-hole or other DNS blocking service, you’ll probably need to whitelist your domain.

SSL certificate

With the amazing Certbot you can obtain free SSL certificates:

https://certbot.eff.org/

There is extensive documentation in the Certbot site about how to use it. I simply install certbot from apt and do a:

certbot certonly --webroot -w /var/www/html/ -d <your-dynamic-domain> --email <my-email> --non-interactive --agree-tos

But in order to make that work, you need a domain name (available from the dynamic DNS provider in the previous section).

HTTP Server

And to verify that the domain points to your server, Certbot is going to do an HTTP request to that domain, so you also need to have an HTTP server in the port 80 and open the port 80 in the router. This is also needed for the certificate renewals.

You may encounter numerous attacks on this port, so it is crucial to have a reliable web server that is consistently updated and properly configured. I personally use nginx as my HTTP server, and it has never failed me so far.

Home Assistant

To use the SSL certificate from the HA container, we need to share the folder where certificates are stored passing a “-v /etc/letsencrypt:/etc/letsencrypt” to the docker command and setting in the HA configuration.yaml:

http:
  ssl_certificate: /etc/letsencrypt/live/<your-dynamic-domain>/fullchain.pem
  ssl_key: /etc/letsencrypt/live/<your-dynamic-domain>/privkey.pem

You can also use your public HA URL to remotely access it and to configure in the HA Android application.

The post Opening Home Assistant to Internet appeared first on Alberto Ruibal.

I’ve never been a fan of the Raspberry Pi. In my opinion, it occupies an intermediate position where it is too underpowered for desktop use and too overpowered for IoT projects:

• To use them as a desktop, there are great X86 alternatives available at about the same price than a RPi 5 but much more powerful, such as the Intel N100.
• And for IoT projects, the ESP32 is the king, with amazing boards with Wifi, Bluetooth, etc., all at a price of less than 5 euros.

So it’s place may be TV boxes (where I prefer a Chromecast with Android) or small servers where the power consumtion is important because they are always on.

I bought an Orange Pi 3B: 4 cores, 4GB RAM, 64GB eMMC (~50 euros in Aliexpress) to replace my old X86 home server (Intel N450: 2 cores, 2 GB RAM, 64GB SSD):

http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/Orange-Pi-3B.html

The Orange Pi 3B shares the form factor with the Raspberry Pi 3B but it is almost as powerful as the Raspberry Pi 4. Notably, the Orange Pi 3B comes with several advantages over the RPi 4:

• Support for eMMC (much faster and reliable than SD cards)
• A power button
• A full-size HDMI port
• External antenna
• And it’s cheaper

I installed the Ubuntu Jammy server image in the eMMC following the OPi manual. It needs to use a USB-A male to USB-A male cable and the RKDevTool (it’s in Chinese) that runs only in Windows.

And, as this machine is going to be exposed to internet, I hardened a bit the security:

• Changed the APT repositories to ports.ubuntu.com
• Regenerated SSH server keys
• Removed SSH root access
• Changed passwords
• Renamed the orangepi user
• Removed the local autologin

To remove the local autologin we need to edit:

• /lib/systemd/system/getty@.service.d/override.conf: For the display console autologin
• /lib/systemd/system/serial-getty@.service.d/override.conf: For the serial console autologin

[Service]
ExecStartPre=/bin/sh -c 'exec /bin/sleep 10'
ExecStart=
ExecStart=-/sbin/agetty --noissue --autologin orangepi %I $TERM
Type=idle

Removing the “–autologin orangepi”. If you rename the orangepiuser but you want to keep the autologin, you’ll also need to change the username here.

Then I moved the docker containers and other services from my old X86 server:

• Home Assistant (docker container)
• ESPHome dashboard (docker container)
• Pi-hole (docker container)
• nginx (for certbot and DNS DoT for Pihole)
• certbot (to maintain the SSL certificate for Home Assistant)
• ddclient (dynamic DNS updater)
• NAS (do not expect anything fancy, I access a USB disk via SSH, it’s enough for Kodi & backups)

Everything seems to work smoothly now.

The post Orange Pi 3B appeared first on Alberto Ruibal.

I encountered numerous issues with my network provider’s router DHCP. Since I haven’t yet decided to acquire another router, I opted to offload the DHCP server to another machine, which is currently running my Home Assistant and NAS.

I was in search of a DHCP server with a web UI. During my exploration, I came across Pi-hole, a DNS server specifically designed to block DNS queries to domains that serve ads and do tracking. Interestingly, Pi-hole also incorporates an integrated DHCP server (dnsmasqd) that can be configured through its admin UI.

https://pi-hole.net/

I presume the integration of the DHCP server aimed to simplify the setup of clients’ DNS servers, yet it proves highly convenient for home networks. And forget about the “Pi” in the name, it can be run in any linux server, not necessarily in a Raspberry Pi.

I’m still an addict to running everything in Docker containers. So I set up the Docker Pi-hole container (https://github.com/pi-hole/docker-pi-hole) using this script localed at /usr/local/pihole/docker.sh:

#!/bin/bash 
cd $(dirname $(readlink -f $0))
docker stop pihole
docker rm pihole
docker pull pihole/pihole:latest
docker run -d \
	--name pihole \
	--privileged \
	--restart=unless-stopped \
	--network=host \
	-e TZ=Europe/Madrid \
        -e FTLCONF_LOCAL_IPV4=192.168.1.2 \
        -e WEB_PORT=8081 \
	-e WEBPASSWORD=admin \
	-e INTERFACE=eth0 \
	-e DNSMASQ_USER=root \
	-v ./etc-pihole:/etc/pihole \
	-v ./etc-dnsmasq.d:/etc/dnsmasq.d \
	--cap-add=NET_ADMIN \
	pihole/pihole:latest
docker image prune --all

• Every time that you run the script, it updates the container with the last Pi-hole version
• It didn’t work without setting FTLCONF_LOCAL_IPV4 to the local IP
• I needed to set up WEB_PORT to not override with the nginx running in that machine (for Certbot)
• Setting WEBPASSWORD is the easiest way to initially setup an admin password
• I couldn’t make the DHCP server work with port mappings, it needed a –network=host
• There is an image prune at the end to save space by removing old docker images

I also had some problems because Ubunt’s systemd-resolved includes a DNS server, and I needed to disable it:

https://askubuntu.com/questions/907246/how-to-disable-systemd-resolved-in-ubuntu

And of course, you need to disable also the DHCP server on the router, it’s a very bad idea to have two DHCP servers working in the same network…

It is now functioning smoothly, and the included ad-blocking feature is a definite plus. Although it doesn’t currently block ads on YouTube and Twitch, its still great.

I’m also using it in my phone with a Wireguard VPN (it maybe a topic for another post). To make it listen in multiple interfaces like in the local and the VPN interfaces, I needed to create a /usr/local/pihole/etc-dnsmasq.d/99-interfaces.conf adding there:

interface=lo
interface=wg0

Another similar alternative worth exploring is AdGuard Home, but I haven’t had the time to test it yet:

https://adguard.com/en/adguard-home/overview.html

The post Pi-hole as home DNS and DHCP server appeared first on Alberto Ruibal.

ESP32 board with ESPHome

I connected the boiler to a ESP-WROOM-32 board via a relay module. The box and the cables were more expensive than the board (~10 EUR) and the relay module (~5 EUR).

The ESP32 board is running ESPHome: https://esphome.io/. I think it is a very nice project and very easy to setup. All the configuration is done via YAML files. The board is connected to the home WiFi and it has a fallback hotspot.

My home heating system has two radiating floor zones with two independent pumps. I also decided to automate the boiler’s “Winter mode”, in this mode the boiler heats the water for the heating, and I wanted to disable it when the heating is not working.

In my case I needed to activate the winter mode when any pump is working and keep it working for a period of time after the pump is off.

This is my ESPHome YAML config:

substitutions:
  devicename: heating
  friendly_name: Heating

esphome:
  name: ${devicename}
  friendly_name: ${friendly_name}
  platform: ESP32
  board: nodemcu-32s

logger:

api:
  password: ""

ota:
  platform: esphome
  password: ""

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  reboot_timeout: 90s

  ap:
    ssid: ${friendly_name} Fallback Hotspot
    password: !secret wifi_password

captive_portal:

web_server:
  port: 80

debug:

time:
  - platform: homeassistant
    id: homeassistant_time

sensor:
  - platform: uptime
    name: Uptime
    filters:
      - lambda: return x / 60.0;
    unit_of_measurement: minutes

  - platform: wifi_signal
    name: Wifi Signal
    update_interval: 60s

script:
  - id: keep_winter_mode_on
    mode: restart
    then:
      - logger.log: "Keep Winter mode start"
      - if:
          condition:
            and:
              - switch.is_off: zone1_pump
              - switch.is_off: zone2_pump
          then:
            - logger.log: "Keep Winter mode will stop"
            - delay: 15min
            - switch.turn_off: winter_mode
            - logger.log: "Keep Winter mode stopped"

  - id: zone1_pump_security
    mode: restart
    then:
      - logger.log: "Zone 1 security start"
      - delay: 60min
      - switch.turn_off: zone1_pump
      - logger.log: "Zone 1 security stop"

  - id: zone2_pump_security
    mode: restart
    then:
      - logger.log: "Zone 2 security start"
      - delay: 60min
      - switch.turn_off: zone2_pump
      - logger.log: "Zone 2 security stop"

switch:
  - platform: gpio
    pin: GPIO16
    name: "Winter mode"
    id: winter_mode
    inverted: true
    restore_mode: ALWAYS_OFF

  - platform: gpio
    pin: GPIO17
    name: "Zone 1 pump"
    id: zone1_pump
    inverted: true
    restore_mode: ALWAYS_OFF
    on_turn_on:
      then:
        - script.stop: keep_winter_mode_on
        - switch.turn_on: winter_mode
        - script.execute: zone1_pump_security
    on_turn_off:
      then:
        - script.stop: zone1_pump_security
        - script.execute: keep_winter_mode_on

  - platform: gpio
    pin: GPIO18
    name: "Zone 2 pump"
    id: zone2_pump
    inverted: true
    restore_mode: ALWAYS_OFF
    on_turn_on:
      then:
        - script.stop: keep_winter_mode_on
        - switch.turn_on: winter_mode
        - script.execute: zone2_pump_security
    on_turn_off:
      then:
        - script.stop: zone2_pump_security
        - script.execute: keep_winter_mode_on

Thermometers

To measure the temperature in the rooms, I used two Xiaomi Mi Home Bluetooth Thermometer 2 (~6 EUR each). They transmit the temperature via BLE (Bluetooth Low Energy) beacons.

Their LCD display is very convenient and, as they are battery powered, you can place them in the better part of the room. I flashed them with this custom firmware:

https://github.com/pvvx/ATC_MiThermometer

I’m still surprised by these small beasts, there are now firmwares to transform them in Zigbee:

https://devbis.github.io/telink-zigbee/.

Home Assistant

The control, reading the thermometers and activating the pumps, is done via a Home Assistant (HA) running in an old X86 tablet with Ubuntu (this is usually run in a Raspberry Pi or similar…).

I installed HA in a Docker container, this is my script to update and start the container:

#!/bin/bash
cd $(dirname $(readlink -f $0))
docker stop homeassistant
docker rm homeassistant
docker pull ghcr.io/home-assistant/home-assistant:stable
docker run -d \
	--name homeassistant \
	--privileged \
	--restart=unless-stopped \
	-e TZ=Europe/Madrid \
	-v ./config:/config \
	-v /etc/letsencrypt:/etc/letsencrypt \
	--network=host \
	ghcr.io/home-assistant/home-assistant:stable
docker image prune --all

Home assistant reads the thermometers via the Passive BLE monitor integration: https://github.com/custom-components/ble_monitor that can be easily installed via HACS (the Home Assistant Community Store). I needed a Bluetooth 5 USB adapter.

Then, I needed to setup two thermostats in HA via the config/configuration.yaml file:

climate:
  - platform: generic_thermostat
    name: "Living Room"
    unique_id: zone_1_thermostat
    heater: switch.zone_1_pump
    target_sensor: sensor.ble_temperature_living_room_thermometer
    min_temp: 15
    max_temp: 20
    ac_mode: false
    target_temp: 17
    cold_tolerance: 0.5
    hot_tolerance: 0
    min_cycle_duration:
      minutes: 30
    keep_alive:
      minutes: 5
    initial_hvac_mode: "off"
    away_temp: 15
    precision: 0.1

  - platform: generic_thermostat
    name: "Bedrooms"
    unique_id: zone_2_thermostat
    heater: switch.zone_2_pump
    target_sensor: sensor.ble_temperature_bedrooms_thermometer
    min_temp: 15
    max_temp: 20
    ac_mode: false
    target_temp: 17
    cold_tolerance: 0.5
    hot_tolerance: 0
    min_cycle_duration:
      minutes: 3
    keep_alive:
      minutes: 5
    initial_hvac_mode: "off"
    away_temp: 15
    precision: 0.1

Home Assistant doubles as temperature and humidity logger, and its easy to configure dashboards:

And, of course, now I’m using HA to control many other things at home.

Another complex parts were:

• Making HA accessible via internet setting up a couple port redirections (one for HA and another for certbot) and a dynamic DNS service
• Setup nginx and certbot for HTTPS
• Connecting it to Google Home to allow receiving voice commands from my Nest Minis

But that is another long story…

The post Climate control with ESPHome and Home Assistant appeared first on Alberto Ruibal.

After the initial hype (with Apple showing some nice fake videos…), it seems that now things are much more quiet about the Vision Pro. I’m sure they are going to fail, like all the previous attemps on VR “failed”, or at least they failed as a mass consumer product.

People do not want immersive experiences, or they do not want these experiences all the time. Books like “Neuromancer” or “Ready Player One” portray a society were all the computers use VR interfaces, but I think that is still not possible with the technology we have in 2024. Even if it becomes possible someday, people may not embrace it.

3D interfaces in computers are not comfortable, and all attempts to develop these kinds of interfaces have failed. Humans have been using paper, a “2D” medium, for thousands of years; that is why it’s so easy for us to interact with 2D screens on mobile phones or tablets.

We observed the evolution of past interface design trends, such as skeuomorphism, transforming into clean visual languages characterized by simplified interfaces, as exemplified by material design. The natural environment of these interfaces is 2D.

And additionally, there are other factors like the weight or the low resolution of the screens and the cameras (yes, it’s one of the biggest in the market, but it still cannot replace a real monitor, and it’s going to guarantee you dizziness when you try to read text).

There are still some niches where VR is a success, mainly those gaming related (and of course porn), but Apple is not good at any of those.

I remember some VR/AR memorable failures, the Vision Pro will soon join the list:

• Nintendo Virtual Boy
• Sega VR
• Microsoft Hololens
• Google DayDream
• …

The post Apple Vision Pro and why it is going to fail appeared first on Alberto Ruibal.

In this version, I’ve removed the no-longer-functional Facebook integration and replaced it with device IDs for the leaderboard. Users can now choose any username for the times they send from their device.

One significant improvement is not immediately visible. I’ve upgraded from an old JMini3d (OpenGL 1.1) to the latest version using OpenGL 2.0. This enables the use of bitmap fonts allowing races with more than 5 laps (the old version only had textures for numbers 1 to 5).

Over the last 10 years, I’ve learned a lot about development. The code looked horrible for today’s standards, so I did a major code refactor. It now supports various race types, adding races against the chronometer.

A minor physics adjustment has been made to prevent users from taking very tight turns at full throttle, which has rendered all previous leaderboard times invalid. Additionally, the leaderboards now differentiate between each lane and the number of laps completed.

During last summer’s holidays, I added new circuits and seasons, including tracks from the current F1 season and Le Mans. Today, I’m applying the final touches to the Bluetooth code and I expect to release it soon.

The post Slot Racing 10th anniversary appeared first on Alberto Ruibal.

2010 was declared “The year of 3D TV”. Somehow it was assumed that we were going to watch TV with glasses. I remember “experts” saying ‘In the future all the TVs will be 3D”.

I went to the cinema a couple times to watch 3D movies, and at the begining it was fun to try, but I got bored soon. I also bought a TV without 3D.

There was a lack of 3D content, and some movies where converted to 3D with algorithms producing a mediocre result. Also 3D viewing was causing headaches in a lot of people.

Nintendo joined the trend in 2011 launching the 3DS, that was showing 3D without glasses. But almost everybody was using it with the 3D deactivated, and in 2013 they launched the 2DS, without the 3D.

The production of 3D TVs ended in 2016 putting an end to this trend.

I remember this every time that someone says we are going to use VR headsets for work. Glasses, stereoscopic view, trends, headaches…

The post Avatar and stereoscopic 3D screens appeared first on Alberto Ruibal.

OpenAI is a research institute that focuses on conducting research in the field of artificial intelligence. The organization was founded in 2015 with the goal of promoting and developing friendly AI, which refers to AI that is aligned with human values and that can be used to improve the lives of people. OpenAI conducts research in areas such as machine learning, robotics, and economics in order to advance the understanding and capabilities of AI. The organization is supported by a number of high-profile investors and has made significant contributions to the field of AI.

GPT is an acronym that stands for “Generative Pretrained Transformer.” It is a type of large language model that uses deep learning techniques to generate human-like text. It was developed by the research lab OpenAI, and is designed to be able to generate text that is indistinguishable from text written by a human. GPT models are trained on massive amounts of text data, and can generate responses to questions and prompts in a variety of languages and styles. They are often used for a wide range of applications, including language translation, text summarization, and conversation.

As a large language model trained by OpenAI, this chatbot is a type of artificial intelligence that is designed to generate natural language responses based on the input that it receives. It uses machine learning algorithms to process and analyze the input, and then generates a response based on the information that it has been trained on.

This chatbot does not have access to the internet, so it cannot browse or search for information online. Instead, it relies on the knowledge and information that it has been trained on to generate its responses. It is constantly learning and improving, so its responses may become more accurate and relevant over time.

Users can interact with this chatbot by typing in questions or statements, and the chatbot will generate a response in natural language. The specific capabilities and functionality of this chatbot will depend on its design and training.

And now the most interesting part: ALL THE ABOVE TEXT WAS GENERATED BY CHATGPT. It was done by asking it “What is OpenAI?”, “What is GPT?’ and “Tell me how this chatbot works in third person”. Surprised? Me too.

https://chat.openai.com/

Official announcement: https://openai.com/blog/chatgpt/

The post OpenAI’s ChatGPT chatbot appeared first on Alberto Ruibal.

I purchased an Arduino UNO board approximately 10 years ago and conducted various experiments with it. Recently, my old Delonghi DEM 10 dehumidifier ceased to function due to a board issue, and the cost of replacing the original board was approximately 60€. Instead, I opted to replace the faulty board with the Arduino UNO and a two-relay board (designated for the compressor and fan).

BOM:

• Arduino UNO: 20€
• Relay board: 5€
• 12V transformer: found at home
• ~1€ in cables and screws
• A resistor
• Wood recycled from a packaging

And a new dehumidifier with the same specs costs ~150€, but I didn’t do this for the money….

I had a lot of fun coding the program to manage the sensors and the timer. I remembered how thermistors work and implemented the defrost and the overheat protection with a state machine, repurposing the leds to show the states. After stopping the compressor we need to wait ~20 seconds before starting it again (because the capacitor needs to be loaded).

This is the source code, it uses the thermistor library.:

#include "thermistor.h"

const int STATUS_IDLE    = 0;
const int STATUS_WORKING = 1;
const int STATUS_PAUSE   = 2;

const int PIN_FULL        = 6;
const int PIN_HIGRO       = 7;
const int PIN_COMP        = 8;
const int PIN_VENT        = 9;
const int PIN_THERMISTOR  = A0;
const int PIN_LED_ON      = 4;
const int PIN_LED_DEFROST = 3;
const int PIN_LED_PAUSE   = 2;


const long TIME_WAIT               = 50;
const long TIME_BEFORE_PAUSE       = 25 * 60 * 1000L;
const long TIME_PAUSE_TIMER        =  5 * 60 * 1000L;
const long TIME_PAUSE_DEFROST      = 10 * 60 * 1000L;
const long TIME_PAUSE_OVERHEAT     = 10 * 60 * 1000L;
const long TIME_PAUSE_COMP_OFF     = 30 * 1000L;

const int TEMP_DEFROST  =  30; // IN 1/10 ºC
const int TEMP_OVERHEAT = 350; // IN 1/10 ºC

int status = STATUS_PAUSE;

long workingTimer  = TIME_BEFORE_PAUSE;
long pauseTimer = TIME_PAUSE_COMP_OFF;

THERMISTOR thermistor(PIN_THERMISTOR,        
                      10000,          // Nominal resistance at 25 ºC
                      3950,           // thermistor's beta coefficient
                      10000);         // Value of the series resistor

void setup() {
  Serial.begin(9600);
  
  pinMode(PIN_FULL, INPUT_PULLUP);
  pinMode(PIN_HIGRO, INPUT_PULLUP);
  
  pinMode(PIN_COMP, OUTPUT);
  pinMode(PIN_VENT, OUTPUT);
  digitalWrite(PIN_VENT, HIGH);
  digitalWrite(PIN_COMP, HIGH);

  pinMode(PIN_LED_ON, OUTPUT);
  pinMode(PIN_LED_DEFROST, OUTPUT);
  pinMode(PIN_LED_PAUSE, OUTPUT);
  digitalWrite(PIN_LED_ON, HIGH);
  digitalWrite(PIN_LED_DEFROST, HIGH);
  digitalWrite(PIN_LED_PAUSE, HIGH);
}

void loop() {
  long t1 = millis();

  boolean full = digitalRead(PIN_FULL);
  boolean higroOff = digitalRead(PIN_HIGRO);
  uint16_t temp = thermistor.read();

  // Status changes
  switch(status) {
    case STATUS_WORKING: {
      if (full || higroOff) {
        Serial.println("Stopping...");
        status = STATUS_PAUSE;
        pauseTimer = TIME_PAUSE_COMP_OFF;

      } else if (temp < TEMP_DEFROST) {
        Serial.println("Pausing to defrost...");
        status = STATUS_PAUSE;
        pauseTimer = TIME_PAUSE_DEFROST;

      } else if (temp > TEMP_OVERHEAT) {
        Serial.println("Pausing due to overheat ...");
        status = STATUS_PAUSE;
        pauseTimer = TIME_PAUSE_OVERHEAT;

      } else if (workingTimer <= 0) {
        Serial.println("Pausing due to timer...");
        workingTimer = TIME_BEFORE_PAUSE;
        status = STATUS_PAUSE;
        pauseTimer = TIME_PAUSE_TIMER;
      }
      break;
    }

    case STATUS_IDLE: {
      if (!full && !higroOff) {
        Serial.println("Starting...");
        status = STATUS_WORKING;
      }
      break;
    }

    case STATUS_PAUSE: {
      if (pauseTimer <= 0) {
        status = STATUS_IDLE;
      }
      break;
    }
  }

  // New statuses and timer update
  switch(status) {
    case STATUS_WORKING: {
      Serial.println("Working");
      digitalWrite(PIN_VENT, LOW);
      digitalWrite(PIN_COMP, LOW);

      digitalWrite(PIN_LED_ON, LOW);
      digitalWrite(PIN_LED_DEFROST, HIGH);
      digitalWrite(PIN_LED_PAUSE, HIGH);
      break;
    }

    case STATUS_IDLE: {
      Serial.println("Idle");
      digitalWrite(PIN_VENT, HIGH);
      digitalWrite(PIN_COMP, HIGH);

      digitalWrite(PIN_LED_ON, HIGH);
      digitalWrite(PIN_LED_DEFROST, LOW);
      digitalWrite(PIN_LED_PAUSE, HIGH);
      break;
    }

    case STATUS_PAUSE: {
      Serial.println("Paused");
      digitalWrite(PIN_VENT, LOW);
      digitalWrite(PIN_COMP, HIGH);

      digitalWrite(PIN_LED_ON, HIGH);
      digitalWrite(PIN_LED_DEFROST, HIGH);
      digitalWrite(PIN_LED_PAUSE, LOW);
      break;
    }
  }

  // Pause and timer updates
  Serial.print("Temp in 1/10 ºC : ");
  Serial.println(temp);

  delay(TIME_WAIT);
  long t2 = millis();

  switch(status) {
    case STATUS_WORKING: {
      workingTimer -= t2 - t1;
      Serial.println(workingTimer);
      break;
    }

    case STATUS_PAUSE: {
      pauseTimer -= t2 - t1;
      Serial.println(pauseTimer);
      break;
    }
  }
}

And it feels like if I do not suck at electronics anymore

The post Fixing an old dehumidifier with Arduino appeared first on Alberto Ruibal.

Los compañeros de LaretasGeek (https://twitter.com/laretasgeek) están llevando a cabo una iniciativa de entrevistas en cadena “AMA” (Ask Me Anything) en la que el entrevistado de cada semana escoge a un invitado y lo entrevista la semana siguiente.

En esta cadena de entrevistas, Eloy Coto de Red Hat escogió entrevistarme a mí, y esta fue la entrevista:

https://www.youtube.com/watch?v=aJkifnWjug0

Una semana después, yo escogí entrevistar a Antón Román, CTO de Quobis, y nos quedó otra entrevista muy chula:

https://www.youtube.com/watch?v=jvFiG1ukAWc

The post LaretasGeek AMA appeared first on Alberto Ruibal.

I just finished my third way of St. James by bike, the french way. This was the first time that I am able to finish without too much incidents, so I’m telling my experience.

My ways

In the last years I have done these:

• Northern way (Camino del norte): It is the prettiest but the most difficult, with lots of slopes. I made Irun-Santiago in 13 days, but I had lots of mechanical problems with my bike and I suffered the rain. It was August and hostels were always full, so I made it from camping to camping.
• Silver way (Vía de la Plata): I made it in July starting from Seville, it was too hot, and it is very easy to run out of water. I drank 7 liters of water per day. There aren’t fountains in the way and there are very long sections without bars or shops. I fell ill and I had to go back home from Salamanca.
• French way (Camino francés): It is he easiest but it is crowded. I just made Pamplona-Santiago in 8 days. I made it in June and there was enough room in hostels and the climate was pretty favorable.

I followed always the Eroski guide, but it is in spanish: http://caminodesantiago.consumer.es/. I also used the GPX Viewer android app with tracks downloaded from Wikiloc to help when I get lost.

The bike

You do not need a very strong bike to make the way. You can make it with a road bike, but I prefer to go off-road with a mountain bike and make it following the same path than walking pilgrims.

I use pannier bags and a small backpack where I carry less than 2Kg. Trying to carry all the weight in a backpack can be harmful. You will need additional space for the food and for the water, specially when making the Silver way.

The rear wheel may suffer with the additional weight, so it is better to have a rear tyre in good conditions. I suffered lots of punctures in the Northern way due to a tyre in bad conditions.

And install a bell, it is very important to warn walking pilgrims of your presence and to do not frighten them.

Do not try to go with your bike to the starting point by train, RENFE has serious issues carrying bicycles. It is possible to go by bus, most companies allow you to carry your bike in the trunk paying a small plus.

What to carry

Along the years, I optimized the things to carry, I made this last way carrying only 6.5 Kg:

• Bike clothing: a t-shirt, a cycling short, glasses, gloves and cycling shoes. I wash the t-shirt and the short every day just after arriving to the hostel.
• A cotton t-shirt: I use it also as pijama
• A pair of light trousers
• 3 x underpants and socks: I also wash my underwear every day
• Flip flops: for the shower
• Swimsuit: there are lots of beaches in the northern way and some swimming pools in the others, do not miss them!
• Rain jacket
• Sleeping bag: I also use it to sleep in hostels
• Sleeping pad
• Tent: I carry a 1 Kg High Peak Minilite, not very resistant to the water https://www.highpeak-outdoor.com/minilite-1038.html
• Bike tools: I carry a very basic set of tools: a small bike multi-tool, a spare tube, a patch kit and a pair of spare braking pads.
• A chain lock: I feel safer leaving my bike locked
• A power bank: I leave it charging in the hostel (it is a minor loss if stolen) and then, during the day, I charge my phone

A pro-trick is to carry your wallet and your electronic devices in a small tupperware. It is an extra protection under the rain.

What to eat

You can find menus for pilgrims by 10 eur. The hostels have kitchen and you can cook there. On the bike, I try to eat the same calories that I am consuming: I carry fruit, sandwiches, cereal bars, cookies, etc. and I stop every hour to eat something.

Where to sleep

Hostels are the best option, I carry a tent as backup, but in my last way it was not necessary. Hostels are cheaper than campings, you can find some hostels by 5 eur/night. Some of the hostels, when they are full, allow you to sleep on the floor (so it’s useful to carry a sleeping pad) or outside, in a tent in the garden.

Most hostels ask you for the Credential, you can get it at many hostels by 2 or 3 eur.

The experience

It’s hard to explain, buy the way is a mix of culture, sport, fellowship and religion (not in my case) that make it a unique experience full of hard to forget moments, and, yes, so good and addictive that I made it three times…

Google Photos album with my French way: https://photos.app.goo.gl/XMJjDm9ZkCDrtbM49

The post The way of St. James by bike appeared first on Alberto Ruibal.

• It can be compiled to bytecode compatible with Java >=6, allowing to use a lot of Java 7-8 features (lambdas…)  in Java 6 bytecode (=Android)
• It can be transpiled to Javascript (like Java with GWT)

So I decided to migrate the Carballo Chess Engine code to Kotlin (and his name is Karballo) to make some experiments and having some “fun” :)… but it became a non-trivial task, the converted code is at: https://github.com/albertoruibal/karballo.

Converting the code

To start working with Kotlin I installed the Kotlin plugin for Android Studio (=IntelliJ) from:

File->Settings->Plugins->Install JetBrains Plugin

Once the Kotlin plugin is installed, it’s quite easy to convert java source files to Kotlin with: CTRL + SHIFT + ALT + K

Conversion problems

The Java to Kotlin code conversion does not work perfectly, the Carballo conversion arose these errors:

• Kotlin is strong typed, you cannot compare a long against the literal ‘0’, you must use ‘0L’… I had hundreds of this comparisons
• A Long cannot be initialized with an unsigned hex literal if the value does not fit in the signed type, it gives a “Value out of range” compilation error ,  so you cannot do:

  var variable = 0xffffffffffffffffL

  The solution is to convert the literals to a signed decimal:

  var variable = -1

• Error “Property must be initialized or be abstract” with attributes not initialized in the constructor, solved adding the “lateinit” modifier to the declaration of the attributes (yes, Kotlin knows if you are initializing the attribute in the constructor)
• Strange toInt() insertions:

  pieceNames.indexOf(pieceChar.toInt())

  should be:

  pieceNames.indexOf(pieceChar)

• Variables of type Byte cannot be used as array indices, I had to manually change many vars from Byte to Int
• Kotlin does not allow assignments in expressions, so it’s impossible to do:

  while ((node.move = node.moveIterator.next()) != Move.NONE) { 

  I manually had to change some cases to the more verbose:

  while (true) {
      node.move = node.moveIterator.next()
      if (node.move == Move.NONE) {
         break
      }

• The binary operators do not work in multi line if they are placed at the beginning of the second line, only if they are at the end of the first, so:

  var myLong : Long = long1
      or long2

  does not compile, it must be:

  var myLong : Long = long1 or
      long2

• It didn’t recognize some custom getters and I had to merge them manually, I like a lot how they look in Kotlin (notice the use of the special word “field” to avoid calling the getter recursively):

  var lastMoveSee: Int = SEE_NOT_CALCULATED
      get() {
          if (field == SEE_NOT_CALCULATED) {
              field = board.see(move, ai)
          }
          return field
      }

• The conversion process got hung with two complex classes: CompleteEvaluator and ExperimentalEvaluator… I had to kill IntelliJ. I converted the CompleteEvaluator class copying to a new class small chunks of code.
• Kotlin’s when() statement do not work like the Java’s switch->case, as it hasn’t breaks, you cannot jump from one option to the next excluding the break: the conversion duplicated a lot of the MoveIterator code and I fixed it manually.
• Some other strange errors like wrong expressions and missing parenthesis…

Some things of Kotlin that I don’t like (yet)

Some are part of the claimed Kotlin “features”:

• Kotlin does not has primitive types, but it seems to not affect the performance…
• There is no ternary operator in Kotlin, it’s replaced with “if (…) … else …” expressions: This increases a lot the verbosity, al least in my code
• Kotlin’s crusade against NullPointerExcepcions: It a type allows null, it must be explicitly indicated appending a question mark to the type:

  var myString : String? = null

  To convert a nullable var/val to a non-nullable, you should use the !! operator, this forces a NullPointerException if the value is null (and it seems that you are shouting to the IDE…):

  var myString : String? = "hello"
  var myStringNotNull : String = myString!!

• Static fields and methods are grouped in a “Companion Object”
• Compilation is slower than pure Java
• Many bugs running from Android Studio non-android projects (IntelliJ worked better for me)
• Couldn’t get the JS compilation working yet

And other things that I like

• The full interoperability with Java
• Type inference, normally I continue to specify the types, but in some cases it saves a bit of code
• Data classes, they will save you hundreds of lines of boilerplate code https://kotlinlang.org/docs/reference/data-classes.html
• Array initialization with lambdas

  nodes = Array(MAX_DEPTH, {i->Node(this, i)})

• The singleton pattern is embedded in the language: using “object” instead “class” assumes that the class is a singleton
• Visibility is “public” by default, with the access modifier “internal” it can be accessed only from the same module
• Implicit getters / setters
• No need for “new” to call constructors
• And much more…

Performance

I’m my first tests, I’m not noticing any performance downgrade (or upgrade) over the Carballo Java version.

The post Converting Carballo to Kotlin appeared first on Alberto Ruibal.

One year ago my Carballo Chess Engine (https://github.com/albertoruibal/carballo) was stuck: all the improvements that I was trying were not working, and I detected the main problem: I am a poor chess player so I will never be a good chess engine developer. I thought that the main chess programming skill was statistical analysis and not chess knowledge, but I was wrong.

So, I took the decision of starting to learn and play chess. I joined the local chess club Xadrez Ramiro Sabell (http://www.xadrezramirosabell.com) and I was so lucky that in this club teaches chess the International Master Yudania Hernández Estevez. It’s quite curious the amazing people that you can find in a small city like Ponteareas. I also try to help the club in the tournaments organization and with a small Mobialia sponsorship. Now I am playing the Galician Chess League (in third division) and all the tournaments that I can.

My chess level is improving fast (ok, I’m under 1600 ELO yet: http://ratings.fide.com/card.phtml?event=24597015), but the real deal is that the Carballo Chess Engine strength is improving much faster, climbing positions in the CCRL list (http://www.computerchess.org.uk/ccrl/4040/). Learning chess helps me to diagnose the flaws and to understand better what’s going on under the hood.

Finally,  playing chess also helps me to detect the chess player needs, so I realized the main missing feature from Mobialia Chess: a chess database to review historic games and to analyze your own games searching statistics for each position. This year I worked to implement this feature and starting today you can access a Beta version of the database in Mobialia Chess Web (http://chess.mobialia.com).

The post Improving Carballo Chess Engine the hard way appeared first on Alberto Ruibal.

Java to native compilers have been around for some years, and I was curious about if one of this solutions could improve the performance of my Carballo Chess Engine.

I ran a tournament between binaries of the Carballo development version (1.5) compiled with different solutions to compare the performance. I used cutechess-cli to run a 3000 game tournament with time control 5″ + 0.1″ per move by side and with the Noomen Test Suite as the starting positions.

The compared binaries

• The Pure Java Version: This is the carballo-1.5.jar ran with the Oracle JDK 1.8.0_73 VM under my 64bit linux (Debian Sid).
• GCJ: The GNU’s Java compiler, incomplete and unfinished, but it works for Carballo. This binary was compiled with this script.
• Excelsior Jet: A classic proprietary Java to native converter at http://www.excelsiorjet.com. I used Excelsior Jet 11 32bit for Linux (evaluation) to generate this binary. The 64bit version had worse results.
• RoboVM: (https://robovm.com) A solution to run Java apps on iOS. Recently it was bought by Xamarin, and after the Microsoft acquisition of Xamarin, RoboVM was discontinued. RoboVM also has the option to compile Java apps to desktop binaries. I built this binary with the last RoboVM free version (1.8). Now RoboVM is forked in BugVM, but I was not able to build the binary with BugVM.
• C# compiled with Mono: There is a C# version of Carballo converted with the Sharpen tool. I compiled this binary with MonoDevelop 5.10. The converted code is sub-optimal but it is a good solution if you need a native version (or if you need to integrate Java code in a C# project).

Test results

Rank Name                          ELO   Games   Score   Draws
   1 carballo-1.5-gcj               89    1200     62%     28%
   2 carballo-1.5                   37    1200     55%     27%
   3 carballo-1.5-mono              -5    1200     49%     30%
   4 carballo-1.5-jet              -33    1200     45%     28%
   5 carballo-1.5-robovm           -88    1200     38%     27%

Conclusions

The JVM performance is very good, better than almost all the Java to native solutions.

The exception is GCJ, but it’s incomplete and it will not work for all the Java apps.

I expected better results from Excelsior Jet, as some time ago Carballo Jet binaries where available an used for testing.

The C# version is a bit worse but acceptable.

The post Benchmarking Java to native compilers appeared first on Alberto Ruibal.