Lora32 come scheda di rete

Un po ' di tempo fa avevo sperimentato l'uso del protocollo AX25 usando Lora  con in moduli SX1278

Questa volta provo ad usare Lora32 Lilygo con il software di RNode

Per prima cosa si deve impostare un ambiente virtuale in Python (in Debian non permette di fare pip al di fuori di in venv) per installare 

pip install rns

rnodeconf --autoinstall

(per la Lilygo Lora32 che ho usato io l'opzione della scheda e' la numero 3)

rnodeconf /dev/ttyuUSB0 -T --freq 868000000 --bw 125000 --txp 2 --sf 7 --cr 5

(qui si impostano sulle schede le impostazione di trasmissione Lora)

per configurare il dispositivo come una scheda di rete wireless si usa tncattach 

tncattach /dev/ttyUSB0 115200 -d --noipv6 --noup --mtu 572

La configurazione puoà essere come punto punto 

ifconfig tnc0 10.0.0.1 pointopoint 10.0.0.2

(ovviamente scambiando gli indirizzi sulle due schede)

oppure multi punto (ma e' decisamente piu' lenta

tncattach /dev/ttyUSB0 115200 -d -e --noipv6 --mtu 554 --ipv4 10.91.0.1/24

per le prove che ho fatto il sistema e' lento ma in ogni caso in una punto punto si riesce ad interagire in modo discreto con una sessione SSH

TI-89 Mandelbrot

 Ho scoperto per puro caso che le calcolatrici Texas Instruments TI-89 (e parenti) hanno al proprio interno un processore della classe 68000 e che possono essere programmate, oltre che in TI-Basic, anche in C...proviamo un po'

Il compilatore C che ho usato si trova a questo link https://github.com/debrouxl/gcc4ti

esistono versioni meno aggiornate ma non sono cosi' complete

Per compilare si va in /trunk/tigcc-linux/scripts e si lancia ./Install

si impostano poi le variabili di ambiente

export TIGCC=/usr/local/share/gcc4ti/

export PATH=$PATH:$TIGCC/bin

il codice di questo post e' ripreso dal precedente post 

le differenze sono :

1) la funzione main in TIGCC si chiama _main (underscore main)

2) sono necessari gli include di stdio e kbd anche se di fatto non sono richiamati dal codice

#define USE_TI89 // produce all types of files

//#define USE_TI92PLUS

//#define USE_V200

#include <stdio.h> // standard ANSI C input/output support

#include <kbd.h>

#include <tigcclib.h>

#define FIXEDPT_WBITS 4

#define WIDTH 160

#define HEIGHT 100

#include "fixedptc.h"

void _main(void) {

ClrScr();

int j,k,i;

float test;

fixedpt Re,Im,DRe,DIm;

fixedpt X,Y,DUE;

fixedpt XN,YN,YNN;

fixedpt A,B;

Re = fixedpt_rconst(-2.00390625); //finestra reale tra -2 e +0.5

Im = fixedpt_rconst(-1.205); //finestra immaginaria tra -1.2 e 1.2

DRe = fixedpt_rconst(0.015625); //2.5/160

DIm = fixedpt_rconst(0.024); // 2.4/100

DUE = fixedpt_rconst(2.0);

A = Re;

for (j=0;j<WIDTH;j++)

{

A = fixedpt_add(A,DRe);

B = Im;

for (k=0;k<HEIGHT;k++)

{

B = fixedpt_add(B,DIm);

X = fixedpt_rconst(0.0);

Y = fixedpt_rconst(0.0);

for (i=0;i<=127;i++)

{

XN=fixedpt_sub(fixedpt_mul(X,X),fixedpt_mul(Y,Y))+A; // (x*x) - (y*y) + A

YN=fixedpt_mul(X,Y); // x*y

YNN=fixedpt_mul(DUE,YN); // 2*x*y

YN=YNN + B; // 2*x*y*+B

test = fixedpt_tofloat(fixedpt_mul(XN,XN) + fixedpt_mul(YN,YN)); //(XN*XN)+(YN*YN)

if (test > 4.0)

{

//png.plot(j,k,1.0,1.0,1.0);

if (i%2) DrawPix(j,k,A_NORMAL);

break;

}

X = XN;

Y = YN;

}

}

}

}

tigcc -O2 -o timand timand.c 

il file binario avra' una estensione .89z (nel caso si compile di per TI-92 sara' .92z)

Per il trasferimento dell'eseguibile tramite cavo USB ho usato il programma TILP funzionante su Linux impostando Direct Link

Una volta trasferito il codice sul dispositivo si puo' eseguire digitando il nome del fie per esempio se il nome del file e' timand come se fosse una funzione ...per esempio timand()

In alcuni casi la calcolatrice puo' non mostrare la linea di comando ma le icone..in questo caso si preme il tasto MODE si scrolla in basso fino all'opzione APP Desktop e se seleziona OFF

Se non si vuole usare un dispositivo fisico si puo' usare l'emulatore TIEmu. In questo caso per caricare l'eseguibile e' sufficiente premere il tasto F10 e selezionare il flie .89z

Hacking camping wifi

Al campegggio il servizio Wifi era gratuito ma il portale captivo era impostato per un limite di banda dopo la quale non potevi navigare fino al giorno successivo

la soluzione e' stata semplicemente quella di impostare il Mac Address della scheda wireless su Random. Ogni volta che arrivavo al limite di banda consumata mi e' bastato spengere e riaccendere il WiFi per assumere un nuovo Mac Address e continuare a navigare

Confronto ArucoTags ed AprilTags

 Ho provato una comparazione sulla stabilita' della misura di distanza usando Aruco Tags (con Opencv) e AprilTags (con AprilTag v2 e v3 modificata per avere la pose estimation)

Sono state acquisite 576 immagini con una camera Reolink E1 Pro (con immagini sia notturne che diurne) di due tag delle medesime dimensioni (4x4_100 per Aruco e 36h11 per Apriltag 10 cm)

Le nuove versioni di OpenCV hanno modificate le API per cui gli script che ho usato l'anno scorso non funzionano piu'. Per fare prima ho usato il docker sottostante che monta OpenCV 4.5.5

docker run -it -v /home/luca/ottico/:/home/ottico hdgigante/python-opencv:4.5.5-debian  sh

OpenCV ed Aruco mostrano outliers, Apriltag3 ne mostra solo uno mentre Apriltag 2 ha mostrato dati molto piu' stabili)

Rimossi gli outlier si evidenzia che l'errore quadratico medio di Arpriltag e' circa la meta' di quella di Aruco (l'errore quadratico  migliore e' circa lo 0,3 % della distanza)

Restful con resty in Go

Attenzione : necesssita' di GO 1.20. In versioni precedenti viene generato l'errore value.SetZero undefined

La libreria Resty github.com/go-resty/resty/ permette di utilizzare servizi restful anche dietro a proxy e con connessione insecure (connessione https con certificato scaduto) 

=========================================================

package main
import (
"crypto/tls"
"fmt"
"os"
"github.com/go-resty/resty/v2"   // libreria per rest
)
type AuthSuccess struct {
success      string
version      string
JWT          string
username     string
userid       string
parentuserid string
userlevelid  string
}
func dieOnError(msg string, err error) {
if err != nil {
fmt.Println(msg, err)
os.Exit(1)
}
}
// go get github.com/go-resty/resty/v2
func main() {
connStr := "connessione"
conn, err := go_ora.NewConnection(connStr)
dieOnError("Can't create connection:", err)
err = conn.Open()
dieOnError("Can't open connection:", err)
client := resty.New()
client.SetProxy("http://proxy.xxxxx.toscana.it:8080")
client.SetTLSClientConfig(&tls.Config{InsecureSkipVerify: true})
// User Login
resp, err := client.R().
SetFormData(map[string]string{
"username": "admin",
"password": "xxxxxxx",
"action":   "login",
}).
SetResult(&AuthSuccess{}).
Post("https://xxxxxx.xxxxxxx.it/api/")
if err != nil {
fmt.Println("Errore di login")
os.Exit(1)
}
token := resp.Result().(*AuthSuccess).JWT
fmt.Print(token)
}

Connession Oracle DB con Go

Per provare a connettere Oracle tramite Go torna utile utilizzare il seguente docker

docker run -d -p 1521:1521 -e ORACLE_PASSWORD=<your password> -v oracle-volume:/opt/oracle/oradata gvenzl/oracle-xe

l'utente e' SYSTEM e service XEPDB1

Per interagire con il db si puo' usare SQLDeveloper  

Con la libreria go-ora non e' necessario installare le librerie client di Oracle

package main

import (

    "database/sql"

    "fmt"

    _ "github.com/sijms/go-ora/v2"

)

func sqlOperations(db *sql.DB) {

    var queryResultColumnOne string

    row := db.QueryRow("SELECT punto_cantiere FROM nodo")

    err := row.Scan(&queryResultColumnOne)

    if err != nil {

        panic(fmt.Errorf("error scanning query result from database into target variable: %w", err))

    }

    fmt.Println("Risultato query", queryResultColumnOne)

    rows, err := db.Query("SELECT punto_cantiere,valore FROM nodo")

    if err != nil {

        // handle this error better than this

        panic(err)

    }

    defer rows.Close()

    for rows.Next() {

        var numero float32

        var nome string

        err = rows.Scan(&nome, &numero)

        if err != nil {

            // handle this error

            panic(err)

        }

        fmt.Println(numero, nome)

    }

    // get any error encountered during iteration

    err = rows.Err()

    if err != nil {

        panic(err)

    }

}

func GetSqlDBWithPureDriver(dbParams map[string]string) *sql.DB {

    connectionString := "oracle://" + dbParams["username"] + ":" +

        dbParams["password"] + "@" + dbParams["server"] + ":" +

        dbParams["port"] + "/" + dbParams["service"]

    db, err := sql.Open("oracle", connectionString)

    if err != nil {

        panic(fmt.Errorf("error in sql.Open: %w", err))

    }

    err = db.Ping()

    if err != nil {

        panic(fmt.Errorf("error pinging db: %w", err))

    }

    return db

}

var localDB = map[string]string{

    "service":  "XEPDB1",

    "username": "system",

    "server":   "localhost",

    "port":     "1521",

    "password": "password",

}

func main() {

    db := GetSqlDBWithPureDriver(localDB)

    defer func() {

        err := db.Close()

        if err != nil {

            fmt.Println("Can't close connection: ", err)

        }

    }()

    sqlOperations(db)

}

Aruco calibration file format

 Ho provato a vedere se effettuare la calibrazione di tag Aruco con immagini in formato raw lossless od in formato jpg (lossy) poteva influenzare l'errore finale

Per fare cio' ho preso un telefono Android che permette di salvare la stessa immagine in formato DNG ed in formato JPG 

Lo script di calcolo e' il seguente

import numpy as np
import cv2
import cv2.aruco as aruco

# Aruco parameters
aruco_dict = aruco.Dictionary_get(aruco.DICT_4X4_50)
aruco_params = aruco.DetectorParameters_create()

# Chessboard parameters
num_chessboard_corners_horizontal = 9
num_chessboard_corners_vertical = 6
chessboard_square_size = 0.025  # in meters

# Image directory and file extension
image_directory = 'path_to_images_directory/'
image_extension = '.jpg'

# Arrays to store object points and image points
obj_points = []  # 3D points in real-world coordinates
img_points = []  # 2D points in image plane

# Generate chessboard object points
chessboard_size = (num_chessboard_corners_horizontal,
num_chessboard_corners_vertical)
objp = np.zeros((num_chessboard_corners_horizontal *
num_chessboard_corners_vertical, 3), np.float32)
objp[:, :2] = np.mgrid[0:num_chessboard_corners_horizontal,
0:num_chessboard_corners_vertical].T.reshape(-1, 2)
objp = objp * chessboard_square_size

# Iterate through images and find chessboard corners
image_count = 0
while True:
    # Load image
    image_path = image_directory + str(image_count) + image_extension
    image = cv2.imread(image_path)
    if image is None:
        break

    # Convert to grayscale
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Find chessboard corners
    ret, corners = cv2.findChessboardCorners(gray, chessboard_size, None)

    # If corners found, add object points and image points
    if ret == True:
        obj_points.append(objp)
        img_points.append(corners)

        # Draw and display corners
        cv2.drawChessboardCorners(image, chessboard_size, corners, ret)
        cv2.imshow('Chessboard Corners', image)
        cv2.waitKey(500)

    image_count += 1

cv2.destroyAllWindows()

# Perform Aruco calibration
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(obj_points,
img_points, gray.shape[::-1], None, None)

# Calculate reprojection error
mean_error = 0
for i in range(len(obj_points)):
    img_points_proj, _ = cv2.projectPoints(obj_points[i], rvecs[i],
tvecs[i], mtx, dist)
    error = cv2.norm(img_points[i], img_points_proj, cv2.NORM_L2) /
len(img_points_proj)
    mean_error += error

calibration_error = mean_error / len(obj_points)
print("Calibration error: {}".format(calibration_error))

# Estimate additional error
reproj_error = 0
total_points = 0
for i in range(len(obj_points)):
    img_points_proj, _ = cv2.projectPoints(obj_points[i], rvecs[i],
tvecs[i], mtx, dist)
    error = cv2.norm(img_points[i], img_points_proj, cv2.NORM_L2)
    reproj_error += error
    total_points += len(obj_points[i])

additional_error = reproj_error / total_points
print("Additional error: {}".format(additional_error))

I risultati sono i seguenti (per i file DNG ho usato la libreria rawpy)

JPG

python calibration.py --dir ./jpg/ --square_size 0.015  -w 9 -t 6
Calibration error: 0.13602731796497697
Additional error: 0.13602731796497697

DNG

Calibration error: 0.13606447706803765

Additional error: 0.13606447706803765

In conclusione non si ha una significativa differenza di errore nell'usare JPG o DNG