Connettore N (disavventure di un radioamatore)

Pensavo che le antenne per radioamatori avessero connettori SMA, BNC e SO 239 (connettore HF femmina) e PL259 (connettore HF maschio)

Comprando una antenna Diamond x50n ho scoperto che esistono i connettori N

 

 

 

HU-069 CW Morse Decoder

Mi sono comprato questo kit denominato HU-069 (ne esiste una versione successiva alimentata via Usb) per imparare a saldare

 

Le istruzioni non sono granche' anche usando il link https://mp.weixin.qq.com/s/7lH6Fs58QgmLsrjEl6atdQ 

Nonostante istruzioni in alcuni casi lacunose sono riuscito a farlo funzionare. (non ho capito ancora a cosa serve il pulsante rosso).L'alimentazione e' 9V GND sull'esterno del jack). Il potenziometro sotto al di display regola la luminosita' di quest'ultimo

Non so quanto possa essere utile per il morse ma per imparare a saldare e correggere gli errori va piu' che bene visto anche il costo 

 

 

Chiavetta CW BH8DZE

Seguendo questo post ho provato la chiavetta BH8DZE (si vedra' che i due sono parenti prossimi)

 

 

Nulla di nuovo ...la cinesata si presenta come un mouse USB HID 

La cosa curiosa e' che l'identificativo 413d:2107  che sembra poter essere ricondotto a WinKeyer (oltre che ad un sensore di temperatura)

sembra che il processore sia della famiglia degli ATTiny (sicuramente non ATTiny8 perche' il numero di piedini e' 16)

 

luca@Dell:~$ lsusb
Bus 001 Device 013: ID 413d:2107  

Input driver version is 1.0.1
Input device ID: bus 0x3 vendor 0x413d product 0x2107 version 0x110
Input device name: "HID 413d:2107"
Supported events:
  Event type 0 (EV_SYN)
  Event type 1 (EV_KEY)
    Event code 272 (BTN_LEFT)
    Event code 273 (BTN_RIGHT)
    Event code 274 (BTN_MIDDLE)
  Event type 2 (EV_REL)
    Event code 0 (REL_X)
    Event code 1 (REL_Y)
    Event code 8 (REL_WHEEL)
    Event code 11 (REL_WHEEL_HI_RES)
  Event type 4 (EV_MSC)
    Event code 4 (MSC_SCAN)
Properties:
Testing ... (interrupt to exit)

Testing ... (interrupt to exit)
Event: time 1763723445.111938, type 4 (EV_MSC), code 4 (MSC_SCAN), value 90001
Event: time 1763723445.111938, type 1 (EV_KEY), code 272 (BTN_LEFT), value 1
Event: time 1763723445.111938, -------------- SYN_REPORT ------------
Event: time 1763723445.231861, type 4 (EV_MSC), code 4 (MSC_SCAN), value 90001
Event: time 1763723445.231861, type 1 (EV_KEY), code 272 (BTN_LEFT), value 0
Event: time 1763723445.231861, -------------- SYN_REPORT ------------
Event: time 1763723446.184010, type 4 (EV_MSC), code 4 (MSC_SCAN), value 90001
Event: time 1763723446.184010, type 1 (EV_KEY), code 272 (BTN_LEFT), value 1
Event: time 1763723446.184010, -------------- SYN_REPORT ------------
Event: time 1763723446.319872, type 4 (EV_MSC), code 4 (MSC_SCAN), value 90001
Event: time 1763723446.319872, type 1 (EV_KEY), code 272 (BTN_LEFT), value 0
Event: time 1763723446.319872, -------------- SYN_REPORT ------------

Keyer VBand e LearnMorsewithGoogle

Partendo dal precedente post ho modificato il programma per essere compatibile con VBand Trainer oltre che con LearnMorsewithGoogle aggiungendo anche la ripetizione se il paddle viene mantenuto premuto

il  programma puo' essere usato solo con privilegi di root (o sudo) 

il primo parametro e' il device

il secondo e' il tempo di ripetizione in millisecondi

il terzo il tipo di configurazione (0=VBand con tasti parentesi quadre, 1=Google con tasti . e / ed infine 3=VBand con tasti CTRL-LEFT e CTRL-RIGHT)  

 sudo ./autokey /dev/input/event19 300 0

 

#include <linux/uinput.h>

#include <fcntl.h>

#include <unistd.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <sys/select.h>

#include <signal.h>

volatile sig_atomic_t running = 1;

void signal_handler(int sig) {

running = 0;

}

void send_key(int ufd, int keycode) {

struct input_event ev;

memset(&ev, 0, sizeof(ev));

// Key press

ev.type = EV_KEY;

ev.code = keycode;

ev.value = 1;

write(ufd, &ev, sizeof(ev));

// Sync

ev.type = EV_SYN;

ev.code = SYN_REPORT;

ev.value = 0;

write(ufd, &ev, sizeof(ev));

// Key release

ev.type = EV_KEY;

ev.code = keycode;

ev.value = 0;

write(ufd, &ev, sizeof(ev));

// Sync

ev.type = EV_SYN;

ev.code = SYN_REPORT;

ev.value = 0;

write(ufd, &ev, sizeof(ev));

}

int main(int argc, char *argv[]) {

if (argc < 4) {

printf("Usage: %s /dev/input/eventX <delay_ms> <mode>\n", argv[0]);

printf("\nModes:\n");

printf(" 0: LEFT='[' RIGHT=']' (VBand)\n");

printf(" 1: LEFT='.' RIGHT='/' (Learn Morse Google)\n");

printf(" 2: LEFT=CTRL_LEFT RIGHT=CTRL_RIGHT (VBand2)\n");

printf("\nExample: %s /dev/input/event4 100 0\n", argv[0]);

return 1;

}

const char *mouse_dev = argv[1];

int delay_ms = atoi(argv[2]);

int mode = atoi(argv[3]);

if (delay_ms <= 0) {

printf("Error: delay must be positive\n");

return 1;

}

if (mode < 0 || mode > 2) {

printf("Error: mode must be 0, 1, or 2\n");

return 1;

}

// Define key mappings based on mode

int left_key, right_key;

const char *left_label, *right_label;

switch (mode) {

case 0:

left_key = KEY_LEFTBRACE;

right_key = KEY_RIGHTBRACE;

left_label = "'['";

right_label = "']'";

break;

case 1:

left_key = KEY_DOT;

right_key = KEY_SLASH;

left_label = "'.'";

right_label = "'/'";

break;

case 2:

left_key = KEY_LEFTCTRL;

right_key = KEY_RIGHTCTRL;

left_label = "CTRL_LEFT";

right_label = "CTRL_RIGHT";

break;

}

// Open mouse device

int mfd = open(mouse_dev, O_RDONLY | O_NONBLOCK);

if (mfd < 0) {

perror("Mouse open");

return 1;

}

// GRAB EXCLUSIVE ACCESS

if (ioctl(mfd, EVIOCGRAB, 1) < 0) {

perror("Cannot grab mouse device");

close(mfd);

return 1;

}

printf("Mouse device grabbed successfully\n");

// Open uinput

int ufd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);

if (ufd < 0) {

perror("uinput open");

ioctl(mfd, EVIOCGRAB, 0);

close(mfd);

return 1;

}

// Setup virtual keyboard - register all possible keys

ioctl(ufd, UI_SET_EVBIT, EV_KEY);

ioctl(ufd, UI_SET_KEYBIT, KEY_DOT);

ioctl(ufd, UI_SET_KEYBIT, KEY_COMMA);

ioctl(ufd, UI_SET_KEYBIT, KEY_SLASH);

ioctl(ufd, UI_SET_KEYBIT, KEY_LEFTBRACE);

ioctl(ufd, UI_SET_KEYBIT, KEY_RIGHTBRACE);

ioctl(ufd, UI_SET_KEYBIT, KEY_LEFTCTRL);

ioctl(ufd, UI_SET_KEYBIT, KEY_RIGHTCTRL);

struct uinput_setup usetup;

memset(&usetup, 0, sizeof(usetup));

snprintf(usetup.name, UINPUT_MAX_NAME_SIZE, "mouse2key-mode%d", mode);

usetup.id.bustype = BUS_USB;

usetup.id.vendor = 0x1;

usetup.id.product = 0x1;

usetup.id.version = 1;

ioctl(ufd, UI_DEV_SETUP, &usetup);

ioctl(ufd, UI_DEV_CREATE);

// Setup signal handler

signal(SIGINT, signal_handler);

signal(SIGTERM, signal_handler);

printf("Mode %d selected - Delay: %dms\n", mode, delay_ms);

printf(" Hold LEFT button = send %s repeatedly\n", left_label);

printf(" Hold RIGHT button = send %s repeatedly\n", right_label);

printf("Press Ctrl+C to exit\n\n");

struct input_event ev;

fd_set readfds;

struct timeval timeout;

int left_pressed = 0;

int right_pressed = 0;

while (running) {

// Setup select with timeout

FD_ZERO(&readfds);

FD_SET(mfd, &readfds);

int ret;

// Only use timeout if a button is held

if (left_pressed || right_pressed) {

// Send keystroke(s) immediately

if (left_pressed) {

send_key(ufd, left_key);

//if (mode < 2) printf(".");

fflush(stdout);

}

if (right_pressed) {

send_key(ufd, right_key);

//if (mode < 2) printf(",");

fflush(stdout);

}

// NOW wait for the delay

timeout.tv_sec = delay_ms / 1000;

timeout.tv_usec = (delay_ms % 1000) * 1000;

ret = select(mfd + 1, &readfds, NULL, NULL, &timeout);

if (ret < 0) {

perror("select");

break;

}

} else {

// No button held, just wait for events (blocking)

ret = select(mfd + 1, &readfds, NULL, NULL, NULL);

if (ret < 0) {

perror("select");

break;

}

}

// Check for mouse events

if (FD_ISSET(mfd, &readfds)) {

while (read(mfd, &ev, sizeof(ev)) > 0) {

if (ev.type == EV_KEY) {

if (ev.code == BTN_LEFT) {

if (ev.value == 1) {

// Left button pressed

left_pressed = 1;

//printf("\n[LEFT pressed - sending %s]\n", left_label);

} else if (ev.value == 0) {

// Left button released

left_pressed = 0;

//printf("\n[LEFT released]\n");

}

} else if (ev.code == BTN_RIGHT) {

if (ev.value == 1) {

// Right button pressed

right_pressed = 1;

//printf("\n[RIGHT pressed - sending %s]\n", right_label);

} else if (ev.value == 0) {

// Right button released

right_pressed = 0;

//printf("\n[RIGHT released]\n");

}

}

}

}

}

}

// Cleanup

printf("\nCleaning up...\n");

ioctl(ufd, UI_DEV_DESTROY);

ioctl(mfd, EVIOCGRAB, 0);

close(ufd);

close(mfd);

return 0;

}

 

il significato di BiasT (disavventure di un radioamatore)

 Sempre alle prese nel trovare una antenna che riceva discretamente ma non sia impegnativa come la Sirio Boomerang ho provato una antenna loop amplificata cinese.

 

L'antenna e' arrivata senza spiegazione delle impostazione dei microswitch, gia' con un microswitch, senza nessuna indicazione della polarita' del jack e con una netta differenza sulla alimentazione tra quello riportato sul web (5-12 V) e quello riportato vicino al jack (9-18V)...si inizia bene

 

Inizio a collegare antenna all'SDR per vedere quanto riceveva senza alimentazione e noto che il led verde dell'amplificatore si accende...strano penso ma non pongo troppa attenzione

 

Switch nero vorra' dire on oppure off?

 ho il 50% di possibilita' di avere fortuna e collego una alimentazione a 12 V...tutto funziona...il segnale e' nettamente amplificato (anche se di fatto e' decisamente scadente)...solo che dopo un minuto inizio a sentire puzzo di bruciato

Stacco tutto...SDR rovente...a questo punto ho scoperto che cosa vuole dire BiasT. In pratica SDR ha una funzione per cui riesce ad alimentare una antenna usando lo stesso cavo del segnale. Io ho iniettato 12 V dall'esterno oltre ai 5V dell'SDR mandando in crisi tutto il sistema. Esiste una funzione per disattivare via software  BiasT

  

Importanza di una antenna (disavventure di un radioamatore)

Le antenne costano e sono solo degli inutili pezzi di ferro....sbagliato...

Sotto un confronto a parita' di ricevitore(RTL-SDR 4)  e posizione tra una antenna loop cinese (addirittura con tuner integrato)  ed una antenna Boomerang Sirio a 27 MHz

Sirio

Loop cinese

La Sirio inoltre riceve molto bene anche lontano dalla propria frequenza..

 

 

 

 

 

 

Meteo Radio Fax

3853 KHz 

Esempio di trasmissione bollettino meteo su frequenza 7.647 MHz servizio DDH7

 Esempio di trasmissione bollettino meteo su frequenza 7.647 MHz servizio DDH7

APRS Lora con IGate

 Ho provato ad usare il tracker APRS basato su Lora ed il gateway verso internet 

https://github.com/lora-aprs/LoRa_APRS_Tracker

https://github.com/lora-aprs/LoRa_APRS_iGate

il progetto e' sviluppato in Platformio 

Come Lora board ho modificato il file.ini del progetto in board = ttgo-t-beam

Le altre configurazioni si trovano nel file Json dove si trovano le impostazioni del trasmettitore/ricevitore Lora, il callsign

Il progetto si compila semplicemente ...l'unica accortezza e' quella alla fine di lanciare Upload Filesystem Image per caricare anche il file di configurazione oltre al programma

Sul IGate nel file di configurazione is-cfg.json si impostano i dati della rete WiFi ed il proprio account presso il servizio aprs2.net per poter inviare su Internet i dati ricevuti e visualizzarli su https://aprs.fi/#!lat=43.75867&lng=11.29033

Programmazione CRT Micron

 Per programmare il CRT Micron ci vuole un cavo seriale che si connette all'RJ45 frontale secondo lo schema. In pratica si usa un USB-2-TTL

Si puo' fare anche da soli ma io ne ho trovato io gia' fatto su Aliexpress ad un prezzo decisamente inferiore a quello originale (circa 8 euro)

Il software puo' essere scaricato qui. Un programma e' per la sola configurazione, il secondo e' quello per impostare i canali ed altri dettagli (tipo il messaggio di benvenuto)

https://www.kcb.co.uk/contents/en-uk/d170_Software.html

Dal software si puo' fare l'espansione delle bande...a me e' gia' arrivato in Modo 2 ovvero la massima ampiezza (UHF 400-490 e VHF 144-148) . Si puo' fare anche dalla radio premendo all'avvio ON+FUN+P4, si seleziona il menu 43, si preme PTT fino a quando il numero del modo non cambia colore, sempre premendo PTT si gira la manopola, si rilascia e si riavvia la radio

Oltre al software della casa madre si puo' usare anche il progetto open source

https://github.com/CircuitChaos/OpenMicron/

in caso di problemi per fare il reset Menu/Func Menu/ opzione 21 RST

Minimodem CRT Micron

Usando il cavo visto qui si puo' usare il CRT Micron anche per inviare trasmissioni  audio modem FSK tramite il programma minimodem

Si puo' scrivere il contenuto del messaggio in un file e poi effettuare la trasmissione con

cat prova.txt |minimodem --tx 100

Frequenza ISM

 Con RTL-SDR e' possibile "ascoltare" il traffico ISM su 433.9 MHz 

I pacchetti si possono leggere tramite il plugin di OpenWebRX oppure da linea di comando 

oppure da linea di comando si puo' usare rtl-433

sudo apt install rtl-433 

APRS con CRT Micron

Per prima cosa si programma la radio per l'ascolto su 144.800 MHz

Il secondo passo e' crearsi un cavetto per connettere l'uscita audio  

La via piu' semplice se si vuole solo ricevere e' connettere l'uscita audio della radio sul dietro del dispositivo con la scheda audio tramite un semplice cavo jack audio (il cavo deve andare sul MIC della scheda audio)

Altrimenti se si vuole anche trasmettere si deve scollegare il microfono della radio e crearsi un cavo apposito

Si prende un cavo RJ45 e si taglia

Si prende un jack maschio TRSS (io per semplicita' ho preso un adattatore che permette collegamenti rapidi)

Si deve collegare 

blu -> tip

biancoblu e marrone -> ring 2

verde -> sleeve

a questo punto i collegamenti con la scheda audio sono i seguenti

Da ricordarsi di attivare il VOX sulla radio perche' in questa configurazione non e' gestito il PTT

Si installa il software direwolf

sudo apt install direwolf 

una volta installato Direwolf con Apt si deve copiare il file di configurazione di esempio direwolf.conf.gz da /usr/share/doc/direwolf/conf/ e lo si copia nella propria home e lo di scompatta

si lancia il comando 

arecord -l

e si osserva l'identificativo della scheda di rete e si modifica il file (nel mio caso)

ADEVICE  plughw:1,0

ARATE 48000

a questo punto si lancia direwolf (per me vuole sudo per abilitare il microfono)

Se tutto e' andato a buon fine si ricevono i messaggi APRS come nell'immagine sottostante

Oltre a ricevere e decodificare APRS direwolf permette anche l'invio di pacchetti aprs 

Si modifica direwolf.conf con una stringa simile alla seguente

PBEACON delay=1  every=30 overlay=S symbol="digi" lat=43^46.45N long=011^14.46E power=50 height=20 gain=4 comment="Luca Innocenti Florence (Italy)"

ed in automatico vengono inviati messaggi