Fedora 44: KiCad, 3D viewer non visualizzo i componenti

KiCad nell'ambiente PCB, selezionando 3D Viewer, il visualizzatore mostra solo il PCB, senza i componenti:

Soluzione: non è stata installata la libreria 3D dei componenti:

$ sudo dnf install kicad-packages3d

radiotray-ng: bookmark di radio italiane

L'idea prende spunto dall'ottimo lavorato pubblicato qui: https://www.lffl.org/2020/09/guida-radio-italiane-radiotray-ng.html, di costituire un segnalibro delle sole principali radio italiane.

Altre radio di proprio gradimento, non presenti, possono ovviamente essere aggiunte manualmente attraverso l'app bookmark editor:

 

Procedura 

1. Scaricare il file bookmark.json (aggiornato a: 08.03.2026 )

2. Copiarlo nella directory utente di radiotray-ng

Aprire un terminale standard, portarsi nella directory in cui è stato scaricato il file (esempio: ~/Scaricati) e lanciare il comando: 

cp ./bookmark.json  ~/.config/radiotray-ng 

3. Ricaricare il segnalibri

Dal menù "Preferences" di radiotray-ng selezionare "Reload bookmarks":

 

 

Sotto il gruppo "Radio italiane", sarà ora possibile scorrere l'elenco delle radio presenti nel segnalibro:

 

 

Buon ascolto! 

 

Fedora Core 43 (gnome): installare radiotray-ng

1) Installare il pacchetto radiotray-ng:

Da un terminale non privilegiato:

sudo dnf install radiotray-ng

 

2) Installare l'estensione per visualizzare l'icona nella tray

Dal gestore estensioni, cercare (Sfoglia) AppIndicator and KStatusNotifierItem Support

quindi abilitarla, attivando il relativo switch:

3) Lanciare radiotray-ng. all'avvio (per tutti gli utenti):

Da un terminale non privilegiato:

sudo ln -s /usr/share/applications/radiotray-ng.desktop /etc/xdg/autostart

Riavviare il sistema per rendere effettive le modifiche.

L'icona di radiotray-ng sarà ora visibile nella tray, con un elenco di stazioni di default 

 

Il prossimo passo sarà configurare l'elenco delle stazioni preferite con Radiotray-ng Boomark Editor:

 

 

Ubuntu/Mint/Debian based: disabilitare bluetooth

Se non si usa bluetooth è possibile disabilitarne il relativo servizio, accellerando così l'avvio del sistema:

sudo systemctl disable blueman-mechanism.service

sudo systemctl mask blueman-mechanism.service

Fedora 43: installare MS TTF Core Fonts

 

sudo dnf install -y curl cabextract xorg-x11-font-utils fontconfig

sudo rpm --nodigest -ihv https://downloads.sourceforge.net/project/mscorefonts2/
rpms/msttcore-fonts-installer-2.6-1.noarch.rpm

sudo fc-cache -fv

Filtro audio per ascolto CW con TL081

Un semplice , ma efficace, filtro attivo (passabanda ad elevato Q) per l'ascolto della nota del CW, che ho ritrovato su un backup di qualche anno fa. 

La topologia di circuito è basata su un filtro notch a doppio T (Twin-T), che essendo inserito nel ramo di reazione ne "capovolge" il comportamento, ovvero il guadagno sarà massimo solo per la frequenza di notch e quindi avremo un filtro passa banda molto stretto.

Ricordo che il circuito fu da me preso dallo schema di un ricevitore IR di un TV Grundig anni 80, e riadattato per "centrarlo" sulla nota classica della ricezione CW (750/800 Hz).

Esso va ovviamente inserito a monte del finale di potenza (che pilota l'altoparlante o le cuffie) con un potenziometro di regolazione del volume.

La frequenza centrale misurata in simulazione, al netto quindi di tolleranze dei componenti reali, è di circa 830 Hz e il fattore di Q@-3dB è di circa 42 .

La formula di calcolo della frequenza centrale f0 del filtro passa banda  è:

Ponendo R=8200 Ohm, e Cserie=47nF/2 (i due condensatori sono in serie), abbiamo

La simulazione AC di LTspice:

FiltroCW.FCD (file FidocadJ)

FiltroCW800_telpar.asc (file LTspice)
  

Di seguito schematico, lato componenti, lato rame e file FidocadJ

 N.B. RIDIMENSIONARE LA STAMPA DEL PCB (latoRame.jpg) AL 23% (apri immagine in una nuova scheda). SI CONSIGLIA FIREFOX 

Zorin OS 17.2 / Mint 22.x : kolourpaint mancano icone della toolbar

Occorre installare il tema breeze:

 

sudo apt install breeze-icon-theme

 

 

Zorin OS 17.2 core: rimuovere snap

 

Queste semplici modifiche hanno fatto guadagnare 5 secondi sull'avvio del sistema (misurati con systemd-analize)

 

sudo systemctl stop snap

sudo systemctl disable snap

sudo apt purge snapd gnome-software-plugin-snap

 

Debian 12: aggiornare winetricks

Problema: winetricks non riesce a scaricare i font core MS. restituendo il seguente messaggio di errore:

Note: command cabextract -q -d /home/frank/.wine/dosdevices/c:/windows/temp /home/frank/.cache/winetricks/corefonts/andale32.exe returned status 1. Aborting.

 

Soluzione: aggiornare winetricks con il seguente comando:

sudo winetricks --self-update

Fedora 41: installare wine

 Installare prima wine32 e quindi wine:

 

sudo dnf install wine.i686

 

sudo dnf install wine

Fedora 41 (Gnome): ridurre il consumo di RAM "a riposo"

Questa semplice modifica, ha ridotto il consumo di RAM "a riposo" (cioè senza applicazioni foreground in esecuzione) da 2,7GB a circa 750MB:

sudo rm /etc/xdg/autostart/org.gnome.Software.desktop

 

Fedora 41: VirtualBox can't operate in VMX root mode. Please disable the KVM kernel extension

Sembra che Virtualbox non "voglia fra i piedi" :) un eventuale modulo KVM caricato...

1) Passiamo a root: 

frank@fedora:~$ su -
Password:  
 

2) Cerchiamo nei moduli caricati l'occorrenze di "kvm":

  
root@fedora:~#  lsmod | grep kvm
kvm_intel             446464  0
kvm                  1449984  1 kvm_intel
 

3) "kvm_intel" è il nome del modulo kvm caricato, che andiamo dunque a "blacklistare" a ogni boot:

root@fedora:~# echo "blacklist kvm_intel" >> /etc/modeprobe.d/kvm_intel-blacklist.conf
 

Riavviare il sistema per rendere effettive e permanenti le modifiche.

Virtualbox può essere ora avviato senza errori.

 

Arduino: visualizzare numero decimale su multidisplay LED 7 segmenti

L'obiettivo è quello di visualizzare la tensione letta da un ingresso analogico di Arduino UNO R3, compresa fra 0 e 5V, su un multidisplay LED 7segmenti integrato, a 4 cifre, ad anodo comune:

LINK TINKERCAD: https://www.tinkercad.com/things/eTcNgypAkWG-voltmetro-5v-multidisplay-led-7-segmenti-cacc-

I MULTIDISPLAY LED 7SEGMENTI

Questi display LED hanno in comune gli 8 LED di ogni cifra (7 segmenti per il numero e 1 per il punto decimale) , consentendo così di risparmiare notevolmente i pin di I/O per il collegamento al microcontrollore, mentre sono ovviamente separati i 4 pin comuni (anodo o catodo comune) per consentirne l'accensione o spegnimento; la tensione di comando (0V nel caso del CC o 5V nel caso del CA) ovviamente non sarà fissa, ma erogata da un pin I/O di un microcontrollore, come quello della scheda Arduino UNO R3:

La gestione di questi display LED multipli avviene in mutliplexing a divisione di tempo, "accedendo", quindi, un display per volta per un brevissimo tempo (dai 2 ai 5 ms). Sfruttando l'illusione ottica della persistenza della visione dell'occhio umano, il numero da visualizzare apparirà come se fosse fisso:

Fonte: https://en.wikipedia.org/wiki/Multiplexed_display#/media/File:7segment_multiplexing.gif

I vantaggi sono molteplici: si risparmiano 20 pin I/O del microcontrollore, aggiuntivi rispetto al display singolo (ne occorrono infatti 4 per comandare i 4 pin comuni), si riduce l'assorbimento energetico, essendo un solo display acceso, e non quattro, per ogni lettura.

Occorre, però, un software di gestione leggermente più complesso, che "spacchetti" innanzitutto il numero, intero o decimale, a 4 cifre in 4 singole cifre, predisponendo pure l'accensione dell'eventuale punto decimale o l'eventuale spegnimento degli zeri non significativi.

Esistono librerie molto efficienti a tale scopo (come SevSegment) ma ovviamente è sempre formativo provvedere alla creazione di una propria libreria, anche se meno sofisticata, ma innanzitutto orientata alla semplicità e alla comprensibilità per un target "scolastico".

Le funzioni utente sono tre:

DISPLAY7S

Questa funzione attiva i segmenti (e l'eventuale punto decimale) in funzione del numero da visualizzare.

Essa accetta in ingresso due parametri:

- il numero decimale (da 0 a 9) da visualizzare
- un eventuale flag per l'accensione del punto decimale: 1 (acceso), 0 (spento); 
  invocando la funzione solo con il primo parametro, questo flag è di default 0

Una successiva istruzione di selezione multipla, assegna ai vari segmenti lo stato in funzione del numero che si intende visualizzare. Impostati i vari stati, le istruzione di scrittura digitale provvedono a spegnere o accendere i segmenti secondo gli stati impostati.

DISPLAYEN

Questa funzione attiva un solo display alla volta, per un brevissimo tempo.

Essa accetta in ingresso un solo parametro: l'indice del display che si intende accendere (da 0, il primo, a 3, l'ultimo). Il display verrà dunque acceso per 5ms e successivamente spento

FLOATTO4DGT

Questa funzione provvede a "spacchettare" il numero decimale da visualizzare nelle 4 cifre, provvedendo anche a impostare l'accensione dell'eventuale punto decimale.

Essa accetta tre parametri:

- il numero decimale da visualizzare (che ovviamente dovrà essere compreso fra 0 e 9999)
- l'indirizzo del vettore delle cifre del multidisplay
- l'indirizzo del vettore dei punti decimali del multidisplay

DEFINIZIONI FUNZIONAMENTO DEL DISPLAY

Occorrerà innanzitutto impostare delle costanti simboliche: SON e SOFF, rispettivamente i livelli logici per avere l'accensione o lo spegnimento del segmento (e anche del punto decimale). Se abbiamo, quindi, un CA (anodo comune) SON sarà LOW e SOFF sarà HIGH.

Viceversa i livelli logici per l'accensione e lo spegnimento del display, quelli cioè applicati al pin comune, saranno sempre i negati di quelli che accendono i segmenti:

#define SON LOW // SEGM ON :LOW (CA) / HIGH (CC) #define SOFF HIGH // SEGM OFF :HIGH (CA) / LOW (CC) #define CON !SON #define COFF !SOFF

Infine si definiranno i pin di Arduino collegati ai segmenti (con la lettera maiuscola: A,B, C ecc) e le variabili di stato dei segmenti (con la lettera minuscola a,b,c) oltre ai due vettori delle cifre del display e dei punti decimali.

Di seguito lo sketch completo:

MUX_4_LED_ADC.INO /******************************************************/ /* DEFINIZIONI FUNZIONAMENTO DISPLAY */ /******************************************************/ #define SON LOW // SEGM ON :LOW (CA) / HIGH (CC) #define SOFF HIGH // SEGM OFF :HIGH (CA) / LOW (CC) #define CON !SON // COMUNE ON : NOT SON #define COFF !SOFF // COMUNE OFF: NOT SOFF const int A = 11 ; //pin a cui è collegato il seg. A const int B = 12 ; const int C = 8; const int D = 7 ; const int E = 6 ; const int F = 10 ; const int G = 9; const int DP = 13; const int C1 = 5; // pin comune della cifra 1 (sx) const int C2 = 4; const int C3 = 3; const int C4 = 2; int a,b,c,d,e,f,g; // stato dei singoli segmenti: ON/OFF int display[4]; //vettore cifre display int puntodec[4]; //vettore punti decimali /******************************************************/ /* FUNZIONE SPACCHETTAMENTO FLOAT -> CIFRE */ /******************************************************/ int floatTo4dgt (float n, int dgt[], int dp[]) { int parte_int, parte_dec, n_dec, n_int; float temp; if (n<0 || n>9999) { return -1; // float non valido (max 4 cifre) } else { parte_int = (int) n; temp = n - parte_int; if (n == 0) // visualizzato come 0.000 n_dec = 3; else { if (parte_int<10 || n==0.0) n_dec = 3; //numero cifre dopo la virgola else if (parte_int < 100) n_dec = 2; else if (parte_int < 1000) n_dec = 1; else n_dec = 0; } n_int = 4 - n_dec; // numero cifre prima della virgola for (int i = 0; i < n_dec; i++) { temp=temp*10; // shift a sx di n_dec posiz. } parte_dec = (int) temp; //toglie lo 0 dopo la virgola if (n_dec == 3) { dgt[0] = parte_int; dgt[1] = parte_dec / 100; dgt[2] = (parte_dec % 100) / 10; dgt[3] = (parte_dec % 100) % 10; dp[0] = 1; dp[1] = 0; dp[2] = 0; dp[3] = 0; } if (n_dec == 2) { dgt[0] = parte_int / 10; dgt[1] = parte_int % 10; dgt[2] = parte_dec / 10; dgt[3] = parte_dec % 10; dp[0] = 0; dp[1] = 1; dp[2] = 0; dp[3] = 0; } if (n_dec == 1) { dgt[0] = parte_int / 100; dgt[1] = (parte_int % 100) / 10; dgt[2] = (parte_int % 100) % 10; dgt[3] = parte_dec; dp[0] = 0; dp[1] = 0; dp[2] = 1; dp[3] = 0; } if (n_dec == 0) { dgt[0] = parte_int / 1000; dgt[1] = (parte_int % 1000) / 100; dgt[2] = ((parte_int % 1000) % 100) / 10; dgt[3] = ((parte_int % 1000) % 100) % 10; dp[0] = 0; dp[1] = 0; dp[2] = 0; dp[3] = 0; } return 0; } } /******************************************************/ /* FUNZIONE ATTIVAZIONE SINGOLO DISPLAY */ /******************************************************/ void displayEn(int i) { switch(i) { case 0: digitalWrite(C1, CON); delay(5); digitalWrite(C1, COFF); break; case 1: digitalWrite(C2, CON); delay(5); digitalWrite(C2, COFF); break; case 2: digitalWrite(C3, CON); delay(5); digitalWrite(C3, COFF); break; case 3: digitalWrite(C4, CON); delay(5); digitalWrite(C4, COFF); } } /******************************************************/ /* FUNZIONE CONVERSIONE NUMERO -> COD. 7 SEG */ /******************************************************/ void display7seg(int val, int dp=0) { switch(val) { case 0: a=SON;b=SON;c=SON;d=SON;e=SON;f=SON;g=SOFF; break; case 1: a=SOFF;b=SON;c=SON;d=SOFF;e=SOFF;f=SOFF;g=SOFF; break; case 2: a=SON;b=SON;c=SOFF;d=SON;e=SON;f=SOFF;g=SON; break; case 3: a=SON;b=SON;c=SON;d=SON;e=SOFF;f=SOFF;g=SON; break; case 4: a=SOFF;b=SON;c=SON;d=SOFF;e=SOFF;f=SON;g=SON; break; case 5: a=SON;b=SOFF;c=SON;d=SON;e=SOFF;f=SON;g=SON; break; case 6: a=SON;b=SOFF;c=SON;d=SON;e=SON;f=SON;g=SON; break; case 7: a=SON;b=SON;c=SON;d=SOFF;e=SOFF;f=SOFF;g=SOFF; break; case 8: a=SON;b=SON;c=SON;d=SON;e=SON;f=SON;g=SON; break; case 9: a=SON;b=SON;c=SON;d=SON;e=SOFF;f=SON;g=SON; break; default: // spegne il display a=SOFF;b=SOFF;c=SOFF;d=SOFF;e=SOFF;f=SOFF;g=SOFF; } // accende/spegne ogni seg. secondo il // corrispondente stato assegnato in precedenza digitalWrite(A, a); digitalWrite(B, b); digitalWrite(C, c); digitalWrite(D, d); digitalWrite(E, e); digitalWrite(F, f); digitalWrite(G, g); digitalWrite(DP, dp==1?SON:SOFF); } /******************************************************/ /* CORPO SKETCH */ /******************************************************/ float mvolt; //tensione misurata (in mV) void setup() { pinMode(A, OUTPUT); pinMode(B, OUTPUT); pinMode(C, OUTPUT); pinMode(D, OUTPUT); pinMode(E, OUTPUT); pinMode(F, OUTPUT); pinMode(G, OUTPUT); pinMode(DP, OUTPUT); pinMode(C1,OUTPUT); //pin comune Display cifra 1 pinMode(C2,OUTPUT); pinMode(C3,OUTPUT); pinMode(C4,OUTPUT); } void loop() { // legge la tensione in mV mvolt=map(analogRead(A0),0,1023,0,5000); // Chiama la funzione di "spacchettamento" (passa i Volt) floatTo4dgt (mvolt/1000.0, display, puntodec); // Invia il codice 7segmenti // e attiva in sequenza i 4 display for(int i=0; i<4; i++) { display7seg(display[i], puntodec[i]); displayEn(i); } }