About admin

Posts by :

Remote controller for Clocks (IKEA and others, DCF77, WWVB, MSF, JJY)

Remote controller for Clocks (IKEA and others, DCF77, WWVB, MSF, JJY)

0

A remotely controlled, precise analog wall clock like that one from IKEA is a cool thing. Today we will build our own remote control for such analog and digital clocks. All we need is a Raspberry Pi and a few electronic components. And we will learn something about resonance frequencies, capacitors, and ferrite antennas. Let’s hack!


This is material presented in the following video:


Installation:

Source of the software: https://github.com/hzeller/txtempus 

sudo apt-get install git build-essential -y
git clone https://github.com/hzeller/txtempus.git
cd txtempus
make

Start command:

sudo ./txtempus -v -s DCF77
Options:
        -s <service>          : Service; one of 'DCF77', 'WWVB', 'JJY40', 'JJY60', 'MSF'
        -r <minutes>          : Run for limited number of minutes. (default: no limit)
        -t 'YYYY-MM-DD HH:MM' : Transmit the given local time (default: now)
        -z <minutes>          : Transmit the time offset from local (default: 0 minutes)
        -v                    : Verbose.
        -n                    : Dryrun, only showing modulation envelope.
        -h                    : This help.

Automatic Startup:

Create a service file for systemd:

Create a service file: 
sudo nano /lib/systemd/system/remoteClock.service

Insert the following content:

[Unit]
  Description=My Sample Service
  After=multi-user.target

[Service]y
 Type=idle
 ExecStart=/home/pi/txtempus/txtempus -v -s DCF77 > /home/pi/remoteClock.log 2>&1 

[Install]
  WantedBy=multi-user.target

Press ctrl-X , Y and Enter to save the file

Set the permission:

sudo chmod 644 /lib/systemd/system/remoteClock.service

Restart systemd

sudo systemctl daemon-reload
sudo systemctl enable remoteClock.service

sudo reboot
Raspberry Pi Tricks

Raspberry Pi Tricks

4

Safe Shutdown

This is material presented in this video:

If you pull the plug on a Raspberry Pi during operation, it is well possible that it will never boot up again, because its SD card is corrupted. This is what we will change today. And I will show you a few other useful tricks you might not find right away.

RPi Pinout: If you connect GPIO3 with GND your Raspberry Pi shuts safely down

Only connecting the switch is not enough. We have change the config.txt file using this command: 

sudo nano /boot/config.txt

and add the following line to the file:

dtoverlay=gpio-shutdown,gpio_pin=3,active_low=1,gpio_pull=up

ctrl-X and Yes and, after a reboot, it should work.

Increase Swap File

The next trick concerns installations with high memory consumptions, mainly on the Pi Zero. I learned it when I used Node-Red, influxDB, and Grafana on a Pi Zero. After a while, the device blocked and had to be rebooted. Using the reboot switch from before, BTW.

The “top” command revealed the problem: No more Swap space available. This means that Linux does not get enough resources and blocks. Swap space is used by the operating system if the main memory is not big enough. Then, it stores less needed content to the “slow” SD card. Of course, this happens earlier the smaller your RAM is.

The Pi zero only has 512 MB RAM, and the operating system assigns 102MB swap space. The Pi 3 has 1 MB RAM, and the operating system assigns the same amount. For the Pi 3 this is not as critical because it needs much less of this space. What to do?

We enter the command:

 sudo nano /etc/dphys-swapfile

and then uncomment the line:

CONF_SWAPFILE=/var/swap and CONF_SWAPFACTOR=2

This creates a swapfile which has 2 times the size of RAM, which seams to be best practice.

And we have to comment the line CONF_SWAPSIZE=100

Ctrl-Z , Y, and enter.

Then we have to invoke these two commands:

sudo dphys-swapfile setup

and

sudo dphys-swapfile swapon

After reboot, we see that the swap file is much bigger and, also after a time, Raspbian will still have free swap space. The Pi zero does not become a racing car with this change. But at least it does not block.

Wi-Fi Setup without Keyboard and display (headless)

We want to connect a “fresh” Raspberry to a Wi-Fi network first time without display and keyboard.

If you create a new SD image and boot your Pi, it cannot connect to your Wi-Fi network because it does not know the credentials and therefore you cannot connect to it to change the SSID or the password. The old “Henn” and “egg” problem.
Here is the trick: after writing the image to the SD card, you can remove and insert it gagain into the reader. You will get an error message. Just ignore it. Now you see this picture . We need to add two files. One is called:

” wpa_supplicant.conf” and the other ssh without an extension.

“wpa_supplicant.conf” has to contain the following lines:

The first is your country, and here you have to enter the Wi-Fi credentials. Save it to the SD card.

country=CH
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid=”…..”
psk=”…..“
}

The file with the name ssh can be empty. It just has to be there. Usually I create a blank text file and remove the extension.

Now we can boot a Raspberry with this SD card, and it will connect to Wi-Fi and enable SSH. As needed. My tip: I store a wpa_supplicant.conf file on my PC which includes my credentials. Then I just have to copy it to the new SD card.

Install rtl_433 for a SDR-RTL Dongle on a Raspberry Pi

Install rtl_433 for a SDR-RTL Dongle on a Raspberry Pi

3

This is supporting material for the following videos:

Install RTL_SDR Support

cd ~
sudo apt-get install git git-core cmake libusb-1.0-0-dev
build-essential
git clone git://git.osmocom.org/rtl-sdr.git
cd rtl-sdr/ && mkdir build && cd build/
cmake ../ -DINSTALL_UDEV_RULES=ON
sudo make
sudo make install
sudo ldconfig
cd ~
sudo cp ./rtl-sdr/rtl-sdr.rules /etc/udev/rules.d/
sudo reboot

# create file no-rtl.conf 

sudo nano /etc/modprobe.d/no-rtl.conf

# add these three lines

blacklist dvb_usb_rtl28xxu
blacklist rtl2832
blacklist rtl2830 

sudo reboot
lsusb
rtl_test -t

Build and install rtl_433

sudo apt-get install libtool libusb-1.0.0-dev librtlsdr-dev
rtl-sdr doxygen
git clone https://github.com/merbanan/rtl_433.git
cd rtl_433/ && mkdir build &&
cd build && cmake ../ &&
make
sudo make install

Test installation:

rtl_433

The source for this tutorial is: https://sdr-setup-notes.readthedocs.io/en/latest/dev_rtlsdr.html#rtl-433-tool-setup

Install supervisord

sudo apt-get install -y supervisor
sudo nano /etc/supervisor/conf.d/rtl_433.conf

Enter into file:

[program:rtl_433]
command=/home/pi/rtl_433/build/src/rtl_433 -R 123 -F “mqtt://localhost:1883,,user=”admin”,pass=”admin”,events=BEER”user=pi
autostart=yes
autorestart=yes
startretries=100
stderr_logfile=/var/log/rtl_433/rtl_433.err.log
stdout_logfile=/var/log/rtl_433/rtl_433.log

sudo mkdir /var/log/rtl_433

sudo service supervisor start 

sudo service supervisor status

If you changed the configuration file:

sudo supervisorctl reread

You are done!



Node-Red, InfuxDB & Grafana Installation

Node-Red, InfuxDB & Grafana Installation

2

Raspberry Pis are very good for monitoring all sorts of things. Today we will use Node-Red, InfluxDB, and Grafana for monitoring as well as enable Smartphone and Mail alarming.

Passwords

Where User Password
Raspberry Pi raspberry
Node-Red Flows admin admin
Node-Red UI User user
InfluxDB User Pi raspberry
Grafana admin admin

Prepare Image on SD card

Download image: http://bit.ly/2GdZbPe
Add empty ssh file to root directory of the card
Add wpa_supplicant.conf to root directory

Content of wpa_supplicant.conf file:

country=CH
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
  ssid=”…”
  psk=”…”
}

Insert SD card into your Raspberry, boot, and find its IP address using https://www.advanced-ip-scanner.com
Log-in using Putty https://www.putty.org/
update your Raspberry to the newest version:

 sudo apt-get update && sudo apt-get upgrade

Configuration on the Raspberry

Configuration of Mosquitto

sudo nano /etc/mosquitto/mosquitto.conf

insert:
allow_anonymous true

Restart Mosquitto

 sudo systemctl restart mosquitto

Configuration of influxDB

Create User:

CREATE USER "pi" WITH PASSWORD 'raspberry' WITH ALL PRIVILEGES
exit

Change config file: 

sudo nano /etc/influxdb/influxdb.conf

In [http] uncomment:
enabled = true and bind-address=:8086

in [monitor] uncomment and change to:
store-enabled = false

sudo service influxdb restart

Configuration of Node-Red

Import Flows from: https://drive.google.com/open?id=1kECuykSaFO7Qb_67QqIHtlpvElpVWDMI

Install Mail

sudo apt-get install ssmtp
sudo apt-get install mailutils
sudo nano /etc/ssmtp/ssmtp.conf

For Gmail enter this text:

mailhub=smtp.gmail.com:587
AuthUser=[yourmailaddress]@gmail.com
AuthPass=[emailPassword]
UseSTARTTLS=YES
UseTLS=YES

Test your Mail

echo "Hello world email body" | mail -s "Test
Subject" sensorsiot@gmail.com

Add support for less secure apps in Gmail: https://myaccount.google.com/lesssecureapps

Create influxDB database

influx

Create database [your databaseName]
Show DATABASES
Use [your databaseName]
Show series

exit

Install and prepare Telegram

Install Telegram on your PC https://desktop.telegram.org/

Start telegram and search for “botfather”

Enter the name of your desired bot. Note down the token.
Send a text message to the bot.

Go to: https://api.telegram.org/bot[Token]/getUpdates

and take a note of the ID. We will use it later:

Prepare Grafana

Add source
Add Dashboard by importing a JSON file:

Examples:
Beer Pressure: https://drive.google.com/open?id=1beKyu4WuGErAHeYKyE3-8wtpyZJ8yHkZ
Weather: https://drive.google.com/open?id=18326_tjcVln0xBLRJINJn2ZwP0lNlyHX
YouTube: https://drive.google.com/open?id=1TrZAGnxn4zRfyO_X8RXw4ZtQIvJi8JnQ

Add Mail Notification Channel

sudo nano /etc/grafana/grafana.ini

enabled=true
host = smtp.gmail.com:587
user =[receivingEmail]@gmail.com
password =”[emailPassword]”
skip_verify = true
from_address = [sendingEmail]@gmail.com
from_name = [whateverName]

Go to notification Channels
Add new Channel
Edit notification channel

And press “Send Text”

Add Telegram Notification Channel

Add new Telegram Notification Channel

Insert chatID and token from before

And press “Send Test”

You are done!



Installing the Arduino IDE including ESP8266 support

Installing the Arduino IDE including ESP8266 support

11

For the IoT Lab at the Developer UnConference in January in Zurich this is how you should prepare your laptop or Mac:

Install the Arduino IDE from https://www.arduino.cc/en/Main/Software.

Chose your platform and install:

Startup the Arduino IDE. It should look like that:

Goto “Preferences”:

Fill-in this string into this field:

https://github.com/esp8266/Arduino/releases/download/2.4.0-rc2/package_esp8266com_index.json

And hit ok.

Go to “Tools->Board:->Boards Manager”:

And search for “ESP8266”:

Check if a 2.4 release is selected and hit “Install”. Wait till everything is installed and hit “Close”.

Now the support for the ESP8266 chips should be installed.

Go back to Tools and boards and scroll until you find “NodeMCU 1.0” and select the line:

The Window will close and you should see the board in the bottom right corner of the IDE window.
Now you have to select or check the COM port:

And you see it also in the bottom right corner.

The COM port is probably not the same as on my computer. No worry.

For Mac users:

Connect the WeMos Shield to the MacBook USB port.
Check whether the WeMos Shield Board shows up on the USB port by using the following commands in a terminal session

$ ls /dev/cu.*
/dev/cu.Bluetooth-Incoming-Port
$ ls /dev/tty.*
/dev/tty.Bluetooth-Incoming-Port

If you get only these result of the ls command the WeMos Shield does not show up and you should install the USB driver. To do this follow the link in this description:

see here https://github.com/adrianmihalko/ch340g-ch34g-ch34x-mac-os-x-driver

(first, run the commands to remove the driver, the I used the procedure to install the driver using the installation with Homebrew-Cask).
You have to reboot your MacOS and with a connected WeMos Shield on the USB port you should get the following result

$ ls -lart /dev/cu*.*
crw-rw-rw-  1 root  wheel   21,   1 Jan  9 08:06 /dev/cu.Bluetooth-Incoming-Port
crw-rw-rw-  1 root  wheel   21,   7 Jan 10 06:55 /dev/cu.wchusbserial1410

$ ls -lart /dev/tty*.*
crw-rw-rw-  1 root  wheel   21,   0 Jan  9 08:06 /dev/tty.Bluetooth-Incoming-Port
crw-rw-rw-  1 root  wheel   21,   6 Jan 10 06:55 /dev/tty.wchusbserial1410

And in the Arduino IDE you should see the board

Continue with Windows and Mac:

Now you hit the “OK” button and the sketch should compile:

After a while, you should see “done compiling”:

Congratulations: This is your success message and you are ready to program an ESP8266 chip.

 

 

Connected Cat Feeder Using a Strain Gauge and an ESP32 (Video #161)

Connected Cat Feeder Using a Strain Gauge and an ESP32 (Video #161)

, , , , 9

Feeding our beloved animals is a rewarding job. We do not want to forget it. So, let’s build a connected scale, which alarms us when the food bin is empty. Of course, we will be able to use the same principle to measure the weight of any other good like the honey in remote beehives, or even your own weight to visualize it somewhere in the cloud…

The usual way to measure weight is with strain gauges. Strain gauges are relatively simple devices: Thin “PCBs”, or carriers, with copper traces. These PCBs are sensitive to all kinds of forces and change their resistance accordingly.

If we stick such a strain gauge on a metal bar and apply a force to one end, the resistance of the copper traces increases or decreases, depending on the direction of the force. That’s all. In principle. You can imagine that the distances these gauges are extended are minimal if the forces are small. This is, why we have to use some tricks. But we are Tinkerers and Engineers, and we love tricks to make things work. So, the first trick is to not only place one strain gauge on the bar. We place two of better four of them on both sides of the bar. Trick number two is: We weaken the rod that it bends easier. This can be done by drilling precise holes through the bar, right under the gauges. So, with a defined force, we get a bigger movement. And trick number three uses these two or four signals from the sensors and combine them in an interesting manner. It is called the Wheatstone bridge because Sir Charles Wheatstone popularized this concept already in the 19th century. Its main advantage is its ability to measure resistors extremely accurate and it cancels temperature effects. This is exactly what we need here.

So, we combine our two or four gauges into such a bridge. Fortunately, we can buy such devices with everything mounted and connected for a few dollars. They are called “Load Cells”. These bars are made for a particular weight, for example for 2, 5, or even 40 kg. And they are announced to be very precise.

The colors of the wires seem also somehow standardized. Red, black, green, and white. If your sensor has different wire colors, you easily find which is which if you search for the wires with the higher resistance between them. These are then the opposite wires.

Now we should be able to see very small changes in voltage if we bend the metal bar. But these are really small voltages as we see here. If I bend the bar quite a lot, we only measure around 2 mV.

Now we have a Sensor to measure forces, not weight. Sir Isaak Newton, also an Englishman, also a long time ago, discovered a way to convert weight in forces and vice versa. This is what we will use now.

Load Cells usually have threaded holes on each side. I mount one of them to a base plate and make sure it can move a little. For this prototype, I use an old PCB which I found in my lab. Then, I mount a bowl on top of the opposite side. Like that the sensor is bent a little if I put cat food into the bowl and we should be able to measure a voltage created by this bending force. And now, the star of this video enters the scene. She is called Dishka and is always hungry. Fortunately, she has long hair, so nobody sees her belly. But even if she is hoggish we have to measure her food in grams per day. So, our bowl has to be very sensitive. And this is why we need trick number four: A very sensitive and accurate analog-to-digital converter, also called ADC. And of course, this ADC should not cost more than the cat itself…

Because these days everybody is interested in measuring weight, such ADCs are produced in extremely high series. This makes it possible, that we can buy a 24-bit ADC with a built-in amplifier for a dollar if we buy a few of them. Its name is HX711. Cool. We connect the top and the bottom wires, in my case black and red, to the E+ and E- pins and the other two to A+ and A-. the B+ and B- pins are not used. Here, you could connect a second strain gauge.

Because these days everybody is interested in measuring weight, such ADCs are produced in extremely high series. This makes it possible, that we can buy a 24-bit ADC with a built-in amplifier for a dollar if we buy a few of them. Its name is HX711. Cool. We connect the top and the bottom wires, in my case black and red, to the E+ and E- pins and the other two to A+ and A-. the B+ and B- pins are not used. Here, you could connect a second strain gauge.

Now we only have to decide on the microprocessor and search for a library. If we want to use an Arduino Uno, we find a few libraries which work fine. We only have to connect 5V, ground, clock, and data to the respective pins, load the example sketch and are ready to go. We already see some values, and if I press the bowl, we see the values moving.

As always with scales, we first have to zero the device, and then, we have to calibrate it using a known weight.

But wait: We wanted also to get a tweet if the bowl is empty. So, we need a connected device. And because the newest kid on the block is an ESP32, I will use one of these new boards with an OLED. So, let’s check if the library works also with this new processor. The only thing we have to do is to adapt the data and the clock pins to the pins of the ESP32. I use pin25 and 26.

The HX711 also runs on 3.3 volts. So, no problem.

Unfortunately from time to time, we see outliers in the results. Not good! What is the problem? As always with intermittent problems, finding the root cause is not easy. But because we know, that it worked with the Arduino Uno, we can suspect, that it could have to do with the higher speed of the ESP32. Speed is not always good.

If we look at the timing of the two signals, we see, that the shortest signal is a little more than 100 nS. And if we look at the datasheet, we see, that this is too fast for the chip. It has to be more than 200 nS.

Usually, we can add a few delays here and there to fix this issue. Not so here, because the library uses the ShiftIn command, which reads 8 bits in a row without intervention possibility. And here, we have 3 shiftin() commands to read 24 bits in a row. So, the easiest way to solve this problem is to slow down the ESP32 chip itself. The ESP32 is a very fast chip and we can afford to slow it down for this application.

Slowing the ESP32 down is quite easy. Just include this library:

#include “soc/rtc.h”

and add this command at the beginning of the sketch:

void setup() {

rtc_clk_cpu_freq_set(RTC_CPU_FREQ_80M);

Then, our ESP32 runs with only 80 MHZ and the signal is now 3 times longer, much better for the HX711. Now, the outliers disappeared. And fortunately, the Serial speed, as well as the Wi-Fi communication, is not influenced.

The whole prototype is based on the example file of the HX711 library.

https://github.com/bogde/HX711

The sketch: https://github.com/SensorsIot/Weight-Sensors

Next, I make sure the OLED shows the values. This is very comfortable. Even if the compiler warns us, the library works with the ESP32. Now we have a nice setup to test the accuracy of our bowl. The calibration commands are included in the sketch. Please uncomment it the first time you use it.

First, this routine adjusts the sensor to zero and then waits for a defined weight to be added.

scale. set_scale();

scale.tare();

displayString(“Calibrate”, 64, 10); delay(2500);

displayFloat(scale.get_units(10), 64, 15);

The display shows: 11691

while(1==1);

Because Dishka is not interested in grams, I use cat food for calibration. I counted 50 pieces, and enter 50 as a calibration value. Now, the scale is ready to count the pieces and we can comment these lines.

This is why we take the number (11691) and divide it by the number of pieces (50). The resulting number has to be keyed in here.
scale.set_scale(233.82);

The next step is now to connect our ESP32

to the Wi-Fi network and to add the PubSub MQTT library, which works also with the ESP32. And because I already have a Raspberry Zero running Mosquitto and Node-Red, I easily can connect my new cat bowl with this system. If you do not know how to set up a Raspby for this purpose, you can watch video #126.

Because my bench light is connected to my MQTT broker, I could now switch my work light off for a moment if Dishka emptied her bowl. But we said we want a tweet. To achieve this, we add an MQTT receiver node and make sure it receives only the actual number of remaining pieces in the bowl. Then, we add a switch node to make sure, the tweet is only sent if less than 4 bites are in the bowl, a trigger which makes sure the tweet is not sent too often, and a twitter node to connect to Twitter. Done.

You find the flow also here.

https://github.com/SensorsIot/Weight-Sensors

Just copy it to the clipboard and import it from there to node-red.

Now, I get alarmed if poor Dishka is hungry.

Testing Power Supplies with Electronic Loads (video #146)

, 2

All our gadgets run with electrical power. And they usually demand constant voltage. We use batteries or some sort of regulated power supplies to deliver this energy. Today, we will look at procedures to test these power sources.
We will cover:

  • The basic principle of testing of power sources like poser supplies or batteries
  • The problems associated with it and its resolution
  • I will show you my new IT8512A+ electronic load and how it works
  • At the end, we will test a very nice small DSP5005 power supply with the procedures we learned

Electronic loads are able to adjust current to a set value and stabilize it, also at changing voltages

Basic diagram of a Electronic Load

If you are interested in a comparison between two USB electronic loads, you can watch my video #75

And a (unfinished) project with a bigger Electronic load:

and

There is a problem if we want to measure larger currents: The voltage is not displayed correctly.

This can be changed by using either a Voltmeter connected directly to the power supply or by using a more expensive Electronic load with Remote Sense capabilities, like the IT8512A+ used in this video, or its more professional “parent”, the BK8500. Or a Maynuo M9712, which is comparable with the IT8512A+. You can also get models with less maximal current, which are cheaper.

We test a DSP5005 Power supply and use what we learned. For that, we connect the IT8512A+ to a PC.

Connection cable between the IT8512A+ and the PC

You can either buy the original one:

https://www.aliexpress.com/store/product/ITECH-IT-E122-Isolated-USB-Communication-Cable-For-Electronic-Loads/1727580_32691025377.html

or build your own.

I used a male 9 pin Sub-D connector to connect the cable to the load

Then, I used a normal FTDI USB to Serial connector, which I switched to 3.3 volts

Now I could connect the cable to the USB port of my computer. But this would create ground loop issues. This is, why we have to use an additional USB insolator

This device creates a complete electrical separation between its two USB ports up to 1500 volts.

http://s.click.aliexpress.com/e/3JAay37

To install the software, you first have to install parst of Labview (in this order):

http://www.ni.com/download/ni-visa-16.0/6184/en/

http://www.ni.com/download/ivi-compliance-package-17.0/6828/en/

And then, you can install the ITECH software

http://www.itech.sh/en/support/Down-11.htm?model=it8500

I had some issues that some issues. Buttons were not displayed:

Fortunately, you can press the buttons and they display the information.

Add your device, and off you go.

I kike the power supply i used for the test and purchased also some other models from this supplier. This is, why I add an overview about the different power supplies of Hangzhou Ruideng Technologies for your convenience:

(Affiliate links to support the channel, no extra cost for you)

Electronics Load store: http://s.click.aliexpress.com/e/RFybmIa
RD official store: http://s.click.aliexpress.com/e/2fmMJqR

IKEA Trådfri Hack with Gateway (video #145 )

IKEA Trådfri Hack with Gateway (video #145 )

, , , 13

In video #140 we hacked the new IKEA Tradfri Smart lighting system using the remote control as a basis. And, as I said already in video #144: It worked, but had some major disadvantages. Today, we will use an IKEA Gateway and do it right!

  • We will eliminate the problems of the current hack
  • We will install and pair the gateway with two different bulbs
  • We will learn how the system communicates
  • We will switch the lights using node-red. Like that, we can use MQTT or many other tools to switch the lights

If you are interested

  • We will switch the lights with a normal Linux command
  • We will install a Python wrapper. You can use this wrapper as a basis for your own programs
  • We will see the CoAP protocol , which was introduced in the last video, in action
  • At the end, as promised, I will reveal a “hot” secret about the IKEA bulbs.

The major problem with the last hack was, that the remote control only toggled the on and off switch. So, we were never sure, if the bulb was really on or off. This works ok if you switch by hand, because you just press the button again, if something went wrong. For home automation systems, however, we need a concept with clear commands like “off” or “on”. And it would be nice, if we could read the actual state back to check, if everything went right.

Ikea sells a Gateway for its lighting system, which promises to be able to do exactly that. You get it together with a Smartphone app for around 30 dollars.

IKEA Architecture

 

First, pair your Remote Control with the Gateway and with all your bulbs.

Now we have to find the IP address of the gateway. I usually use Advanced IP scanner to do so. Fortunately, the MAC address is also printed on the Gateway. So, we just have to search for it in our IP scanner..

IP scanner

Tutorial about installing a  CoAP client to our Raspberry Pi (and much other stuff):

https://learn.pimoroni.com/tutorial/sandyj/controlling-ikea-tradfri-lights-from-your-pi

Peter Scargill’s script to install Node-Red, Mosquito, and many other goodies:

The Script

 

Consider also watching video #126 and #144 first:

Then, you start your browser and navigate to node-red. In the palette, you find a contribution called node-red-contrib-Tradfri. Just install this contribution and you are done. A CoAP client is installed together with this contribution.

Here is the flow. Just copy the whole flow into your clipboard and insert it from there in your Node-Red installation:
[{“id”:”7a41aec5.1ad98″,”type”:”tradfri-out”,”z”:”faf1d11c.29964″,”name”:”By msg.tradfri_id”,”dtype”:””,”tradfri_id”:”0″,”hub”:”8059fcc6.22ef7″,”output”:false,”x”:853,”y”:195,”wires”:[]},{“id”:”2925b8e0.63a798″,”type”:”inject”,”z”:”faf1d11c.29964″,”name”:””,”topic”:””,”payload”:”warm”,”payloadType”:”str”,”repeat”:””,”crontab”:””,”once”:false,”x”:312,”y”:151,”wires”:[[“e88c5652.38d698”]]},{“id”:”c9e0a605.bc7268″,”type”:”inject”,”z”:”faf1d11c.29964″,”name”:””,”topic”:””,”payload”:”off”,”payloadType”:”str”,”repeat”:””,”crontab”:””,”once”:false,”x”:312,”y”:298,”wires”:[[“e88c5652.38d698”]]},{“id”:”e88c5652.38d698″,”type”:”function”,”z”:”faf1d11c.29964″,”name”:””,”func”:”color=String(msg.payload)\n\nswitch (color){\ncase ‘warm’: \n msg.payload = { tradfri_id: 65538, type:’device’, state: ‘on’, color: ‘warm’, brightness: 255}\n break;\ncase ‘cool’: \n msg.payload = { tradfri_id: 65538, type:’device’, state: ‘on’, color: ‘cool’, brightness: 255}\n break;\ncase ‘half’: \n msg.payload = { tradfri_id: 65538, type:’device’, state: ‘on’, color: ‘cool’, brightness: 128}\n break;\ncase ‘off’: \n msg.payload = { tradfri_id: 65538, type:’device’, state: ‘off’}\n break;\n}\n\nreturn msg;”,”outputs”:1,”noerr”:0,”x”:607,”y”:198,”wires”:[[“7a41aec5.1ad98”]]},{“id”:”87ebd098.7894b”,”type”:”tradfri-out”,”z”:”faf1d11c.29964″,”name”:”TRADFRI bulb E27 WS clear 950lm”,”dtype”:”device”,”tradfri_id”:”65537″,”hub”:”8059fcc6.22ef7″,”output”:false,”x”:690,”y”:1018,”wires”:[]},{“id”:”98187db4.72c6″,”type”:”inject”,”z”:”faf1d11c.29964″,”name”:””,”topic”:””,”payload”:”65537″,”payloadType”:”json”,”repeat”:””,”crontab”:””,”once”:false,”x”:323,”y”:985,”wires”:[[“87ebd098.7894b”]]},{“id”:”1495e6db.5819b9″,”type”:”inject”,”z”:”faf1d11c.29964″,”name”:””,”topic”:””,”payload”:”off”,”payloadType”:”str”,”repeat”:””,”crontab”:””,”once”:false,”x”:284,”y”:758,”wires”:[[“87ebd098.7894b”]]},{“id”:”b88c5b55.05f3e8″,”type”:”tradfri-get”,”z”:”faf1d11c.29964″,”name”:””,”hub”:”8059fcc6.22ef7″,”x”:548,”y”:624,”wires”:[[“2b209f5c.b0e3a”]]},{“id”:”2b209f5c.b0e3a”,”type”:”debug”,”z”:”faf1d11c.29964″,”name”:””,”active”:true,”console”:”false”,”complete”:”payload.on”,”x”:815,”y”:624,”wires”:[]},{“id”:”3b4ed60b.9cc7ca”,”type”:”inject”,”z”:”faf1d11c.29964″,”name”:””,”topic”:””,”payload”:”65537″,”payloadType”:”json”,”repeat”:””,”crontab”:””,”once”:false,”x”:282,”y”:626,”wires”:[[“b88c5b55.05f3e8”]]},{“id”:”d0c91ad7.c54e98″,”type”:”inject”,”z”:”faf1d11c.29964″,”name”:””,”topic”:””,”payload”:”cool”,”payloadType”:”str”,”repeat”:””,”crontab”:””,”once”:false,”x”:319,”y”:204,”wires”:[[“e88c5652.38d698”]]},{“id”:”c90e7466.0d3148″,”type”:”inject”,”z”:”faf1d11c.29964″,”name”:””,”topic”:””,”payload”:”half”,”payloadType”:”str”,”repeat”:””,”crontab”:””,”once”:false,”x”:312,”y”:244,”wires”:[[“e88c5652.38d698”]]},{“id”:”7915f32e.2429dc”,”type”:”bigtimer”,”z”:”faf1d11c.29964″,”outtopic”:””,”outpayload1″:””,”outpayload2″:””,”name”:”Big Timer”,”lat”:”47.474161″,”lon”:”7.767258″,”starttime”:5001,”endtime”:”5000″,”startoff”:”1″,”endoff”:0,”offs”:0,”outtext1″:”on”,”outtext2″:”off”,”timeout”:1440,”sun”:true,”mon”:true,”tue”:true,”wed”:true,”thu”:true,”fri”:true,”sat”:true,”jan”:true,”feb”:true,”mar”:true,”apr”:true,”may”:true,”jun”:true,”jul”:true,”aug”:true,”sep”:true,”oct”:true,”nov”:true,”dec”:true,”day1″:0,”month1″:0,”day2″:0,”month2″:0,”day3″:0,”month3″:0,”day4″:0,”month4″:0,”day5″:0,”month5″:0,”d1″:0,”w1″:0,”d2″:0,”w2″:0,”d3″:0,”w3″:0,”d4″:0,”w4″:0,”d5″:0,”w5″:0,”suspend”:false,”random”:false,”repeat”:true,”atstart”:true,”x”:307,”y”:367.5,”wires”:[[“e88c5652.38d698”],[],[]]},{“id”:”8059fcc6.22ef7″,”type”:”tradfri-config”,”z”:””,”name”:”Lab”,”hubip”:”192.168.0.15″,”sid”:”djed8rbxLWVOdUWm”,”coap”:”/home/pi/.node-red/node_modules/node-tradfri-argon/lib/coap-client-raspbian”}]

Directory of CoAP client on Raspberry Pi:

/home/pi/.node-red/node_modules/node-tradfri-argon/lib/

To use the CoAP client, it is best to navigate to its directory:

cd /home/pi/.node-red/node_modules/node-tradfri-argon/lib/

Discover the available lamps (change your IP address and the Security Code from the bottom of your Gateway):

./coap-client-raspbian -m get -u "Client_identity" -k "Security Code" "coaps://192.168.0.15:5684/15001"
Parameters:
ON: 5850:1
OFF: 5850:0

Brightness: 5851: (brightness from 0 to 255)
Warm: 5709:33135  5710:27211
Cold: 5709:24930  5710:24684
Normal: 5709:30140  5710:26909
Bulb 1 ON:
./coap-client-raspbian -m put -u "Client_identity" -k "Security Code" -e '{ "3311": [{ "5850": 1 }] }' "coaps://192.168.0.15:5684/15001/65537"
Bulb half:
./coap-client-raspbian -m get -u "Client_identity" -k "djed8rbxLWVOdUWm" -e '{ "3311": [{ "5708": 128 }] }' "coaps://192.168.0.15:5684/15001/65537"

If you want to use this client in a Python program, you can install a so called “Python Wrapper”.

cd ~
sudo apt-get install python-pip
sudo pip install tqdm
git clone https://github.com/sandyjmacdonald/ikea-smartlight
cd ikea-smartlight

It consists of a few python programs and is installed in your home directory.

Navigate into its directory and create this file:

cdikea-smartlight
nano tradfri.cfg

and enter

[tradfri]
hubip = 192.168.0.15 (ip address)
securityid = Security Code

Now, you can discover the bulbs with a simple command:

./tradfri-status.py

or switch the lamps:

./tradfri-lights.py -l 65537 -a power -v on
./tradfri-lights.py -l 65537 -a power -v off
./tradfri-lights.py -l 65537 -a brightness -v 50
./tradfri-lights.py -l 65537 -a color -v warm
In video #140 we hacked the new IKEA Tradfri Smart lighting system using the remote control as a basis. And, as I said already in video #144: It worked, but had some major disadvantages. Today, we will use an IKEA Gateway and do it right! We will eliminate the problems of the current hack We will install and pair the gateway with two different bulbs We will learn how the system communicates We will switch the lights using node-red. Like that, we can use MQTT or many other tools to switch the lights If you are interested We will switch the lights with a normal Linux command We will install a Python wrapper. You can use this wrapper as a basis for your own programs We will see the CoAP protocol , which was introduced in the last video, in action At the end, as promised, I will reveal a “hot” secret about the IKEA bulbs. The major problem with the last hack was, that the remote control only toggled the on and off switch. So, we were never sure, if the bulb was really on or off. This works ok if you switch by hand, because you just press the button again, if something went wrong. For home automation systems, however, we need a concept with clear commands like “off” or “on”. And it would be nice, if we could read the actual state back to check, if everything went right. Ikea sells a Gateway for its lighting system, which promises to be able to do exactly that. You get it together with a Smartphone app for around 30 dollars.
Simple and cheap way to protect your super caps (video #139 )

Simple and cheap way to protect your super caps (video #139 )

4

In video #133 we used super capacitors to safely shutdown the Rapberry Pi. In the comments, viewers asked about over voltage protection of the super caps. I will show you a big and small and cheap possibility. And I will show you one concept which does not really work.

But why do we have to protect Super Capacitors? And how can we protect them? Most Super capacitors are only specified up to 2.7 volt. If we need higher voltages, we have to connect a few of them in series. To give the Raspberry a save shutdown I used two caps because it runs on 5 volt USB.

Video: https://www.youtube.com/watch?v=NsTAyD2i3rc

If we charge the capacitors, the same current I flows through each of the caps. If one cap has a smaller capacitance, it charges faster and its voltage can go above the maximum 2.7 volts. To prevent this, we can connect a resistor and a switch in parallel to the capacitors. If the switch is closed, part of the current flows through the resistor and the voltage stays below the 2.7 volts.

We also can replace the resistor and the switch by a 2.4 volts Zener diode

This is a solution for small currents. A better and cheaper solution is to replace the Zener diode with a TL431. This part behaves like a Zener diode with a variable Zener voltage. So, the final diagram looks like that:

 

A TL431 can handle up to 150 mA

The formula for the TL431 is: V=(1+R1/R2) x 2.5

And for the resistors: (R4=R2 and R3=R1): R2=0.08 x R1

If you want to use bug capacitors (>>10 F) you can buy ready made protectors:

It also uses a TL431, but it adds a small PNP transistor and a big NPN transistor (8A) to handle bigger currents (the SMD resistors handle max. 1.5A).

This diagram in the video was not correct (Q1)

Variable Speed Cooling Fan for Raspberry Pi using PWM (video#138)

Variable Speed Cooling Fan for Raspberry Pi using PWM (video#138)

, 19

In video #131 we pimped a Raspberry Pi. One of the new features was a cooling fan which switched automatically on if CPU temperature was too high. Viewers suggested to make the speed of the fan variable. And this is, what we will do today. We also will learn a few things about Pulse Width Modulation, PID controllers, MOSFET transistors, and even a little bit of magic.

So, let’s start: in video #131 I used a simple concept: A MOSFET transistor to switch the fan on and off and a Python program which measures the CPU temperature and switched the MOSFET on, when the temperature was too high. Very simple. I used a beefy IRLZ44N transistor, because it is logic level. In video #137 I showed, that these FETs switch on at a voltage of below 2.5 volt. This is, why they are ideal for microprocessors with 3.3 volt logic.

Usually, you should add two resistors to drive a FET: R1 to discharge the gate capacitance of the MOSFET, and R2 to limit the current which is created if you change the signal at the gate. R1 is usually a few k Ohms, and R2 a few 100 ohms.

A diode should be connected in parallel to the fan, because it has an inductance and inductors create high “reverse” voltages when switched on and off fast. In our case, R1 and R2 are built into the GPIO of the Raspberry and can be omitted. The diode is not mandatory for a small fan, but it is better to include one.

The python script has two tasks. It has to be started at boot. I described how this can be done in a earlier blog and in video #131.

The python script is at the same place. You can get it with the following command:

wget http://www.sensorsiot.org/transferFiles/Pi_Zero_MQTT_Broker/fanShutdownPWM.py

Please rename it to fan_shutdown.py:

 mv fanShutdownPWM.py fan_shutdown.py

Or adjust your startup file accordingly.

As a result, you should get a quite constant temperature of 45 degrees centigrade:

You can change this temperature on line 15 in the python file:

desiredTemp = 45 # The maximum temperature in Celsius after which we trigger the fan. If you use a different fan, it might be necessary to change the parameters of the PI controller:

pTemp=15
iTemp=0.4

 

 

 

 

Load More