Bembyho blog

Vaječný likér

Sat, 12 Dec 2020 00:00:00 +0100

Vaječný likér jsem nikdy neměl moc v oblibě. Když se řekne vaječnák, vybaví se mi Velikonoce a návšteva tety Jiřiny. Ta nám za našich mladých let, když usoudila, že nám ještě nebylo dost na to, abychom dostali štamrplu slivovice (tedy něco kolem patnácti), vždycky nalila minimálně půldecák jakési žluté táhnoucí se hmoty. Jelikož nám ale většinou jinde tu štamplu stejně nalili, pobila se nám tato mňamina v břichu dohromady se slivovicou, což mělo za následek, že minimálně jeden z nás ogarů Velikonoční štaci zdárně nedokončil a místo tradičního oběda u babičky skončil někde v křáku, kde to musel vydýchat, vyležet, či se poléčit jiným způsobem.

Nikdy mě tedy nelákalo vaječňák si někde dát, jelikož jsem to považoval za takové to hnusné tetičkovské pitíčko, až na mě někdě vzbafl příspěvek od Martina Žufánka o vaječnáku, ze kterého si cvrnknete do gatí. Ve svém příspěvku se pozastavoval nad tím, jak češi patlají vaječňáky z tuzemáku, salka a vanilinového cukru, tedy z věcí, které jsou lacinými napodobeninami originálů. Co dobrého asi může vzejít, když je člověk použije. No, asi něco jako vaječnák tety Jiřiny. Rozhodl jsem se tedy vyzkoušet jeho recept (ten vychází z receptu od Jany Florentýny Zatloukalové), založený na kvalitních surovinách a výsledek mě nadchl. Proto jsem se rozhodl recept na svém blogu zvěčnit, abych ho měl případně vždy po ruce.

Recept

Budeme potřebovat:

prázdnou 0,5 litrovou sklenici
4 žloutky
70 g moučkového cukru
1 lusk vanilky
250 ml 33% smetany
220 ml bourbonu
30 ml rumu
30 ml brandy

Výsledkem nám bude 0,5 litru vynikajícího vaječného likéru o obsahu alkoholu okolo 24%, který nás vyjde na asi 400 Kč.

Postup

Jelikož jsou základem vaječnáku syrové žloutky, je důležité dodržet při jeho přípravě určitá hygienická opatření, aby nám po týdnech ležení v ledničce sám neodešel, případně abychom si po jeho požití nemuseli hrát na Usaina Bolt na trase obyvák záchod. Proto ze všeho nejdříve ve varné konvici přivedeme k varu 0,5 litru vody a ještě vroucí nalejeme do připravené sklenice a necháme 10 minut stát. Tímto účinně lahev sterilizujeme. Po deseti minutách můžete vodu vylít a nechat sklenici okapat. V průběhu výroby vás to určitě bude lákat ochutnat, což je v pořádku, ale vemte si an to pokaždé čistou lžičku. Ve vaši puse žije spoustu breberek, kterým by vaječnák taky moc chutnal a taková olízlá lžička je pro ně expres lístek.

V misce nebo malém rendlíčku o objemu větším než 0,5 litru rozmícháme vidličkou žloutky, nejlépe od slepiček co mohly lítat po venku a dostalo se jim dobrého zobání, aby byly krásně žluté,cukr moučku a vnitřkem z vanilkového lusku. Lehce kvedláme, dokud nám nevznikne žlutá kašička s černýma ťupkama od vanilky. Do kašičky přidáme smetanu a opět lehce vidličkou mícháme, dokud se nám kašička se smetanou nespojí. Tímto máme hotový základ, který teď ochutíme alkoholem.

Přidáme bourbon, doporuču Bourbon Bulleit Frontier. Má lahodnou chuť a lehce medový nádech a přitom je to cenově dostupný alkohol. Dále přidáme 30 ml rumu, tím myslím opravdového třtinového rumu, ne tuzmemáku. Výběr nechám na vás, pokud se nechcete pouštět do neznámých vod, můžete sáhnout po rumu Republika nebo Heffron. Je to takový dotupný základ, jinak zvolte podle chuti. Poslední přísada je 30 ml brandy. Brandy je vinná pálenka, která zrála několik let v dubovém sudu. Já jsem se ji rozhodl nahradit vyzrálou ovocnou pálenkou, konkrétně vlastní meruňkovicí, co rok ležela v dubovém soudku. Pokud nemáte vlastní vyzrálou pálenku (pokud pálíte, určitě si soudek na zrání pořiďte, vyplatí se to), můžete použít některou z pálenek z dubového sudu od Žufánka.

Vše dobře vidličkou nebo metličkou promíchejte a nalejte do lahve. Výsledné množství by mělo vystačit na půl litru a ještě vám malá trocha zbyde na okamžité ochutnání. Lahev dejte na 3 týdny do lednice. Po třech týdnech se všechny chutě spojí, více vyniknou a likér získá krásnou žlutou barvu.

Nyní je likér hotov a zbýva si ho jen vychutnat. Na zdraví!

Measuring temperature with 1-Wire DS18B20 on Raspberry

Mon, 07 May 2018 00:00:00 +0200

1-Wire

In todays article we will look at an interesting 1-Wire technology and at how it works together with Raspberry. After the brief introduction, you can look forward to a practical demostration of how to use 1-Wire temperature sensor DS18B20.

1-Wire is a device communications bus system developed by Dallas Smiconductors, simply put, it is a technology providing communication between multiple devices. 1-Wire always has one master device, which runs the communications with the slave devices. This technology is usually used for small and cheap sensors, such as thermometers and other similar devices, that only need low power and transmit only small amounts of data. 1-Wire can work on relatively large distances and needs only 3 wires. Those are power supply, that can be anyting from 3V to 5V, ground and data. Slave devices are all conencted to the same triple of wires.

Raspberry and 1-Wire

If you want to work with 1-Wire devices on your Raspberry, you first need to enable the 1-Wire protocol. You can do this in Raspberry’s configuration and you have multiple options how to do it. You can change the configuration through the raspi-config wizard. Simply open the console and write:

sudo raspi-config

Which will give you this screen:

Select section 5 Interfacing options

Select P7 1-Wire

And select Yes to enable 1-Wire

The other option is more straightforward. You can edit the configuration file directly from any text editor, for example nano.

sudo nano /boot/config.txt

Scroll to the bottom of the file and add a new line with:

dtoverlay=w1-gpio

Save and close the file (press Ctrl+X, Y - as yes to changes and press Enter to confirm).

Now you are ready to go! Reboot you Raspberry:

sudo shutdown -r

And you can start connecting 1-Wire devices.

Connecting 1-Wire devices to Raspberry

Connecting 1-Wire devices to Raspberry is pretty easy, you only need 1 resistor with resistance between 4k7Ω and 10kΩ, that will be put between power supply and data line. That is it. For demonstration, we will use temperature sensors DS18B20. Get at least two, so we can see that 1-Wire is able to work with multiple devices, even in case they are of the same type.

Multiple devices on one line

As was said before, 1-Wire always has one master device, which runs the communication - this will be our Raspberry and can have multiple slave devices - those will be temperature sensors in our case and they are all connected to just one data line. You might be asking how will the Raspberry know, which temperature sensor is sending which data, if they both sit on the same wire and the answer is simple. Each 1-Wire device has its own internal ROM memory, that stores unique 64-bit long address or identifier if you want. Every time a sensor sends some data, it also includes its address, so Raspberry always knows, which sensor sent which data.

DS18B20 temperature sensor

For this tutorial, we are using DS18B20 temperature sensor which is a great sensor with high accuarcy and can handle big range of temperatures. All the details can be found in its datasheet, but lets just point out the important details:

power supply from 3V to 5V
measures temperatures from -55°C to +125°C (-67°F to +257°F)
accuarcy is ±0.5°C for temperatures ranging from -10°C to +85°C

It is also goot to know, which DS18B20 pins are for power supply, ground and data:

You can buy this sensor on Ebay, its price starts around 1.5 USD. This sensor comes also in a waterproof version, usually with a 2m cable, which makes it ideal for measuring temperatures in pools or refrigirators.

Detecting 1-Wire devices

Lets get into wiring so we can finally see some real outputs. Grab your Raspberry, DS18B20 sensors and one 4k7Ω resistor. By default, the 1-Wire input pin on Rasperry is GPIO 4 in BCM numbering, but you can change that if you want. Go back to Raspberry’s config file:

sudo nano /boot/config.txt

And change the line with

dtoverlay=w1-gpio

to:

dtoverlay=w1-gpio,gpiopin=X

where X is the desired BCM pin number. Nertheless, for this example, we will work with the default settings.

As was already mentioned before, wiring the sensors to the Raspberry is very simple, just connect the power and ground to corresponding sensor pins, connect GPIO4 with data pins and put the 4k7Ω resistor between the power and data line.

Now we are ready to read the temperature data. All connected 1-Wire devices will create a folder named after its unique identifier in /sys/bus/w1/devices/. To see the folders, use your command line:

ls /sys/bus/w1/devices/

In my case it gives me this output:

28-000009f8259a  28-000009f96000  w1_bus_master1

Lets ignore the w1_bus_master1, the rest of the folders are our sensors. The first two digits tell us, what kind of a sensor we are dealing with, 28 stands for DS18B20 temperature sensor, so everything is working as expected.

Detecting all 1-Wire devices

I have written a neat python script, that prints out data about all connected 1-Wire devices. You can find it on my Gitlab repository for this tutorial. Grab it directly from command line:

git clone git@gitlab.com:bambusekd-dev-blog/raspberry-1-wire-temperature-ds18b20.git

There are two files in this repository, for detecting devices, use the w1-devices.py. So in your command line:

cd raspberry-1-wire-temperature-ds18b20
python w1-devices.py

The output for me is:

 _______________________
|
| Device #1
| Type:        temperature sensor
| ID:          000009f96000
| Sensor type: DS18B20
|_______________________

 _______________________
|
| Device #2
| Type:        temperature sensor
| ID:          000009f8259a
| Sensor type: DS18B20
|_______________________

Reading data from DS18B20

To read the actual measured sensor data, we need to read the contents of a file called w1_slave, that is included in each device file in /sys/bus/w1/devices/. To do that, use your command line and don’t forget to change the folder name to the name of your sensors:

cat /sys/bus/w1/devices/28-000009f8259a/w1_slave

I get this output:

92 01 4b 46 7f ff 0e 10 24 : crc=24 YES
92 01 4b 46 7f ff 0e 10 24 t=25125

WTF is this might be your first reaction, but everything we need to know is written in this output. Lets have a look at the end of the first line. Here we can see if the information was received error-free. If the word says YES, we are fine, if it states NO, there was some problem. At the end of the second line, we have the measured temperature, it just needs to be divided by 1000. So t=25125, gives us 25125/1000 = 25.125°C. Pretty hot day for May in Brno.

Usually, you want to read the measured data automatically running a script, so doing it in a command line is not very practical. So lets write a Python script, that will do it for us.

Reading DS18B20 sensor data in Python

If you have already downloaded my Gitlab repository for this tutorial, you can find the script there under w1-read-temperature-ds18b20.py. It detects all DS18B20 sensors and prints out the mesured temperature. Running the script

python w1-read-temperature-ds18b20.py

will output something like this:

 _________________________
|
| Measurement from: 2018-05-07 18:42:41
|________
|
| Thermometer 28-000009f96000
| Celsius:    25.25
| Fahrenheit: 77.45
|________
|
| Thermometer 28-000009f8259a
| Celsius:    25.062
| Fahrenheit: 77.1116

For completness, I am including the script also directly into this blog post below. Read the in code comments to understand the functionality.

#!/usr/bin/python

import os
import re
from glob import glob
import time

# Folder with 1-Wire devices
w1DeviceFolder = '/sys/bus/w1/devices'

# Function that returns array with IDs of all found thermometers
def find_thermometers():
    # Get all devices
    w1Devices = glob(w1DeviceFolder + '/*/')
    # Create regular expression to filter only those starting with '28', which is thermometer
    w1ThermometerCode = re.compile(r'28-\d+')
    # Initialize the array
    thermometers = []
    # Go through all devices
    for device in w1Devices:
        # Read the device code
        deviceCode = device[len(w1DeviceFolder)+1:-1]
        # If the code matches thermometer code add it to the array
        if w1ThermometerCode.match(deviceCode):
            thermometers.append(deviceCode)
    # Return the array
    return thermometers

# Function that reads and returns the raw content of 'w1_slave' file
def read_temp_raw(deviceCode):
    f = open(w1DeviceFolder + '/' + deviceCode + '/w1_slave' , 'r')
    lines = f.readlines()
    f.close()
    return lines

# Function that reads the temperature from raw file content
def read_temp(deviceCode):
    # Read the raw temperature data
    lines = read_temp_raw(deviceCode)
    # Wait until the data is valid - end of the first line reads 'YES'
    while lines[0].strip()[-3:] != 'YES':
        time.sleep(0.2)
        lines = read_temp_raw(deviceCode)
    # Read the temperature, that is on the second line
    equals_pos = lines[1].find('t=')
    if equals_pos != -1:
        temp_string = lines[1][equals_pos+2:]
        # Convert the temperature number to Celsius
        temp_c = float(temp_string) / 1000.0
        # Convert the temperature to Fahrenheit
        temp_f = temp_c * 9.0 / 5.0 + 32.0
        # Return formatted sensor data
        return {
            'thermometerID': deviceCode,
            'celsius': temp_c,
            'fehrenheit': temp_f
        }

# Function that pretty prints the sensor data
def print_temperature(data):
    print '|________'
    print '|'
    print '| Thermometer {}'.format(data['thermometerID'])
    print '| Celsius:    {}'.format(data['celsius'])
    print '| Fahrenheit: {}'.format(data['fehrenheit'])

# Function that prints actual timestamp
def print_timestamp(): 
    print ' _________________________'
    print '|'
    print '| Measurement from: ' + time.strftime('%Y-%m-%d %H:%M:%S')

# Main function
def main():
    # Find all connected thermometers
    thermometers = find_thermometers()
    # Print actual timestamp
    print_timestamp()
    # Go through all connected thermometers
    for thermometer in thermometers:
        # Pretty print sensor data
        print_temperature(read_temp(thermometer))
    
# Run the main function when the script is executed
if __name__ == "__main__":
    main()

If everything worked, then congratz! You have successfuly configured, wired and read 1-Wire sensor data!

Psí výběh Brno-Vinohrady

Sat, 03 Mar 2018 00:00:00 +0100

Participativní rozpočet Brno

Brno v roce 2017 spustilo projekt Dáme na Vás, ve kterém sbírá nápady od svých občanů na vylepšení našeho města. Pokud má někdo námět na něco, co by se mohlo v Brně postavit, uspořádat, vylepšit nebo revitalizovat, má možnost svůj nápad jednoduchou cestou přihlásit do projektu - stačí sepsat stručný popis projektu, udělat nástřel rozpočtu a je to. Aby se město začalo projektem zabývat, potřebuje člověk 300 lajků nebo 30 podpisů od Brňáků. Po získání podpory projekt projde posouzením, zda je realizovatelný a pokud ano, postupuje do závěrečného hlasování. V tom se rozhodne, opět podle hlasů Brňáků, které projekty se budou realizovat.

Po prvním ročníku, ve kterém se nakonec vybralo 16 projektů, které by se měly v letošním roce (2018) začít realizovat, byl v únoru spuštěn ročník druhý. Vzhledem k tomu, že bydlím na brněnských Vinohradech a přijde mi, že je tady spoustu věcí ke zlepšení, rozhodl jsem se přispět svou troškou do mlýna a vypracovat návrh na psí výběh, který tady na Vinohradech chybí. V okolních městských částech se už několik výběhů vybudovalo a myslím si, že svou funkci plní perfektně. Lidé mohou své pejsky vypustit v oploceném výběhu, beze strachu, že jim někam utečou, což má za důsledek méně na volno puštěných pejsků na sídlišti samotném. Pejskaři mají své místo, kam s pejsky zajít a ti, kteří pejsky nemusí, mohou být o to víc v klidu, jelikož místo v ulicích pejsci lítají a blbnou právě ve výběhu.

Psí výběh na Vinohradech

Vinohradům, jakožto hustě zastavenému sídlišti dle mého psí výběh citelně chybí, jelikož zde není žádné větší prostranství, kde by bylo možné psy venčit, aniž by měl člověk obavy s možnou kolizí s automobily a byl alespoň trochu mimo panelákovou zástavbu a cítil se jako v přírodě. V okolních městských částech v posledních letech pěkné psí výběhy vznikly a všichni si je chválí. Spoustu místních pejskařů si tak přeje, aby psí výběh existoval i zde na Vinohradech.

Abych byl přesný, na Vinohradech psí výběh existuje. Nachází se za bývalou ZŠ na Bzenecké ulici, ale je to jen kus louky, bez jakéhokoliv oplocení, pouze s jedním košem na odpadky, na kterém je cedule “Výběh pro psy” a pro mě prapodivnými dřevěnými konstrukcemi, nad jejichž významem stále bádám - snad opěrné “lavičky”, překážky pro medvědy… netuším. Zkuste si tipnout sami, viz foto níže.

Pro tento výběh nevýběh jsem se pokusil navrhnout novou podobu. Původně jsem chtěl pro návrh využít veškeré volné prostranství na stávajícím místě, kde by výběh mohl mít plochu zhruba 1500 m2.

Bohužel jsem zjistil, že ne všechny pozemky na tomto místě jsou města Brna a tak bylo nutné projekt předělat na menší, zhruba 879 m2 velký výběh. Ten je již čistě na pozemcích města.

Výběh bude oplocený (asi 126 metrů plotu) s jednou brankou s přístupem od cesty. Na cestě by se nově vybudoval bezbariérový přechod, aby se do výběhu dostali i lidé s omezenou možností pohybu.

Přístupová cesta by byla vydlážděna zámkovou dlažbou, stejně tak jako malý ostrůvek uvnitř výběhu (36 m2), podél jehož okraje by byly dvě lavičky a mezi nimi strom. Tento ostrůvek bude zajišťovat, že se do výběhu dostanou lidé “suchou nohou” i za horšího počasí a budou mít odkud pozorovat své mazlíčky. Osvětlení budou zajišťovaly dvě lampy. Na okraji ostrůvku je umístěno pítko, pro zahnání žízně jak lidí, tak psů. Uvažoval jsem i o nádobě na vodu pro psy, ale byl jsem upozorněn, že by to z hlediska hygieny nebylo dobré, aby všichni psi pili z jedné společné nádoby, jelikož by se tak mohly velmi úspěšně mezi nimi šířit nemoci. U vchodu do výběhu jsou umístěny koše zvlášť na odpadky a zvlášť na psí exkrementy.

Samotný výběh je volně rozdělen na dvě části. První z nich je lesík s asi 9 stromy, ve kterém v létě najdou lidé i psi stínek, druhou je pak část s překážkami pro psy a prostorem například pro hru s míčkem/diskem.

Rozpočet

I když takový výběh může vypadat jako levná záležitost, při práci na rozpočtu a hledání cen člověk zjistí, že se jednotlivé položky rychle nastřádají. Hrubý návrh rozpočtu pro tento projekt mi vyšel na nějakých 414 400 Kč, tedy skoro půl milionu. Počítám ale, že je to spíše dolní odhad možné ceny. Jednotlivé položky jsou rozepsány v následující tabulce.

položka	cena za kus	množství	cena celkem
lavička	4000	2	8000
koš na odpadky	3000	1	3000
koš na exkrementy	3000	1	1000
lampa	10000	2	20000
dlažba	700	36 m2	25200
překážky pro psy	7000	5	35000
stromy	3000	10	30000
plot a branka	200	126 m2	25200
pítko	15000	1	15000
chodník a přechod	100000	1	100000
projekt	50000	1	50000
práce	100000	1	100000
celkem			414400

Projekt

Návrh projektu jsem vypracoval ve SketchUp. Nejsem žádný architekt ani modelář, takže prosím o shovívavost. Projekt je možné nalézt přímo ve skladu modelů.

Po kliknutí na obrázek pod tímto odstavcem, by se měl spustit 3D model, ve kterém si návrh můžete prohlédnout ze všech stran.

Zde je pohled na celý výběh shora.

Model jsem se pokusil zasadit i přímo do pohledu na stávající výběh.

Pokud se vám můj návrh na projekt líbí, budu rád za jakoukoliv podporu - projekt najdete oficiálně zde. Pro zájemce je možné všechny zdrojové i výsledné vyexportované soubory najít na mém Gitlab repozitáři. Pokud máte nějaké dotazy, nápady na vylepšení nebo kritiku, budu rád pokud se ozvete pod článkem v komentářích nebo mi napíšete mail na můj email. Díky!

Parking sensor made with HC-SR04 and Raspberry

Wed, 24 Jan 2018 00:00:00 +0100

Parking sensor

In today’s article, we are going to build a parking sensor. Most of you are for sure familiar with that beeping sound in your car that starts every time you start to back your car and tells you, by changing the beeping frequency, how far your rear spoiler is from the closest obstacle. If you are not, I have just described to you what a parking sensor is. We will build a simple circuit with Raspberry Pi and HC-SR04 ultrasonic range sensor, that will simply beep according to how far it is from an obstacle. No beeping will tell us that everything around us is far away. Slow beeping will start as we will be getting closer and the closer we will be the higher will the beeping frequency be. At last, our sensor wil will beep constantly as we reach dangerously close position to our obstacle.

Distance sensor HC-SR04

HC-SR04 is an ultrasonic range sensor. I have already written an article about JSN-SR04T sensor, which is also an ultrasonic range sensor, so if you want to know how exactly such a sensor works, go ahead and read the other article, and then come back here for the rest of the tutorial. But in a nutshell - an ultrasonic sensor has two membranes (those two tubes on HC-SR04). One sends a sound wave (on a high frequency, so we do not hear it), which travels to an obstacle, where it is reflected back to the sensor, where the second membrane registers it as it comes back and immediately sets one of its output pins to HIGH value. To measure the distance, we just take the time between sending the wave and receiving it, divide it by two, because it had to travel there and back and since we know how fast sound travels, we can compute how far the obstacle is.

HC-SR04 can measure distances from 2cm to 4 meters in angle up to 15 degrees and needs at least 5V to operate. When doing consecutive measurements, we should always wait at least 60ms between two of them, in order to reduce interference that could be caused by too many signals travelling there and back.

Connecting it to Raspberry

HC-SR04 has 4 pins, VCC which needs to be connected to 5V input, GND that has to be connected to ground and then two control pins TRIGGER and ECHO. In order to make the sensor send a sound wave, we need to send at least 10µs long HIGH pulse to TRIGGER pin. That means we will connect the pin with a GPIO, set it to OUTPUT mode and instruct Raspberry to set the GPIO to LOW, then very shortly to HIGH and back to LOW. At the point, when TRIGGER will switch from HIGH to LOW, the sensor will send a sound pulse. The second pin - ECHO is always in LOW, except for the moment, when it registers incoming sound wave, then it will shortly rise to HIGH. ECHO therefore needs to be connected to a GPIO set to INPUT mode, where we will be waiting for it to jump to HIGH. So far it seems like a straightforward and easy setup, but there is one catch. We can not connect ECHO pin directly to GPIO. ECHO in HIGH state gives 5V which is too high for Raspberry and could damage it. Raspberry operates with 3,3V as HIGH value, so we need to reduce the voltage coming from ECHO.

Voltage Divider

But worry not, reducing voltage from higher value to a lower one is very easy and we will only need two resistors. Lets take 330Ω and 470Ω. Put 330Ω resistor between ECHO output and GPIO, then 470Ω resistor between ground and the point where 330Ω resistor meets the GPIO connection. See the the complete circuit schema below for better understanding.

The thing we just build with resistors is called a voltage divider. 5V coming from the source will be divided on resistors, serially connected, according to their resistance ratio, which is in our case 330:470. To better understand how exactly voltage divider works, lets ignore the rest of the Raspberry circuit and just see the resistors as is illustrated on the image below.

Vin is our 5V source. Vout is the place between resistors, from where we will be taking the lowered voltage for GPIO input. Ground is obviously the last end of circuit marked with shrinking lines. Resistors are marked as Z1 and Z2. If you remember Ohm’s law, which is the cornerstone of electronics, it says that voltage is equal to resistance multiplied by current.

U = R * I

We also know, that if all the parts of circuit are in a series, which is our case, the current flowing through them will be the same. And last important thing - in serial circuit the total resistance is the sum of resistance of all resistors. Taking all of this into account, we can count the current flowing through the circuit.

From

U = R * I

we see that

I = U/R

which is

I = U/(Z1+Z2)

Putting the known numbers to equation we get that

I = 5/800 = 0.00625A = 6.25mA

OK, we have the current value, so now we can count what voltage is on each of the two resistor. Keep in mind that voltage is always measured between two points in circuit. Measuring voltage on Z1 equals to measuring voltage between Vin and Vout.

Take again Ohm’s law

U = R * I

now we know

I = 0.00625A

and

R = Z1 = 330Ω

Uz1 = 0.00625 * 330 = 2.0625V

And lets do the same with the second resistor, measuring voltage between points Vout and ground will give us

Uz2 = 0.00625 * 470 = 2.9375V

We can check that our calculations are correct by adding those two voltage values together. They will give us 5V so we see that no voltage disappeared and really divided according to value of resistors. All right, so the voltage got divided, now only the last step. Which of those values will be the voltage on Vout? Well, voltage is always measured against ground, so the correct answer is 2.9V - the voltage between Vout and ground which is equal to our Uz2. This might be a bit counter intuitive if you think of a current flowing from the source, where we have 5V, down to the ground, where it might be tempting to see it as it will partially ‘leak’ on Vout, so you would think the voltage between Vin and Vout is the correct answer, but no. Always remember that voltage is a value that is measured between two points, where one is ground. If you don§t believe me, just build the circuit and measure it…

Also, you might be thinking - you said we need 3.3V, but we have 2.9V, why such a weird number. Well, we could easily deduct, that to get 3.3V from 5V we would need a resistors with 1:2 ratio, so lets say 1000Ω and 2000Ω, but the most common resistors usually don§’ have this exact value, so we are using the closet we have in this case 330Ω and 470Ω, which gives us 330:470 = 1:1.42 ratio, which is close enough.

Raspberry’s input GPIO doesn’t necessarily need 3.3V to turn to HIGH state, in fact Raspberry will take anything between 1.3V and 3.3V as HIGH and anything between 0V and 0.8V as LOW, which is great, because we don’t have to be that precise when building our circuits.

Buzzer

Last part of our circuit will be a buzzer. It is a simple electronic component, that simply beeps if it is connected to the source and it is silent when it is disconnected. We will use it to acknowledge the “driver” of an approaching obstacle. Buzzer comes it many variants, be sure to buy one that is made for 3.3V voltage that our Raspberry GPIO gives us when it is in HIGH state. Connect the buzzer to a GPIO set to OUTPUT mode and to the ground.

Coding the sensor

Now lets create a file called parking_sensor.py and write a function distance, that will measure how far the obstacle is from the sensor. It will be similar to the code from article about JSN-SR04T:

#!/usr/bin/python

# Import required Python libraries
import RPi.GPIO as GPIO
import time

# We will be using the BCM GPIO numbering
GPIO.setmode(GPIO.BCM)

# Select which GPIOs you will use
GPIO_BUZZER = 18
GPIO_TRIGGER = 23
GPIO_ECHO = 22

# Set BUZZER to OUTPUT mode
GPIO.setup(GPIO_BUZZER, GPIO.OUT)
# Set TRIGGER to OUTPUT mode
GPIO.setup(GPIO_TRIGGER, GPIO.OUT)
# Set ECHO to INPUT mode
GPIO.setup(GPIO_ECHO, GPIO.IN)

# Measures the distance between a sensor and an obstacle and returns the measured value
def distance():
  # Send 10 microsecond pulse to TRIGGER
  GPIO.output(GPIO_TRIGGER, True) # set TRIGGER to HIGH
  time.sleep(0.00001) # wait 10 microseconds
  GPIO.output(GPIO_TRIGGER, False) # set TRIGGER back to LOW
 
  # Create variable start and assign it current time
  start = time.time()
  # Create variable stop and assign it current time
  stop = time.time()
  # Refresh start value until the ECHO goes HIGH = until the wave is send
  while GPIO.input(GPIO_ECHO) == 0:
    start = time.time()
 
  # Assign the actual time to stop variable until the ECHO goes back from HIGH to LOW = the wave came back
  while GPIO.input(GPIO_ECHO) == 1:
    stop = time.time()
 
  # Calculate the time it took the wave to travel there and back
  measuredTime = stop - start
  # Calculate the travel distance by multiplying the measured time by speed of sound
  distanceBothWays = measuredTime * 33112 # cm/s in 20 degrees Celsius
  # Divide the distance by 2 to get the actual distance from sensor to obstacle
  distance = distanceBothWays / 2

  # Print the distance to see if everything works correctly
  print("Distance : {0:5.1f}cm".format(distance))
  # Return the actual measured distance
  return distance

# Main function
def main():
  try:
    distance()
    time.sleep(1) # Pause between measurements
  # If the program is ended, stop beeping and cleanup GPIOs
  except KeyboardInterrupt:
    GPIO.cleanup()

# Run the main function when the script is executed
if __name__ == "__main__":
    main()

If you run the script from your Raspberry

python parking_sensor.py

it will print the distance each second. That is nice, but lets add the beeping. We will write another function, that will count how fast the buzzer should beep = beeping frequency. If the obstacle is more than 50cm from the sensor, it will not beep, that will be marked by value -1. If the obstacle will be closer than 50cm, but further than 30cm, we will beep once per second - value returned will be 1. If the distance will be between 30cm and 20cm, we will beep twice a second - value returned will be 0.5. For distances between 20cm and 10 cm, we will beep four times a second - value returned will be 0.25. If we will be in a dangerously close position, that is closer than 10cm to obstacle, buzzer will beep constantly - value returned will be 0. Lets put that into code.

# Calculates the frequency of beeping depending on the measured distance
def beep_freq():
  # Measure the distance
  dist = distance()
  # If the distance is bigger than 50cm, we will not beep at all
  if dist > 50:
    return -1
  # If the distance is between 50 and 30 cm, we will beep once a second
  elif dist <= 50 and dist >=30:
    return 1
  # If the distance is between 30 and 20 cm, we will beep every twice a second
  elif dist < 30 and dist >= 20:
    return 0.5
  # If the distance is between 20 and 10 cm, we will beep four times a second
  elif dist < 20 and dist >= 10:
    return 0.25
  # If the distance is smaller than 10 cm, we will beep constantly
  else:
    return 0

The only thing left is to adjust the main function to make the buzzer beep in our given frequency. We will do that by writing a simple if-else statement with result from the beep_freq function.

  # Main function
def main():
  try:
    # Repeat till the program is ended by the user
    while True:
      # Get the beeping frequency
      freq = beep_freq()
      # No beeping
      if freq == -1:
        GPIO.output(GPIO_BUZZER, False)
        time.sleep(0.25)
      # Constant beeping
      elif freq == 0:
        GPIO.output(GPIO_BUZZER, True)
        time.sleep(0.25)
      # Beeping on certain frequency
      else:
        GPIO.output(GPIO_BUZZER, True)
        time.sleep(0.2) # Beep is 0.2 seconds long
        GPIO.output(GPIO_BUZZER, False)
        time.sleep(freq) # Pause between beeps = beeping frequency
  # If the program is ended, stop beeping and cleanup GPIOs
  except KeyboardInterrupt:
    GPIO.output(GPIO_BUZZER, False)
    GPIO.cleanup()

And that is it! The complete code is right below this paragraph and you can also get it from my Gitlab. Well done, you have just successfully built your own parking sensor. Enjoy experimenting with it!

Complete program

#!/usr/bin/python

# Import required Python libraries
import RPi.GPIO as GPIO
import time

# We will be using the BCM GPIO numbering
GPIO.setmode(GPIO.BCM)

# Select which GPIOs you will use
GPIO_BUZZER = 18
GPIO_TRIGGER = 23
GPIO_ECHO = 22

# Set BUZZER to OUTPUT mode
GPIO.setup(GPIO_BUZZER, GPIO.OUT)
# Set TRIGGER to OUTPUT mode
GPIO.setup(GPIO_TRIGGER, GPIO.OUT)
# Set ECHO to INPUT mode
GPIO.setup(GPIO_ECHO, GPIO.IN)

# Measures the distance between a sensor and an obstacle and returns the measured value
def distance():
  # Send 10 microsecond pulse to TRIGGER
  GPIO.output(GPIO_TRIGGER, True) # set TRIGGER to HIGH
  time.sleep(0.00001) # wait 10 microseconds
  GPIO.output(GPIO_TRIGGER, False) # set TRIGGER back to LOW
 
  # Create variable start and assign it current time
  start = time.time()
  # Create variable stop and assign it current time
  stop = time.time()
  # Refresh start value until the ECHO goes HIGH = until the wave is send
  while GPIO.input(GPIO_ECHO) == 0:
    start = time.time()
 
  # Assign the actual time to stop variable until the ECHO goes back from HIGH to LOW = the wave came back
  while GPIO.input(GPIO_ECHO) == 1:
    stop = time.time()
 
  # Calculate the time it took the wave to travel there and back
  measuredTime = stop - start
  # Calculate the travel distance by multiplying the measured time by speed of sound
  distanceBothWays = measuredTime * 33112 # cm/s in 20 degrees Celsius
  # Divide the distance by 2 to get the actual distance from sensor to obstacle
  distance = distanceBothWays / 2

  # Print the distance to see if everything works correctly
  print("Distance : {0:5.1f}cm".format(distance))
  # Return the actual measured distance
  return distance

# Calculates the frequency of beeping depending on the measured distance
def beep_freq():
  # Measure the distance
  dist = distance()
  # If the distance is bigger than 50cm, we will not beep at all
  if dist > 50:
    return -1
  # If the distance is between 50 and 30 cm, we will beep once a second
  elif dist <= 50 and dist >=30:
    return 1
  # If the distance is between 30 and 20 cm, we will beep every twice a second
  elif dist < 30 and dist >= 20:
    return 0.5
  # If the distance is between 20 and 10 cm, we will beep four times a second
  elif dist < 20 and dist >= 10:
    return 0.25
  # If the distance is smaller than 10 cm, we will beep constantly
  else:
    return 0

# Main function
def main():
  try:
    # Repeat till the program is ended by the user
    while True:
      # Get the beeping frequency
      freq = beep_freq()
      # No beeping
      if freq == -1:
        GPIO.output(GPIO_BUZZER, False)
        time.sleep(0.25)
      # Constant beeping
      elif freq == 0:
        GPIO.output(GPIO_BUZZER, True)
        time.sleep(0.25)
      # Beeping on certain frequency
      else:
        GPIO.output(GPIO_BUZZER, True)
        time.sleep(0.2) # Beep is 0.2 seconds long
        GPIO.output(GPIO_BUZZER, False)
        time.sleep(freq) # Pause between beeps = beeping frequency
  # If the program is ended, stop beeping and cleanup GPIOs
  except KeyboardInterrupt:
    GPIO.output(GPIO_BUZZER, False)
    GPIO.cleanup()

# Run the main function when the script is executed
if __name__ == "__main__":
    main()

Measuring distance with JSN-SR04T and Raspberry

Mon, 21 Aug 2017 00:00:00 +0200

Distance sensor JSN-SR04T

If you are in need of measuring distances with your Raspberry, this tutorial is what you where looking for. In this article, we will look at a JSN-SR04T ultrasonic distance sensor. Which is an affordable sensor for your robotics/home automation/whatever project. Its price starts on $7 on Ebay. For this price you will get a waterproof sensor, that can measure distances between 20cm to 600cm and should work in temperatures from -20°C to +70°C. It claims to have an accuracy of ±1cm, but lets be honest, there are so many things that can influence the measuring, that you will get a higher fluctuance in your measurements than that. This is how it looks like…

How to measure distance with sound

JSN-SR04T and ultrasonic distance sensor in general works on a simple principle. It sends an acoustic wave (ultrasonic, so you won’t hear it) when it is triggered and then listens for when the wave reflects from some obstacle in front of it and comes back. However, the sensor is only able to send the wave and tell that a wave came back, you will have to do the math to count the distance by yourself (read, you will have to program it by yourself). But read further and you will see it is really easy.

From the sensor specification we can find out that the sensor is activated by sending a pulse of HIGH, which is at least 10µs (microseconds) long, on the TRIGGER pinout. Which means that if you want to send a wave, you will need to have a GPIO set to OUTPUT mode, connect it to the TRIGGER pinout and have it set to LOW, then set in to HIGHT for at least 10µs and then set it back to LOW. Shortly after this pulse is received by the sensor (TRIGGER goes from HIGHT back to LOW), the ECHO pinout will go HIGH and the sensor will send a wave at the same time. The ECHO pinout will remain in HIGH position until it receives the wave back, at that moment the ECHO will go back to LOW. Therefore you will need one more GPIO set to INPUT mode and connect it to the ECHO pinout. Then in your program, you will have to wait until it goes HIGHT, then start counting, wait until it goes back to LOW as it received the wave back and then stop the counting. The time you measure is the time a sound wave spend going to the obstacle and back to the sensor.

Thanks to many clever minds who did research on speed of sound we now know, that it travels around 332 meters per second at 20°C, keep in mind that it slightly changes with different air temperature. To be more precise, use this equation to count the speed for your conditions (it assumes the air humidity is 0% and that temperature is in °C):

speedOfSound = (331.3 + 0.606 * temperature) m/s

To tell the distance we only need to multiply the speed of sound with the measured time and divide it by two. That is because the sound wave had to go the distance twice - to the obstacle and back to the sensor. And viola! We have measured the distance! Now lets go connect the sensor to the Raspberry and write a program to count the distances for us…

Connecting it to Raspberry

JSN-SR04T sensor has four pinouts. First pair is VCC and GND for obvious purpose of connecting it to 5V power and grounding it. And the second pair is TRIGGER and ECHO that we already mentioned in previous section. So simply connect the VCC to 5V, GND to GND, ECHO to a GPIO & TRIGGER to different GPIO. Simple.

Reading the distance

Now lets create a file called distance.py and write the actual code:

#!/usr/bin/python

# Import required Python libraries
import time               # library for time reading time
import RPi.GPIO as GPIO   # library to control Rpi GPIOs

def main():
  # We will be using the BCM GPIO numbering
  GPIO.setmode(GPIO.BCM)

  # Select which GPIOs you will use
  GPIO_TRIGGER = 23
  GPIO_ECHO    = 24

  # Set TRIGGER to OUTPUT mode
  GPIO.setup(GPIO_TRIGGER,GPIO.OUT)
  # Set ECHO to INPUT mode
  GPIO.setup(GPIO_ECHO,GPIO.IN)

  # Set TRIGGER to LOW
  GPIO.output(GPIO_TRIGGER, False)

  # Let the sensor settle for a while
  time.sleep(0.5)

  # Send 10 microsecond pulse to TRIGGER
  GPIO.output(GPIO_TRIGGER, True) # set TRIGGER to HIGH
  time.sleep(0.00001) # wait 10 microseconds
  GPIO.output(GPIO_TRIGGER, False) # set TRIGGER back to LOW

  # Create variable start and give it current time
  start = time.time()
  # Refresh start value until the ECHO goes HIGH = until the wave is send
  while GPIO.input(GPIO_ECHO)==0:
    start = time.time()
  # Assign the actual time to stop variable until the ECHO goes back from HIGH to LOW
  while GPIO.input(GPIO_ECHO)==1:
    stop = time.time()

  # Calculate the time it took the wave to travel there and back
  measuredTime = stop - start
  # Calculate the travel distance by multiplying the measured time by speed of sound
  distanceBothWays = measuredTime * 33112 # cm/s in 20 degrees Celsius
  # Divide the distance by 2 to get the actual distance from sensor to obstacle
  distance = distanceBothWays / 2
  # Print the distance
  print("Distance : {0:5.1f}cm".format(distance))

  # Reset GPIO settings
  GPIO.cleanup()

# Run the main function when the script is executed
if __name__ == "__main__":
    main()

You can get the code also from my GitLab or just clone the repo to your Raspberry.

git clone https://gitlab.com/bambusekd-dev-blog/raspberry-measure-distance-jsn-sr04t.git

Once you have the code ready, fire up your terminal on Raspberry, navigate to the folder with your script, point the sensor somewhere and run the script.

python distance.py

If everything worked as it should, you should see message similar to this in your terminal:

Distance : 25.1cm

Good job, you have successfully measured a distance between an obstacle and your sensor!

Some last thoughts

You should always bare in mind, that this sensor has limited capabilities. You have to setup it properly, make sure it points to the place whose distance you desire to measure and also that the speed of sound differs in different temperature/humidity. Also Python’s time library is not the best tool for precise time measurement. For greater precision, I would recommend to use a C program rather than Python. But worry not, if you can tolerate some inaccuracy, then there is no problem using Python and the code provided above. Happy hacking!

Reading temperature & humidity from DHT sensors with Raspberry

Wed, 16 Aug 2017 00:00:00 +0200

DHT sensors

Have you ever wanted to build your own weather station? Then read further, because today we are going to look at how to measure temperature and humidity with our Raspberry! We are going to use DHT11/22 sensor, which you can get on Ebay for 1 to 4 dollars, depending on the type and accessory that comes with it. These sensors are smaller that s match box and quite accurate. There are two basic models of the sensor - DHT11 and DHT22, you can find their characteristics below. Generally DHT11 is cheaper and less accurate than DHT22, but the price of DHT22 is still so low that there is no reason why you should hesitate and not buy the 22 version.

The sensor can come as a bare “mini plastic box” with 4 pinouts or it can be mounted on a board and have 3 pinouts. The difference is that the version mounted on the board already has a pull-down resistor connected to it and you don’t have to worry about a NULL pin, which doesn’t have any purpose for us, on the “bare” version. The three remaining pinouts are for power input, ground and data output, how simple! Bare in mind that if you have the version without the board, you will also need a 4.7kΩ-10kΩ resistor to make it work properly!

This sensors is able to measure temperature and humidity. If you would cut the plastic box guarding the inner parts of the sensor, you would find two separate sensors there. A thermistor for temperature readings, which is simply a variable resistor that changes its resistance according to the temperature. And second sensor for humidity readings, that consists of two electrodes and a moisture holding substrate between them. This substrate sucks humidity from its surroundings - changing its conductivity, which then changes the resistance between the two electrodes.

DHT11

attribute	value
cost	starting on $1
power	3-5V
humidity	reads values from 20% to 80% with 5% accuarcy
temperature	reads values from 0°C to 50°C ±2°C accuracy
reading interval	1Hz - can read values every second

DTH22

attribute	value
cost	starting on $3
power	3-5V
humidity	reads values from 0% to 100% with 2-5% accuracy
temperature	reads values from -40°C to 80°C ±0.5°C accuracy
reading interval	0.5Hz - can read values every 2 seconds

Connecting it to Raspberry

Connecting the sensor to Raspberry is pretty simple. You can choose weather to use 3.3V or 5V output from your Raspberry to connect it to VCC pin, then connect Raspberry’s GROUND to GND and choose one GPIO to connect in to DATA pin. If you have the version not mounted on the board, connect 4.7kΩ-10kΩ resistor between VCC and DATA.

Reading the temperature

Now we have everything connected and ready to read the actual temperature and humidity from our sensor. To read the actual values, we will use a python library from Adafruit, because these amazing guys already did the hard work and figured out how to translate the changing resistance of temperature/humidity sensors to human readable values. I have forked the library and you can freely download it from my Gitlab. Remember that you need python and git to be installed on your Raspberry to make this work! Lets go step by step and measure something finally!

Open a terminal on your Raspberry and install python and git if you don’t have it yet

sudo apt-get update
sudo apt-get install git build-essential python-dev python-openssl

Now download the Adafruit DHT library and open the folder

git clone https://gitlab.com/bambusekd-dev-blog/raspberry-read-temperature-humidity-DHT.git

Install the library

sudo python setup.py install

Great, now go to the examples folder

cd examples

And here we go, there is a python script AdafruitDHT.py that takes two arguments. First one is type of your sensor, so 11 for DHT11 and 22 for DHT22. The second one is the GPIO number (BCM number) that the DATA pinout is connected to. So if you have connected the sensor to GPIO 4, that translates to number 7 in BCM, just execute

sudo ./AdafruitDHT.py 22 4

And you should see the measured temperature and humidity, something like this

Temp=22.0*  Humidity=60.0%

Congratz! You are now running a small weather station!

Controlling 5V relay with Raspberry

Thu, 10 Aug 2017 00:00:00 +0200

Relay

In todays article, we are going to have a look at an electronic component called relay. In case that you have never heard of it, it is simply a mechanical switch, that can be controlled by low level voltage (starting from usually 5V) and that can switch much higher voltages, for example the one you have at a plug at your home (110/120/220/230V depending on where you live). Inside of a relay, there is a mechanism made of a coil and a piece of metal, that can move from one side to the other. See the picture below to better imagine the inside of a relay.

C input is for high voltage current, so lets say for 230V. This input is normally connected by the mentioned piece of metal with NC output, which stands for Normally closed. In case you want to use a relay as a switch, which is by default in OFF mode, you will leave NC as it is, so the voltage from C is not going anywhere. NO output, that stands for Normally opened, is the place where you connect some electronic appliance, such as a light bulb, heating or whatever you wish to be in control of. But as we said, C is by default connected no NC so whatever is connected to NO will be OFF by default. C, NC

These three pins are those with screws on top of them, which will help you to attach the wires of an electric appliance, you will be controlling.

Now comes the interesting part of controlling the relay. There is another circuit in relay, this time low level voltage, which controls if a current will flow through the coil or not. If there is a current flowing through the coil, it creates an electromagnetic(EM) field, which as we know attracts metal. As I mentioned at the beginning, there is a piece of metal inside the relay, which attracted to the coil, when the EM field is present and causes it to move from NC position to NO position.

This circuit is controlled also by three pins. They are those traditional small pins coming out of the relay board. Those three pins are marked as VCC - which will be connected to 5V source, GND - which will be connected to the ground and IN which will control if the coil should produce EM field or not.

Which relay to buy

Now when searching for a relay on the internet, you will find thousands of different types. Search for an Arduino/Raspberry 5V relay. Those 5V are important as one of the characteristics of a relay is its working voltage. RaspberryPi can give you 3.3V or 5V. Most of the relays you will find need at least 5V, but some of them can work even with 3.3V so don’t forget to check this when buying one. They come as a single relays or on a board where you have 2/4/8… of them. Their price starts at around 1$ on Ebay, so you can definitely buy at least two of them to experiment with.

I have bought 1 channel 5V relay 1280 2560 ARM PIC AVR DSP

Connecting it to Raspberry

As I already said, Raspberry will control the relay, so we will connect it to control part of the relay - VCC to Raspberry’s 5V output, GND to ground and IN will serve to control it. You might be tempted to just connect the IN to GPIO in OUTPUT mode and switch it from high to low, but this will unfortunately not work. Relays are usually so called GROUND/ZERO/LOW LEVEL ACTIVATED which means, that the IN pin must be connected to ground to turn the relay ON and connected to 5V (or disconnected/floating) to be OFF. Therefore we will need to create a small helper circuit to be able to connect the IN pin with ground or 5V using our Raspberry. We will need a NPN transistor, that will serve as a switch, two 10KΩ resistors, that will serve as pull-up and pull-down resistors and one 2.2KΩ resistor.

Pull-up & Pull-down resistors

You might be asking what is that pull-up/down resistor I just mentioned. When dealing with with sensors, relays and any other electronic components, that can be controlled, we always want to be sure that we know in which state they are (ON/OFF). This is almost always done by switching the voltage between the 5V and GROUND on some kind of IN/CONTROL pin. However, there are situations, when you can not be sure, what voltage is on the pin, that could lead to unexpected behavior, for example if you leave the control pin just as it is, not connected to anything. It might seem like if some pin is not connected, there would be no voltage on it, so it would be the same as connecting it to ground, but no! There can be some electric charge “flying” it the air, that will “sit” on the pin and suddenly turn your circuit ON and then it can again “fly away” so your circuit can go mad switching between ON and OFF multiple times. Such a state when the pin is not connected is called FLOATING state and we need to make sure that or control pins will never happen to be in such a state.

Here comes the pull-up/down resistor. It is used to make sure, that in default state, there is always high voltage on the pin, e.g. 5V on the input pin (in case of pull-up) or that the pin is grounded (in case of pull-down). These resistors have high resistance, usually 10KΩ, cause we do not want to have a high current floating through them, which would be plain wasting of energy and also, we want to be able to “override” the default settings, by having an optional circuit branch, with lower resistance. Circuit always go by the way of lowest resistance, so if we let it go through such a lower resistance branch, the pull-up/down branch will be kind of ignored.

Control circuit

In our case, we want the relay to be in OFF mode by default. Therefore we will use a pull-up resistor for the IN pin. Then we will have a transistor, serving as a switch, that will connect the IN pin to GROUND on our demand. We want this transistor to be CLOSED by default, so we will connect a pull-down resistor to it.

The transistor itself will be controlled by a GPIO in OUTPUT mode. Since a big current could potentially destroy our transistor and only low current is needed to open it, we put a 2.2KΩ resistor between the GPIO and transistor’s base. Transistors collector is connected to IN pin and emitter to GROUND. So when the transistor is opened (GPIO will be set to HIGH) the relay will turn ON, when the transistor will be closed (GPIO set to LOW), relay will be OFF.

See the image below for details on how to connect the relay to Raspberry.

Controlling the relay

Now we have the circuit ready, so lets test it. First lets just simply use a gpio command line program to turn the relay on and off.

First lets set the GPIO to OUTPUT mode - turn on the command line and write:

gpio mode 7 OUT

Let’s check if it is really in OUTPUT mode by writing:

gpio readall

Which will show a schematics of your Raspberry with all pinouts, their number, mode and current value. Now turn the relay ON by setting the GPIO to HIGH:

gpio write 7 1

The relay should turn ON. Horay! Now turn it back OFF by setting the GPIO to LOW:

gpio write 7 0

Voila! You are now in control of the relay. But how about writing a simple python program, that would switch the relay on and off by pressing an ENTER key.

#!/usr/bin/python

# Import required Python libraries
import RPi.GPIO as GPIO

# We will be using the BCM GPIO numbering
GPIO.setmode(GPIO.BCM)

# Select a control GPIO
GPIO_CONTROL = 17

# Set CONTROL to OUTPUT mode
GPIO.setup(GPIO_CONTROL, GPIO.OUT)

# Main function
def main():
  # Start by setting the relay to OFF
  relayState = False
  GPIO.output(GPIO_CONTROL, relayState)
  print('Relay is OFF')
  try:
    # Repeat till the program is ended by the user
    while True:
      # Wait while ENTER is pressed
      # This is a small hack, raw_input() can read keyboard input until you press ENTER and save it to a variable, but we dont care about other keys to be pressed, so we don't
      raw_input() 
      # Toggle the relayState value
      relayState = not(relayState )
      # Change the CONTROL output value
      GPIO.output(GPIO_CONTROL, relayState)
      # Print state to console
      if relayState:
        print('Relay is ON')
      else:
        print('Relay is OFF')
  # If the program is ended cleanup GPIOs
  except KeyboardInterrupt:
    GPIO.cleanup()

# Run the main function when the script is executed
if __name__ == "__main__":
    main()

Call this file relay_control.py and run it

python relay_control.py

Every time you press ENTER, relay will switch from OFF to ON and the other way round. Also, on every switch, there will be a message printed into the console reading Relay is ON/OFF. Give it a try and enjoy creating cool projects with relays and Raspberry!

The code, schema and breadboard wiring is also available on my GitLab

Raspberry pinouts - BCM/BOARD/wiringPi

Tue, 08 Aug 2017 00:00:00 +0200

Raspberry pinouts

If you are going to connect some electronics to your Raspberry, no matter if to power them, control them or read dat from them, you will need to use Raspberry’s pinouts, which are those small wires going out of the raspberry in the corner. There are more versions of Raspberry (A, B, A and B in revision 2.0, A+,B+,2B,3B and som) and they vary in number and placement of their pinouts. Namely version A & B have 26 pinouts and all others have 40. Each A, B and the rest have different layout of their pins, so there are 3 variations in total. Let’s have a look at them!

RPi B revision 1

RPi A/B revision 2

RPi A+/B+/2B/3B

credits for images go to RaspberryPi Spy

GPIO

If you are going to control something with your Raspberry or read data from a sensor lets say, you will need a general purpose input/output to conect it to. These pins - GPIO in short - can be set to OUTPUT or INPUT mode. In OUTPUT mode you can read HIGH or LOW (eg. 1 or 0) values on the pin depending if you brings 3.3V voltage on it for HIGH, respectively 0V for LOW. In reverse, if you set GPIO to INPUT mode, you can set it to HIGH, which means the pin will be source of 3.3V or to LOW, which means it will give you 0V.

BOARD vs. BCM vs. wiringPi

You might have noticed, that each pin has a number, but also a label, which in GPIO’s case also contains number different from the actual pin number. You always have to bare in mind, which pin numbering you are using! Those numbers on pins are reffered to as BOARD numbering, numbers mentioned in labels reffer to BCM numbering. To make it even more confusing, there is another numbering called wiringPi used in command-line utility gpio which we will have a look at in next article. This utility offers an option to print all pin numbers with all their different numbering. So either write

gpio readall

in your Raspberry terminal or have a look at this screen to see all the numberings together. BCM goes for BCM, wPi goes for wiringPi and Physical goes for BOARD.

Now finally, put this blog post to your favourites bar, cause you will come back here quite often before you remember the numbers by heart…

RaspberryPi course - building garden control & weather station

Tue, 01 Aug 2017 00:00:00 +0200

Raspberry Course

Greetings! I am very glad that you ended up on my blog, mostly focused on programming and electronics. Since you clicked on this post I guess you are probably looking for some learing material to teach yourself how to run and control your RaspberryPi, how to connect various sensors and other components to it and read data from them and how to make something cool with it. If it is really your case, then read ahead, because I have decided to write a series covering everything from seting up your Raspberry for the first time to creating a super cool garden control system running on your own Raspberry server, which will enable you to controll your water pump while checking the temperature and heigh of your water well!

From now on, I will publish short articles, each focused on one major thing that you can do with your Raspberry. We will start with a setup, then learn how to write programs in Python, how to connect and read data from your sensors, then we will run a Laravel server on your Raspberry with MySQL database and finally, we will put everything together and build a remote garden control system with a weather station.

Articles won’t be published on regullar basis, but you can expect aproximately one article per two weeks. Below, I am going to create a list of published and planned articles, so go ahead and click on those which have a link - those are done and wait for those wich are next in the row.

If you think there is something missing or you would like me to write an article about certain sensor, do not hesitate and give me a shout here in the comments or mail me.

Raspberry course articles

First time starting your Raspberry
Pinouts - connecting other electronics to Raspberry
Lumos! - turning on a LED with Python
Will it rain? - reading external weather API with python
Reading temperature from a DHT sensor
Measuring distances with ultrasonic JSN-SR04T sensor
Day or night? - Measuring light intensity
Water everywhere - humidity, rain and water level sensors
Turning high voltage electronics on and of - control a relay
Flying around - read data from gyroscope
Securing your room - access system with NFC reader
Screenshoting you garden - conext a camera to RaspberryPi
Own linux server - running apache on Raspberry
Setting up Laravel on Raspberry
Putting it together - building a garden control system & weather station

Enjoy reading and I hope these articles will become a starting point for your awsome Raspberry projects!

Život v dešti

Mon, 15 Dec 2014 00:00:00 +0100

Bude tomu za chvíli už něco kolem dvou a půl měsíců, co trvá mé pracovní anglické dobrodružství. Až na trojici výletů do Londýna, Paříže a Dublinu se tady ovšem každý můj den podobal skoro na chlup tomu předchozímu a abych pravdu řekl, někdy je to opruz. Abych vám přiblížil co tady vlastně dělám, bude stačit když popíšu jeden takový průměrný den, ten si vynásobte sedmdesáti a máte zhruba představu o mém celém anglickém působení.

V práci začínáme oficiálně v devět ráno. Vzhledem k tomu, že nemáme žádné píchačky a každý si tam chodí jak chce , propracoval jsem se od mých příchodů kolem 8:45 v prvních dvou týdnech, kdy krom mě a šéfa v kanclu ještě nikdo nebyl až k aktuálnímu času příchodů, zhruba okolo 9:20, většinou to záleží na provozu, počasí a taky jestli si ráno odbydu svých patnáct minut na záchodě ještě doma nebo až v práci. Abych stíhal, stával jsem původně v 8 hodin, ale jak se posunoval čas mých příchodů do práce, posunul se taky čas mého vstávání. Vzhledem k tomu, že jsem docela agilní co se týče vypakování se z baráku, jsem schopen vzbudit se 8:40 a 45 už být na cestě, takže to takhle nějak většinou taky bývá. Každé ráno do baťohu sbalím myš, nějakou sladkost, musli tyčinku na snídani, jedny suché trenky a ponožky kdyby náhodou chcalo a já byl promáčený až na řiť, protože tomu ver ,že se mi to už několikrát stalo, čapnu kolo, nasadím polskou reflexní vestu kterou jsem dostal v Estonsku a vyrážím na kole směr centrum. Autobusem moc nejezdím, protože to stojí těžké háky a už i tak tady občas na večeři okusuju omítku, takže kolo, které jsem fásl od jednoho z šéfíků využívám každý den a šetří mi dost peněz a hlavně, co bych neudělal pro své zdraví že. Co se městské logistiky týče, už se tady docela vyznám, po levé straně jsem si taky zvykl jezdit, i že brzdy jsou naopak už si pamatuju, akorát přednost zleva mi sviňa pořád moc nepasuje a se občas stane, že na mě někdo trubne, protože si to jak pán prosvištím křižovatkou, když si myslím, že mám přednost. Ale abych na sebe nebyl tak tvrdý, Angličani jezdí obecně jako prasata. Začíná to u cyklistů, kteří jezdí na červenou a všemi směry jak se jim zachce, pokračuje to u nervózních řidičů osobáků co pořád troubí a končí u posratých taxikářů, kteří naschvál blokujou krajní pruh pro cyklisty, který je skoro na každé cestě a jedou tak, že je tím pruhem prostě nepodjedete protože by to skončilo buď uražením zrcátka nebo některé z vašich končetin. Cesta mi trvá asi 15 minut a je většinou poklidná, až tedy na případy kdy prší. Pod pojmem prší myslím lije, protože tady prší pořád. Jak už jsem předeslal, několikrát se mi stalo, že jsem vyjel za sucha a do práce dojel promočený jak pomyvač po šichtě. Jednou jsem si musel dokonce dojít koupit nové trenky a ponožky abych měl aspoň něco suchého a od té doby vždycky vozím v báglu rezervu. Vzhledem k tomu že blatníky nemám a ani vlastně vzhledem ke kvantitě vody kolem vás při dešti nemají moc smysl, jsem pořád celý od bláta, ale kalhoty ve kterých jezdím mám jenom na kolo, takže je to cajk.

Pracuju v moc pěkném kanclu přímo v centru města. Náš Cleversteam tvořím já, šéf co je zároveň i programátor, ještě jeden programátor a dva designéři. Kupodivu tam nejsem nejmladší, což mě přivádí k myšlenkám, že už mám fakt asi taky roky… Vedle nás sedí ještě 4 lidi z firmy co podporuje startupy a tak nějak pod nás patří a občas do kaclu dochází CEO a dva akcionáři/šéfi Campleaders potažmo celé Smaller Earth skupiny pod kterou patříme i my. Všechno jsou to moc pohodoví lidi a i když je v kanceláři většinou ticho, tak když už se začnou bavit, tak to stojí za to. Už jsem se trochu adaptoval i co se týče porozumění přízvukům, které má každý úplně jiný, takže si troufnu říct, že tak 50 procent veškeré konverzace už chytám :D Máme malou kuchyňku s kávo/čajo varem, který frčí pořád na plné koule, protože Angličani vychlemtají během dne hektolitry ať už toho nebo toho, ledničku a dva záchody. To poslední jmenované mi dělá největší radost, protože není nad to když člověk může v klidu dělat co potřebuje a není nervózní, že za dveřma stojí někdo další v řadě… Jediné co mě štve je děsná kosa, kterou tam máme. Všichni jsou pořád nemocní, kašlou, ale chodí v krátkém tričku a to pitomé topení prostě nezapnou i přesto, že se tam sami klepou Parkinson hadra. Já se docela dlouho držel a i díky každodenní malé dávce slivovice po práci jsem si udržoval zdravého duchaí, nic ale netrvá věčně a tak jsem minulý týden taky chytl nějakou rýmičku. Proti zimě se každodenně snažím bojovat na všech frontách, kancl je velký takže než se vytopí, asi hoďku to trvá. Zmrzlé ruce si chodím ohřívat pod fukar na záchodech, jelikož třeba pod vodou to nejde, protože kohoutky jsou rozdělené a jak už jsem psal, z jednoho teče skoro pára a z druhého se dělají rampouchy. V neposlední řadě pak také přispívám k velké spotřebě čaje, protože to je jediný zdroj tepla, který dokážete dostat do sebe. Taky je fajn, že jako vedlejší efekt často chodíte čůrat, takže se aspoň trochu protáhnete od práce.

Šichty kancelářského plebsu jsou osmihodinové, teoreticky. Většinou jsem to já kdo tam opravdu zůstává celých 8 hodin a pak šéf, který se mi svěřil, že někdy je v práci už ve 4 ráno a zůstává tam až do večera, je to trochu workoholik, co si budem povídat… Někdy kolem poledne si vždycky zajdu na oběď. Typický anglický oběd je sandwich a tak v tom samozřejmě frčím taky. Většinou si skočím do Tesca, které máme za rohem na “Meal deal” což je sendvič, pití a nějaké ovoce nebo brambůrky k tomu. Stojí to 3 anglokačky, lepší poměr výkon/cena neseženete. Že jsem ale pořád chlapec ve vývinu a mívám docela hlad, takže poslední dobou si k meníčku kupuju ještě něco z “teplé přihrádky”. Je to prostě regál, kde je udělané jídlo, které se udržuje teplé. Vždycky mě fascinovaly masové koláče a pečivo s masem anglické receptury, kterého tu mají fůru, takže docela ujíždím na tomhle, páč to moc nestojí, je to docela dobré a hlavně teplé a když zrovna není slina na pečivo, tak vždy sahám po kuřecích nugetkách nebo rybích bobcích, kouscích nebo whatever to je. Mimochodem, vyřídil jsem si Tesco klubovou kartičku a se smutkem jsem zjistil, že i když mám nasbíraných přes 200 bodů, jakési kupóny dostanu až v únoru či kdy, prostě poser, kdyby aspoň dávali nějaké pánvičky, šmouly nebo jakoukoliv jinou plyšovou věc stylu oživlé mutované zeleniny kdesi od Černobylu s magickýma schopnostma, které můžete sbírat , ale oni nic, vůbec nic…

Ve firmě dělám ze všeho nejvíc nejvíc front-end vývoj webovek, pro nezasvěcené dělám prostě webové stránky, snažím se, aby vypadaly tak jak je navrhnou designeři, fungovaly na nich všechny udělátka, skákaly veselé obrázky a texty a tak vůbec. Vzhledem k tomu, že jsem se očividně osvědčil, tak hned po prvním týdnu jsem dostal na starost první projekt, kterých mám teď souběžně asi pět a vzhledem k tomu, že nikdo jiný nemá čas, tak je všechny nějak tak vedu, což mi docela masíruje ego, co s projektama bude až odejdu netuším, ale myslím, že na stážistu slušná pozice, škoda akorát že mi nic neplatí… Hned od začátku jsem byl plně integrován do týmu, takže se účastním i hodinových porad, které jsou na pořadu týdne vždy v pondělí v 11, takže mám docela přehled jak to všechno vlastně ve firmě funguje. Ovšem největší sranda je, že je to všechno úplně jinak než nám to vykládají ve škole a takováhle dvouměsíční praxe mi toho dala víc než celý bakalář na našem prestižním VUT , které tady samozřejmě nikdo nezná a vlastně ani nikoho moc nevzrušuje jestli nějaké školy máte, spíš jde o to co umíte, možná i proto tady nikdo tituly nepoužívá a to ani ve formální korespondenci nebo na vizitkách…

Většinou z práce odcházím po páté. Kolem šesté jsem doma a jsem rád že jsem rád. Se sedavou prací jsem moc zkušeností neměl a překvapivě mě to zmáhá víc než prostátá šichta v kuchyni u krájení okurek. Než jsem tady dojel, představoval jsem si jak volné večery budu věnovat učení se novým věcem, pilováním španělštiny a ruštiny, cvičení a tak. Každopádně můj večerní program je asi takový, že si přečtu všechny zprávy, zavolám si se svou Peťou, udělám večeři, podívám se na nějaký seriál, něco malinko si přečtu a už je jedna ráno jsem kaput a je čas jít spát. Nikam ven moc nechodím, jelikož bych se nedoplatil, i když bylo pár výjimek a taky mé výletky stály docela dost, takže bylo třeba šetřit a až na malé procházky jsem se nikam moc z baráku nedostal.

Shrnuto podtrženo je to tady trochu nudný stereotyp. Dost věcí mi tu chybí, Peťa, levné pivo, pořádná strava, pořádná sprcha a taky pořádná postel. Tyvole takovou postel jste nikdo nezažili, každé ráno kontroluju, jestli některé péro přes noc neprolítlo mojim břichem nebo hlavou, protože se jednak zevnitř postele ozývají divné zvuky a každou chvíli někde tlačí nějaká ven se deroucí pružina, takže kvalita spánku je nastavená hodně nízko. Abych nebyl ale jen kritický tak si myslím, že profesně mi to dává víc než cokoliv předtím a taky, že kolonka vývojář v anglické společnosti nebude vypadat špatně v mojem sívíčku. Takže doufám, že i přes všechno co jsem tady musel přetrpět se to nakonec oplatí.