JFíla

sobota 9. srpna 2025

EZS Smart žárovka s PIR čidlem

Spectrum Smart 9W, s FW od OpenBK. https://github.com/openshwprojects/OpenBK7231T_App/tree/main

PIN6 je připojen na PIR čidlo (Aktivní je L). Žárovka je aktivní po dobu sepnutí PIR čidla, po aktivaci odešle po MQTT "Active" a po deaktivaci PIR čidla pošle "Passive" a uspí se (tj. i odpojí od WiFi).

Konfigurace:

{ "vendor": "Tuya", "bDetailed": "0", "name": "Full Device Name Here", "model": "enter short model name here", "chip": "BK7231N", "board": "TODO", "flags": "266256", "keywords": [ "TODO", "TODO", "TODO" ], "pins": { "6": "dInput;10", "24": "SM2235DAT;0", "26": "SM2235CLK;0" }, "command": "PowerSave 1", "image": "https://obrazki.elektroda.pl/YOUR_IMAGE.jpg", "wiki": "https://www.elektroda.com/rtvforum/topic_YOUR_TOPIC.html" }

Script autoexec.bat:

AddEventHandler OnChannelChange 10 startScript /autoexec.bat handle_leds // počkáme než se připojí MQTT waitFor MQTTState 1 on_boot: handle_leds: if $CH10==0 then goto Active Passive: led_enableAll 0 publish PIR "Passive" DSEdge 2 PinDeepSleep goto End Active: led_enableAll 1 publish PIR "Active" End:

čtvrtek 3. července 2025

Build Linux pro RPi

Instalovat:

sudo apt update
sudo apt install build-essential git cpio unzip rsync bc libncurses5-dev libssl-dev

Naklonovat repozitář:

git clone https://github.com/buildroot/buildroot.git
cd buildroot

Zkopírovat vzorový konfig pro RPi4

cp configs/raspberrypi4_64_defconfig .config

Upravit dle potřeby:

make menuconfig

vyřešit problém s mezerami v PATH:

#!/bin/bash
export PATH="/usr/local/bin:/usr/bin:/bin" # základní cesty bez mezer

Přeložit a čekat

make -j 6 # počet jader CPU pro kompilaci

Výsledný obraz nalezneme v output/images/sdcard.img

sudo dd if=output/images/sdcard.img of=/dev/sdX bs=4M status=progress && sync

Nyní vytvoříme helloword a pokusíme se ho spustit

nano hello.c
./buildroot/output/host/bin/aarch64-linux-gcc -o hello hello.c

#include <stdio.h> void main() { printf("Funguje to!\n"); }

sobota 31. května 2025

Nastavení kanálů v Tvheadend

ČT

Nova

Prima

úterý 7. ledna 2025

Windows 11 nefunguje Guest přístup na Samba

Povolení nedůvěryhodného přístupu:

Otevřete Editor registru (Win + R → napište regedit).
Přejděte na klíč do:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\LanmanWorkstation\Parameters

Vytvořte nebo upravte hodnotu DWORD (32bit) s názvem:

AllowInsecureGuestAuth

Nastavte hodnotu na 1.

pátek 3. ledna 2025

Přidání nového modulu do jádra a Device Tree na Raspberry Pi

V tomto článku se podíváme na proces přidání nového modulu do linuxového jádra na Raspberry Pi a jeho konfiguraci pomocí Device Tree (DT). Ukážeme si konkrétní příklad s EEPROM pamětí připojenou přes I2C sběrnici.

1. Stažení a příprava modulu

Nejprve stáhneme zdrojový kód ovladače z repozitáře Linuxu. Použijeme EEPROM ovladač at24:

wget https://raw.githubusercontent.com/torvalds/linux/refs/tags/v6.6/drivers/misc/eeprom/at24.c

Tento ovladač slouží k práci s paměťmi EEPROM přes sběrnici I2C. Zajišťuje správu komunikace mezi jádrem systému a zařízením připojeným přes I2C.

2. Vytvoření Makefile

Makefile definuje pravidla pro kompilaci modulu. Vytvořte soubor s názvem Makefile s následujícím obsahem:

obj-m += at24.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

Popis obsahu Makefile:

obj-m += at24.o: Určuje, že chceme sestavit modul at24.
all: Používá se pro sestavení modulu pomocí Makefile. Spustí se příkaz pro kompilaci modulu ve správném adresáři jádra.
clean: Smaže dočasné soubory vytvořené během kompilace.

Pro spuštění kompilace použijte:

make

Výstupem bude soubor at24.ko, což je zkompilovaný modul jádra.

3. Vytvoření Device Tree pro I2C zařízení

Device Tree (DT) je systémová konfigurace, která popisuje hardwarová zařízení. Pro konfiguraci EEPROM pamětí vytvoříme soubor at24.dts s následujícím obsahem:

/dts-v1/;
/plugin/;

/ {
    compatible = "brcm,bcm2835";

    fragment@0 {
        target = <&i2c1>;  // Použití I2C-1
        __overlay__ {
            #address-cells = <1>;
            #size-cells = <0>;

            EEPROM1@50 {  // první EEPROM
                compatible = "at24,24c02";  // Typ EEPROM
                reg = <0x50>;               // Adresa na I2C sběrnici
                pagesize = <16>;            // Velikost stránky
                size = <256>;               // Celková velikost EEPROM
            };
            EEPROM2@57 {  // druhá EEPROM
                compatible = "at24,24c02";
                reg = <0x57>;               // Adresa na I2C sběrnici
                pagesize = <16>;
                size = <256>;
            };
        };
    };
};

Vysvětlení obsahu souboru:

compatible = "brcm,bcm2835";: Specifikuje, že konfigurace je určena pro BCM2835 (Raspberry Pi SoC).
reg = <0x50>;: Specifikuje skutečnou adresu zařízení na I2C sběrnici, která bude jádrem použita ke komunikaci se zařízením.
pagesize a size: Definují parametry paměti EEPROM.

4. Kompilace Device Tree

Pro převedení souboru na binární formát použijeme nástroj:

dtc -I dts -O dtb -o at24.dtbo at24.dts

Tímto příkazem vznikne binární soubor at24.dtbo, který je připraven pro použití.

Nahrání overlay:

Zkopírujeme výsledný soubor do adresáře s DT overlays:

sudo cp at24.dtbo /boot/firmware/overlays/

Přidáme overlay do konfiguračního souboru:

echo 'dtoverlay=at24' | sudo tee -a /boot/firmware/config.txt

5. Testování EEPROM

Zápis dat do EEPROM:

Pro otestování funkce EEPROM můžeme zapsat řetězec do paměti:

echo "Zapis do I2C EEPROM" | sudo dd of=/sys/bus/i2c/devices/1-0057/eeprom bs=1 seek=0

Čtení dat z EEPROM:

Následně ověříme zápis čtením obsahu EEPROM:

sudo hexdump -C /sys/bus/i2c/devices/1-0057/eeprom

Ukázkový výstup:

00000000  5a 61 70 69 73 20 64 6f  20 49 32 43 20 45 45 50  |Zapis do I2C EEP|
00000010  52 4f 4d 0a 01 00 0f 00  00 00 00 14 0f 14 2d 10  |ROM...........-.|

sobota 27. dubna 2024

Lineární regrese

import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

x = np.array([0, 1, 2, 3, 4, 5, 6, 7])
y = np.array([1, 3, 5, 7, 9, 11, 13, 15])

model = LinearRegression()
model.fit(x[:, np.newaxis], y)

koeficienty = model.coef_
print(f"Naučené koeficenty: {koeficienty}")

new_x = np.array([8])
y_pred = model.predict(new_x[:, np.newaxis])
print(f"Předpovědi pro x = {new_x}: {y_pred}")

plt.scatter(x, y, label="Data")
plt.plot(x, model.predict(x[:, np.newaxis]), label="Model")
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Lineární regrese")
plt.legend()
plt.show()

A co je "pod kapotou"?

Hledáme parametry rovnice přímky y = a * x + b

Směrový koeficient (a): a = Σ((xi - x̄)(yi - ȳ)) / Σ(xi - x̄)²
Úsekový koeficient (b): b = ȳ - b * x̄

Kde:

x̄ a ȳ reprezentují průměrnou hodnotu x a y
xi a yi reprezentují jednotlivé hodnoty x a y

import numpy as np

y = np.array([1, 3, 5, 7, 9, 11, 13, 15])
noise = np.random.normal(0, 0.1, len(y))  # Standardní odchylka 0.1
y_with_noise = y + noise

model = LinearRegression()
model.fit(x[:, np.newaxis], y_with_noise)

koeficienty = model.coef_
print(f"Naučené koeficenty: {koeficienty}")

new_x = np.array([8])
y_pred = model.predict(new_x[:, np.newaxis])
print(f"Předpovědi pro x = {new_x}: {y_pred}")

plt.scatter(x, y_with_noise, label="Data")
plt.plot(x, model.predict(x[:, np.newaxis]), label="Model")
plt.xlabel("X")
plt.ylabel("Y_noyse")
plt.title("Lineární regrese")
plt.legend()
plt.show()

středa 13. března 2024

Zjištění jaké šifry server podporuje

Na openwrt je nutné nainstalovat nmap-full, který podporuje scriptování a TLS. A stáhnout script ssl-enum-ciphers

root@MB:~# nmap --script ssl-enum-ciphers.nse -p 443 server.cz

Starting Nmap 7.80 ( https://nmap.org ) at 2024-03-13 18:19 CET

Nmap scan report for server.cz (152.184.162.111)

Host is up (0.041s latency).

PORT STATE SERVICE

443/tcp open https

| ssl-enum-ciphers:

| TLSv1.0:

| ciphers:

| TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA - unknown

| TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA (secp256r1) - A

| TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA (secp256r1) - A

| compressors:

| NULL

| cipher preference: server

| TLSv1.1:

| ciphers:

| TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA - unknown

| TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA (secp256r1) - A

| TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA (secp256r1) - A

| compressors:

| NULL

| cipher preference: server

| TLSv1.2:

| ciphers:

| TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 (secp256r1) - A

| TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 (secp256r1) - A

| TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA - unknown

| TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 - unknown

| TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA (secp256r1) - A

| TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 (secp256r1) - A

| TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA (secp256r1) - A

| TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 (secp256r1) - A

| TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 (secp256r1) - A

| compressors:

| NULL

| cipher preference: server

|_ least strength: unknown

Nmap done: 1 IP address (1 host up) scanned in 4.07 seconds

Windows 11

"Normální" kontextová nabídka u souboru

reg add HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32 /ve /d "" /f

čtvrtek 11. ledna 2024

Nastavení síťového připojení Ubuntu

sudo ip addr add 192.168.1.245/24 dev eth0

sudo ip route add default via 192.168.1.1

/etc/resolv.conf

nameserver 8.8.8.8

nameserver 8.8.4.4

čtvrtek 7. prosince 2023

Jak funguje base64?

Všichni to používají ale zda vůbec vědí jak se tato textová reprezentace binárních dat v ASCII vlastně převádí?

Binární data převedeme na 24 bitové číslo a to rozdělíme na skupiny o 6 bitech. Níže uvedená tabulka nám pomůže při kódování.

Máme binární data 01 02 03, 24 bit číslo bude 0x010203, to binárně zapsané vypadá 00000001 00000010 00000011. Nyní si data rozdělíme na šesti bitové skupiny, 000000 010000 001000 000011 (desítkové soustavě 1 16 8 3). Podle tabulky získáme AQID.

Pro data nesoudělná čtyřmi to funguje takto:

01 02, bude číslo 0x0102, tedy 00000001 00000010 binárně. Rozdělíme na šesti bitové skupiny, 000000 010000 0010, zprava přidáme nuly a vyjde nám AQI. Aby bylo možné detekovat padding, tak se doplní za každé dva bity znak =.

Příklad 01 02 03 04.

000000 010000 001000 000011 000001 000000

AQIDBA==

Dekódování se provádí opačně, jen se podle počtu znaků = data od konce oříznou. AA== je tedy 000000 00 ~~0000~~ což je 00.

Hex	Binary	Decimal	Base64
00	000000	0	A
01	000001	1	B
02	000010	2	C
03	000011	3	D
04	000100	4	E
05	000101	5	F
06	000110	6	G
07	000111	7	H
08	001000	8	I
09	001001	9	J
0A	001010	10	K
0B	001011	11	L
0C	001100	12	M
0D	001101	13	N
0E	001110	14	O
0F	001111	15	P
10	010000	16	Q
11	010001	17	R
12	010010	18	S
13	010011	19	T
14	010100	20	U
15	010101	21	V
16	010110	22	W
17	010111	23	X
18	011000	24	Y
19	011001	25	Z
1A	011010	26	a
1B	011011	27	b
1C	011100	28	c
1D	011101	29	d
1E	011110	30	e
1F	011111	31	f
20	100000	32	g
21	100001	33	h
22	100010	34	i
23	100011	35	j
24	100100	36	k
25	100101	37	l
26	100110	38	m
27	100111	39	n
28	101000	40	o
29	101001	41	p
2A	101010	42	q
2B	101011	43	r
2C	101100	44	s
2D	101101	45	t
2E	101110	46	u
2F	101111	47	v
30	110000	48	w
31	110001	49	x
32	110010	50	y
33	110011	51	z
34	110100	52	0
35	110101	53	1
36	110110	54	2
37	110111	55	3
38	111000	56	4
39	111001	57	5
3A	111010	58	6
3B	111011	59	7
3C	111100	60	8
3D	111101	61	9
3E	111110	62	+
3F	111111	63	/

Za vygenerování tabulky děkuji AI.