TpLink WN722N v2v3 monitor ESP-NOW con Debian 11

 Volevo usare la scheda WN722N per monitorare il traffico Esp-Now usando WireShark...il fatto e' che la scheda e' riconosciuta da Debian 11 ma non entrava in monitor mode mentre usando ParrotOs funzionava perfettamente.

La soluzione e' ricompilare il modulo  usando questo link

git clone https://github.com/gglluukk/rtl8188eus

make &make install

e eliminando il modulo di defualt

sudo echo 'blacklist r8188eu'|sudo tee -a '/etc/modprobe.d/realtek.conf'

al riavvio si puo' monitorare il traffico mediante questi comandi

sudo ip link set wlx9c532268fdca down
sudo iw wlx9c532268fdca set monitor control
sudo ip link set wlx9c532268fdca up
sudo wireshark

per selezionare il traffico proveniente da un determinato MAC si puo'usare

wlan.sa==xx:xx:xx:xx:xx:xx

Il seguente codice invia un messaggio broadcast su ESP-NOW con abilitato il Long Range (evidenziato in giallo)

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

/*

  ESP-NOW Demo - Transmit

  esp-now-demo-xmit.ino

  Sends data to Responder

  

  DroneBot Workshop 2022

  https://dronebotworkshop.com

  https://dronebotworkshop.com/esp-now/

*/

// Include Libraries

#include <esp_wifi.h>

#include <esp_now.h>

#include <WiFi.h>

// Variables for test data

int int_value;

// MAC Address of responder - edit as required

uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

esp_interface_t current_esp_interface;

wifi_interface_t current_wifi_interface;

// Define a data structure

typedef struct struct_message {

  char a[32];

  int b;

} struct_message;

// Create a structured object

struct_message myData;

// Peer info

esp_now_peer_info_t peerInfo;

// Callback function called when data is sent

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {

  Serial.print("\r\nLast Packet Send Status:\t");

  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");

}

void setup() {

  int_value = 0;

  Serial.begin(115200);

  WiFi.mode(WIFI_STA);

  esp_wifi_set_protocol(current_wifi_interface, WIFI_PROTOCOL_LR);

  if (esp_now_init() != ESP_OK) {

    Serial.println("Error initializing ESP-NOW");

    return;

  }

  esp_now_register_send_cb(OnDataSent);

  memcpy(peerInfo.peer_addr, broadcastAddress, 6);

  peerInfo.channel = 0;  

  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK){

    Serial.println("Failed to add peer");

    return;

  }

  

}

void loop() {

 strcpy(myData.a, "Luca");

  int_value++;

  myData.b = int_value;

  esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));

  if (result == ESP_OK) {

    Serial.println("Sending confirmed");

  }

  else {

    Serial.println("Sending error");

  }

  delay(1000);

}

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

Per leggere i pacchetti ESP-NOW a linea di comando si puo' usare tcpdump oppure un progetto Go che utilizza le libreria Pcap https://pkg.go.dev/github.com/google/gopacket/pcap

Ophcrack per recuperare password Windows XP

Il problema e' seguente: recuperare la password da un vetusto PC con XP senza pero' resettarla

Soluzione : usare Ophcrack, un live CD linux con il sofo software per recuperare le password dagli has

Per prima cosa si deve indicare dove sono le tabelle. Se si effettua il download con le tabella gia' caricate esse si trovano in /media/ophcrack

Dopo di cio' si deve indicare dove si trova il file delle password che e'  in Windows/system/config

Sul mio calcolatore le passwords erano di 7 lettere ed il sistema ha impiegato pochi minuti per decrittarle 

Aruco terrestrial spotting scope

Aggiornamento: ho sostituio il Meade con il Celestron da viaggio da 70 mm. L'errore di standard deviation a 50 m e' stimato intorno al 0.6% della distanza (quindi 30 cm). Comincia a non valere piu' la pena di lavorarci sopra

Volevo vedere se era possibile usare Aruco Tags mediante telescopio (o meglio spotting scope terrestre) 

I modelli in vendita non hanno l'oculare rimuovibile (sono venduti per uso di tiro al bersaglio o bird watching) ed ho preso il mio Meade AC 70/350 ETX-70 GoTo, un rifrattore da viaggio che non uso quasi mai per la mancanza del puntatore,ed una SVBony 105

A 50 m un tag aruco da 10 cm occupa circa 120x120 pixels

per acquisire in automatico ho utlizzato i comandi sottostanti .Da notare che il SVBony 105 esce in YUYV e non RGB 

v4l2-ctl -c exposure_auto=0

sleep 10

fswebcam -r 1920x1080 --jpeg 95 -D 1 --no-banner --device /dev/video2 --skip 50 --loop 10 -p YUYV --save pic%Y-%m-%d_%H:%M:%S.jpg

giusto per confronto lo stesso bersaglio ripreso da una Canon 450D con tele da 300

Aruco vs Apriltag condizioni reali

Aggiornamento:

Dopo aver provato un po' di tutto per correggere i dati ho scoperto che le immagini originali non sono state riprese in modo corretto. La camera satura in alcuni condizioni di luce come si vede dai due esempi sottostanti rendendo inutile l'elaborazione

Prova comparativa per misuare distanze tramite April ed Aruco tag in condizioni reali 

Lo scopo e' quello di verificare la ripetibilita' delle misure di distanza mediante tag a condizioni di luce variabile e per questo sono state effettuate misure con i tag in posizione stazionaria

E' stata impiegata una camera di sorveglianza a fuoco fisso con acquisizione ogni 10 minuti anche di notte grazie all'illuminazione ad infrarossi

I tag sono stati di dimensione di 25 cm in formato 4x4 per Aruco e 36h11 per gli Apriltag

Per determinare la distanza sono state impiegate le librerie OpenCV su Python per agli Aruco Tags mentre la libreria Apriltags3 in C++

in generale gli Apriltag risultano meglio individuabili rispetto agli Aruco tag. Di 430 immagini totali gli Apriltags sono stati individuati al 99% ad una distanza di 6 m mentre gli Aruco tag hanno prestazioni simili ma solo sulla breve distanza (4 m)

Aruco

l'elaborazione dei tag aruco indica che l'algoritmo genera molti outliers che possono essere facilmente separati dai dati corretti

Provando a smussare i dati con una media mobile a finetra oraria la situazione non migliora e si osserva un comportamento legato all'illuminazione che si ritrovera' anche dopo con gli April Tags 

Apriltag

Dall'analisi dei grafici si vede che le condizioni di illuminazione condizionano fortemente la misura della distanza mediante Apriltag. Le misure piu' stabili sono di notte quando e' attiva l'illuminazione dei led ad infrarossi

Rispetto ad Aruco ci sono molti meno outliers ed i dati sono meno rumorosi

In queste condizioni e' stato registrato un errore di standard devitation pari a 0.96% della distanza per il tag a 6.5m e dell'1% per il tag a 10 m

Se si plottano i dati a parita' di ora del giorno si vede ancora piu' chiaramente come la presenza di ombra influenza il dato di distanza

Se si fa la differenza tra le due curve l'errore scende al 0.18%

Un sistema per rimuovere l'effetto dell'illuminazione e' di correlare i dati dei due tag (sono vicini quindi sono illuminati in modo comparabile)

Per cercare di risolvere il problema delle differenti illuminazione ho provato ad elaborare le immagini mediante l'algoritmo presentato in questo articolo (Illumination Invariant Imaging: Applications in Robust Vision-based Localisation, Mapping and Classification for Autonomous Vehicles)

In estrema sintesi l'algoritmo appiattisce una immagine RGB e cerca di annullare gli effetti di differente illuminaizone (questo algoritmo funziona solo sulle immagini diurne perche' la camera di notte acquisisce a scala di grigi)

Per le elaborazioni ho usato questo progetto su Github.  (ho dovuto fare una leggere modifica perche' le immagini della camera avevano dei valori zero che ovviamente non potevano essere usati in un logaritmo)

import cv2

import numpy as np

import os

from argparse import ArgumentParser

from multiprocessing import Pool

ROBOTCAR_ALPHA = 0.4642

def transform(im):

# Assumes image is RGB-ordered

image = cv2.imread(read_dir + "/" + im, cv2.IMREAD_UNCHANGED)

r, g, b = image[:, :, 0], image[:, :, 1], image[:, :, 2]

// per eliminare gli eventuali zeri dalla matrice

r = np.where(r==0, 0.1, r)

g = np.where(g==0, 0.1, g)

b = np.where(b==0, 0.1, b)

ii_image = 0.5 + np.log(g) - ROBOTCAR_ALPHA*np.log(b) - (1-ROBOTCAR_ALPHA)*np.log(r)

# Lastly, convert from float to uint8 space

max_ii = np.max(ii_image)

min_ii = np.min(ii_image)

uii = np.uint8((ii_image - min_ii) * 256 / (max_ii - min_ii))

ii_name = write_dir + "/" + im

cv2.imwrite(ii_name, uii)

return ii_image

def transform_loop(directory):

image_names = os.listdir(directory)

# Spawn 4 worker processes to transform in parallel

p = Pool(4)

p.map(transform, image_names)

if __name__ == '__main__':

parser = ArgumentParser(

description=

'Transform images in a directory into lighting invariant color space')

parser.add_argument('--read-dir', action="store", type=str, required=True)

parser.add_argument('--write-dir', action="store", type=str, required=True)

args = parser.parse_args()

global read_dir, write_dir

read_dir = args.read_dir

write_dir = args.write_dir

transform_loop(read_dir)

dopo l'applicazione della elaborazione l'algoritmo di riconoscimento dei tag risulta molto piu' in difficolta' nel riconoscere i taf e sono state estratte solo 71 misure di distanza del tag1 e 16 misure del tag 2

Aggiornamento:

Frugando dentro al codice della demo di Apritag3 c'e' un porzione di codice che non puo' mai essere eseguito (c'e' un IF sempre True) e la condizione Falsa e' appunto l'algoritmo di Illumination Invariant 

Basta modificare la riga 156 per esempio aggiungendo un NOT si introduce il calcolo

questi sono i grafici risultanti dopo l'algoritmo. Si e' oersa la ritmicita' dell'illuminazione ma si e' persa anche la capacita' di riconoscere i tag nelle immagini trattate (per il tag 1 circa il 50%, tag2 decisamente peggio)

L'errore percentuale delle standard deviation e' pari a 1.79% per il tag1 e 1.08% per il tag 2

La differenza risiede nel valore del parametro utilizzato nell'elaborazione delle immagini

Files in TI-89

 TiOs non ha un vero e proprio file system ma permette comunque di salvare file dati sul calcolatore

Per esempio si puo' usare il programma TiGraph per generare delle note

Il file non sara' identificato dal nome ma dalla "variabile" associata

Una volta trasferito il file sulla calcolatrice sono tilp2 si puo' aprire la nota con il text editor

E' possibile usare dei folder ma in questo caso si e' usata la root che in TiOs viene definita main ed il file compare automaticamente aprendo la finestra del menu variabile

altirmenti si possono generare dei file custom da codice. La cosa interessante e' che i file su TiOs non sono compatibili con la versione PC. Per esempio un semplice file testo ha un header ed un tag di chiusura (OTH_TAG) 

//https://technoplaza.net/programming/lesson10.php

#define USE_TI89

#include <stdlib.h>

#include <stdio.h>

#include <estack.h>

int _main(void)

{

const int dimx = 50, dimy = 50;

FILE *fp = fopen ("example2", "wb");

fprintf(fp, "P6\n%d %d\n255\n", dimx, dimy);

fputs("luca",fp);

fputc (0, fp);

fputs ("HSC", fp);

fputc (0, fp);

fputc (OTH_TAG, fp);

fclose (fp);

return 0;

}

TI-89 scrittura diretta in memoria video

 Oltre a poter usare un buffer per generare grafica si puo' avere anche la scrittura diretta in memoria video sulla TI-89 puntando all'indirizzo 0x4C00

#define USE_TI89

#define SAVE_SCREEN // Save/Restore LCD Contents

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <kbd.h>

char * reale = (char *) 0x4C00;

int c;

void setpixel(int x, int y)

{

int yc = 30*y;

int xc = (int)floor(x/8);

int xd = 1<<(7-(x % 8));

reale[yc+xc]=xd;

}

void pulisci(void)

{

for (c=0;c<3840;c++)

{

reale[c]=0;

}

}

int _main(void)

{

pulisci();

for (c=0;c<80;c++){

setpixel(c,c);

}

ngetchx();

return 0;

}

Schermo virtuale su TI-89

Una delle cose divertenti con la TI-89 e' di avere il controllo completo dell'hardware con l'accesso diretto alla memoria video

La memoria dello schermo LCD inizia a 0x4C00

Si puo' fare puntare lo schermo virtuale ad una zona di memoria e poterla trattare con i comandi grafici (ogni byte di memoria contiene l'informazione di 8 pixels) 

dopo aver creato il buffer video si puo' copiarlo sulla vera memoria video per mostrare il risultato

attenzione: nonostante la TI-89 abbia uno schermo di dimensione 160x100 il codice funziona solo con le dimensione di 240x128 ovvero le dimensioni della TI-92 (la sorella maggiore)

#define USE_TI89

#define SAVE_SCREEN // Save/Restore LCD Contents

#include <stdlib.h>

#include <stdio.h>

#include <graph.h>

#include <kbd.h>

#include <string.h>

int _main(void)

{

char virtual[LCD_SIZE];

//PortSet ((void *) 0x4C00, 239, 127);

int i;

for (i=1;i<50;i++)

{

DrawPix(i,i,A_NORMAL);

}

ngetchx();

memcpy (LCD_MEM, virtual, LCD_SIZE);

ngetchx();

PortRestore();

return 0;

}