ISS ARISS 11 aprile 2022

 

ISS SSTV Aprile 2022

Ricezione piuttosto scadente

 

Stima distanze con Aruco Tags ed OpenCV

Ho voluto provare questo progetto

https://github.com/GSNCodes/ArUCo-Markers-Pose-Estimation-Generation-Python

ho provato ad usare la webcam del portatile per provare a stimare le distanze mediante i tag Aruco (sono concettualmente simili a QrCode ma piu' robusti per il riconoscimento a scapito del numero di dati inseriti...di fatto solo un codice ID)..altri progetti usano gli AprilTag

Attenzione : e' necessario Python3

Per generare i tag si usa il codice sottostante

python3 generate_aruco_tags.py --id 24 --type DICT_4X4_50 --output tags/ -s 230

id = codice inserito nel tag

type = formato del tag (ne esistono molti...si puo' vedere l'elenco nel file utils.py)

output = e' il folder dove sono salvati i file png dei tag

s = dimensioni del tag

Esempio di tag

Il passo successivo e' quello di crea i file di calibrazione della camera. Si usa una scacchiera (checkerboard)...ho fatto alcune prove ed alcune immagini non funzionano ...ho usato quella proposta da OpenCv in formato 9x6

Si devono fare fotografie in cui si vede la scacchiera posizionata a diversa distanza e con diverse angolazioni e si mettono in una sottodirectory 

Checkerboard

Una delle immagini di calibrazione

Dopo aver raccolto una ventina di immagini di calibrazione (nel mio caso salvato nel folder pose) si lancia

python3 calibration.py --dir './pose/' -s 0.023  -w 9 -t 6

se tutto va a buon fine saranno create i file della matrice di calibrazione e dei coefficienti di distorsione

A questo punto si puo' procedere con la stima di distanza

python3 pose_estimation.py --K_Matrix calibration_matrix.npy --D_Coeff distortion_coefficients.npy --type DICT_4X4_50

il codice e' leggermente differente dal progetto originario perche' di fatto in origine vengono calcolate le matrici rvec e tvec ma non viene effettuato il calcolo della distanza. Le modifiche possono essere ritrovate al mio GitHub https://github.com/c1p81/Aruco_distance

Macchie solari

 Riprese con Celestron 70/700 con filtro in mylar...avevo comprato il filtro solare l'anno scorso quando l'attivita' solare era al minimo e non erano presenti macchie😊😊

Platformio IDF MPU6050

Ho voluto provare a fare un esperimento programmando un ESP32 con il framework IDF al posto di quello Arduino (esperimento che rimarra' solitario perche' alla fine non ho trovato grandi vantaggi)

Ho avuto diverse difficolta' ad usare il monitor seriale di Platformio per cui ho usato Minicom

Il codice (si tratta sostanzialmente dell'esempio della libreria con impostate lo porte SDA SCL a GPIO 21 e 22 nel file i2c.c alla riga 23 e 24) 

Anatomia di un conducimetro Neomet 29D

In ufficio e' morto il conducimetro da cantiere. Una volta rimosso dall'inventario e' arrivato il momento di sezionarlo

All'interno si puo' osservare la presenza di un microcontrollore ATMega 103L (8 bit, Flash 128 Kb, EEPROM 4 Kb, SRAM 4Kb), un integrato MAX232CE (RS232 porta seriale) ed un display da 4.3 pollici 94V0. Il display e' saldato alla base 

Al di sotto si trova un ICL7135CPI, un convertitore analogico digitale a 4 digit 1/2 ed un DC/DC converter tc7662cpa

Manuale 

 

Protocol Buffers in Golang

 Protocol Buffers (protobuf) e' una libreria di Google per la serializzazione di dati. Con il termine serializzazione si intende il processo di tradurre una "data structure" (array, struttura, albero binario.....) in un file che conservi oltre che i dati anche la struttura. Una forma tipica di serializzazione sono i file in formato JSON

Per utilizzare protobuf con GoLang si parte dalla definizione della struttura in file .proto. Un semplice modello puo' essere il seguente

syntax = "proto3";

package main;

import "google/protobuf/timestamp.proto";

message Person {

string name = 1;

int32 id = 2;

string email = 3;

google.protobuf.Timestamp last_updated = 5;

}

da notare che il file .proto deve avere lo stesso package del codice che lo utilizzera'

i numeri di fianco ai vari campi sono univoci

il file .proto deve essere compilato tramite il compilatore protoc. Su Debian l'installazione del compilatore avviene mediante

apt install protobuf-compiler

apt install golang-goprotobuf-dev

si crea il file .proto nella stessa directory del sorgente Go e si compila con

protoc --go_out=. *.proto

questo genera un nuovo file con estensione .go. Se si apre il file con editor di testo si osserva che oltre alla struttura dei dati sono state create delle funzioni tipo helper che facilitano l'immissione e gestione della struttura dati

per gestire i dati all'interno del progetto Go, nel caso si usino tipo dati di uso comune tipo datetime gia' formalizzati in protobuf si deve scaricare la loro definizione per esempio

go get github.com/golang/protobuf/ptypes/timestamp

i dati di un protobuf possono essere salvati su un file ma questo sara' binario e non immediatamente human readable

package main

import (

"fmt"

"io/ioutil"

"log"

proto "github.com/golang/protobuf/proto"

)

// apt install protobuf-compiler

// per compilare il file proto

// protoc --go_out=. *.proto

// go get github.com/golang/protobuf/ptypes/timestamp

func main() {

dati_persona := &Person{

Name: "Luca",

Id: 51, //per poco ancora

}

data, err := proto.Marshal(dati_persona)

if err != nil {

log.Fatal("marshaling error: ", err)

}

fmt.Println(data)

out, err := proto.Marshal(dati_persona)

if err != nil {

log.Fatalf("Serialization error: %s", err.Error())

}

if err := ioutil.WriteFile("dati.bin", out, 0644); err != nil {

log.Fatalf("Write File Error: %s ", err.Error())

}

fmt.Println("Write Success")

//Read from file

in, err := ioutil.ReadFile("dati.bin")

if err != nil {

log.Fatalf("Read File Error: %s ", err.Error())

}

dati_persona2 := &Person{}

err2 := proto.Unmarshal(in, dati_persona2)

if err2 != nil {

log.Fatalf("DeSerialization error: %s", err.Error())

}

fmt.Println("Read Success")

fmt.Printf("Nome %s\n", dati_persona2.GetName())

}