Stadio di condizionamento per AD590, con unico op-amp 5V

L'idea di questo stadio di condizionamento, con op-amp, nasce da due esigenze: la prima, di usare solo l'alimentazione 5V fornita da Arduino e non ricorrere ad un alimentatore duale esterno, anche per lo stadio di condizionamento. La seconda, di volere usare la tensione di riferimento ADC di default da 5V, dello stesso microcontrollore ATmega328.

Problema n.1

Alimentando il sensore AD590 a 5V, con in serie una resistenza da 1kOhm (non è possibile usare a questa tensione una resistenza da 10k),  abbiamo una tensione sulla stessa resistenza di 1mV per ogni grado Kelvin, mentre la risoluzione, teorica, della conversione ADC di Arduino, con Vref=5V, è circa 5mV.

Si rende dunque necessario amplificare questa tensione, per esempio, di un fattore pari a 10 volte, in modo da avere 10mV/K e quindi una risoluzione in temperatura di 0,5K (ovvero 0,5 °C).

Problema n.2

Abbiamo bisogno di un op-amp che possa lavorare ad alimentazione singola, come l'LM358, componente economico, molto reperibile, e dalle buone prestazioni. Bisogna però tenere conto della sua tensione di uscita massima (VSAT+), che è intorno ai 3,5V, quando lo si alimentata a 5V.

Supponendo di volerci limitare alla misura di una temperatura massima di 50°C, abbiamo dunque in corrispondenza una tensione di uscita massima di 3,2V (323K->3,23V).

Dimensionamento dello stadio di condizionamento

Per ottenere un guadagno di tensione di 10 con un unico op-amp, in configurazione non invertente, possiamo usare due resistori da 22k e 68k in serie, per il ramo di retroazione, e un resistore da 10K collegato fra il morsetto invertente e massa; infatti abbiamo:

Risultati più accurati si possono ottenere sostituendo R2A con un'ulteriore resistenza serie formata, per esempio, da un resistore da 18k fisso e un trimmer da 5k, in modo da correggere le tolleranze dei resistori e gli effetti dovuti alle correnti di polarizzazione e alla tensione di offset dell'op-amp.

Schematico

Viene usato il primo dei due op-amp dell'LM238. la parte "A". Il resistore da 1K dallo 0,1% può essere eventualmente sostituito con uno dall'1% oppure da una resistenza serie compresa da un resistore fisso da 820 Ohm e un trimmer da 220 Ohm, che andrà ovviamente regolato in fase di taratura per avere esattamente 1mV/K.  In caso di disturbi, provare a inserire in parallelo alla Rs un condensatore ceramico a disco da 100nF ed, eventualmente, anche in parallelo alla serie R2A+R2B.

RISULTATI LTSPICE:

Arduino UNO R3: "correggere" la tensione di riferimento interna

L'idea di questa procedura mi è nata quando ho dovuto effettuare la correzione software della tensione di riferimento generata dal bandgap entro contenuto nell'ATmega328P, per l'uso con il sensore AD590 senza stadi attivi di condizionamento. 

La tensione di riferimento del bandgap interno è estremamente stabile, ottima per misurare range fra 0 e 1,1V,  ma ha un'elevata tolleranza di produzione (tipicamente fra 1,0 e 1,2V) che può quindi introdurre errori non trascurabili nel calcolo della tensione misurata dall'ADC.

Il suo utilizzo corretto richiede, quindi, innanzitutto una stima del suo effettivo valore (mediante la procedura di seguito descritta) ma anche lo scarto della prima lettura (che sarebbe non accurato, così come è scritto nel datasheet).

DESCRIZIONE DELLA PROCEDURA

Via software si misura una tensione di prova, VR, compresa fra 0,1 e 1V, ai capi di una resistenza di un partitore (come per esempio un potenziometro), usando nel calcolo, come tensione di riferimento il valore nominale della tensione di riferimento bandgap da 1,1V e si memorizza il valore, che chiameremo VR':

ove N è il numero restituito da analogRead()

Contemporaneamente si misura la stessa tensione mediante un multimetro digitale (con portata 2V=)  che chiameremo VR''.  Il rapporto fra questi due valori ci darà il coefficiente di "correzione" della tensione di riferimento che verrà usato nei software in cui si impiegherà la tensione di riferimento da 1,1V:

Tale valore, infine, verrà memorizzato nella memoria EEPROM della scheda e richiamato, all'occorrenza, nel software che impiega la tensione di riferimento da 1,1V.

Evidentemente, tale procedura andrà ripetuta ogni volta si cambia la scheda Arduino UNO R3 ovvero il microcontrollore ATmega328, essendo la tolleranza di fabbricazione del bandgap interno piuttosto variabile.

La procedura è stata testata solo su questo microcontrollore, ma dovrebbe funzionare anche per altri micro ATmegax che hanno un bandgap interno da 1,1V

Altri metodi reperibili in rete, usano un procedimento simile, che raggiunge lo stesso obiettivo finale di ricavare il coefficiente di correzione:  "giocando" con le configurazioni dei registri interni del micro, si misura la tensione del bandgap, usando come tensione di riferimento quella di alimentazione 5V, di default; poi, con una formula inversa di quella di ricostruzione, si calcola la tensione di riferimento che ne scaturisce (più piccola o più grande di 5,0V a seconda se la tensione bandgap effettiva è, rispettivamente, minore o maggiore del valore nominale di 1,1V). Alla fine si confronta questo valore calcolato con il valore misurato "reale" della tensione di alimentazione di Arduino, mediante il DMM, e da qui si ricava lo stesso coefficiente di correzione. 

Però, la misura di una tensione di 5V (sempre rimanendo nell'ambito dei più diffusi DMM 3,5 cifre) impone l'uso di portata minima di 20V= , con un'incertezza assoluta di misura, sulle cifre, sicuramente più alta di quando si usa una portata più piccola, come quella usata nella procedura qui descritta (una misura con P=2V infatti ha 3 cifre decimali, mentre una misura con P=20V ne ha solo 2).

HARDWARE

E' stato usato un trimmer resistivo da 10K, collegato all'ingresso analogico A0, regolandolo per una tensione intorno ai 0,7V:

MISURA TENSIONE VR'' CON DMM:

SOFTWARE

1)  BANDGAP_1V1_CAL.INO

Calcolo del fattore di correzione e salvataggio su EEPROM

/****** Problema:
 * la tensione di riferimento del bandgap interno 1,1V degli ATmegaX, sebbene molto 
 * stabile, ha una tolleranza produttiva non trascurabile. Conoscere l'effettivo valore,
 * dunque, migliora notevolmente il calcolo delle tensioni misurate via software
 * che usano come riferimento questa tensione.
 * 
 ****** Risoluzione:
 * confronta due misure della stessa tensione (compresa fra 0,1 e 1V) applicata a 
 * un ingresso analogico di Arduino, la prima fatta mediante software
 * la seconda mediante un DMM. Dal rapporto fra questi due valori, si determina un 
 * fattore di correzione, che verrà salvato in una locazione della memoria EEPROM; 
 * valore che verrà richiamato, successivamente, nel software  di lettura A/D 
 * che utilizza come VREF il bandgap interno.
 * La procedura va ovviamente ripetuta a ogni cambio di scheda Arduino/microcontrollore.
 * 
 ****** Autore: 
 * Francesco Parisi, 20231217
 */
 
#include <EEPROM.h>

const int pinR=A0;     // pin collegato al partitore
const float VREF =1.1; // tensione nominale b/gap int.
const int EEADD=0;     // ind. EEPROM dove salvare il fatt. correttivo
/*****************************************************/
float VR1;             // tensione partitore misurata via software
float VR2;             // tensione partitore misurata con il DMM
float CAL;             // fattore di correzione calcolato
/*****************************************************/ 

void setup() {
  Serial.begin(9600);
  analogReference(INTERNAL); // Vref interna =1,1V nominale
  VR1=misuraVR();  // misura ripetuta di VR, via software
  Serial.print("\nMisura tensione con bandgap interno: ");
  Serial.print( VR1, 3 );  
  Serial.println(" V");
  Serial.println(F("============================================="));
  Serial.print("Inserire misura tensione DMM in Volt (es. 0.752): ") ;
  while (Serial.available()==0)  
  { } // attende input da monitor seriale
  VR2=Serial.parseFloat();  // trasforma input in float
  Serial.println(VR2,3);
  CAL=VR2/VR1;
  Serial.print("\n\nFattore di correzione calcolato: ");
  Serial.println(CAL, 4);
  EEPROM.put(EEADD, CAL);  // scrive il val. CAL all'ind. EEADD
  Serial.println(F("============================================="));
  Serial.print("Fattore di correzione salvato all'indirizzo EEPROM: ");
  Serial.println(EEADD);
  Serial.println(F("============================================="));
  Serial.println("Programma terminato con successo!"); 
}

void loop() {
}

/* Funzione per la misura ripetuta di VR */
float misuraVR() {
  float somma=0;   // somma delle letture singole di VR
  float vmedio=0;  // media delle letture singole di VR
  float v;         // lettura singola di VR
  int n;           // numero restituito da analogRead()  
  int nlett=5;     // quante letture singole
  for (int i=0; i<nlett+1; i++) {
     n=analogRead(pinR);
     v=VREF*n/1024;
     if (i>0) // prima lettura scartata
       somma=somma+v;
     delay(50);
  }  
  vmedio=somma/nlett;  
  return (vmedio);     // ritorna la media della misure di VR
}

Caricato sulla scheda il software, si attiverà il monitor seriale. Dopo la stampa della misura software, l'utente inserirà nella casella di input dello stesso, il valore di tensione VR letto con il multimetro (0,766 nell'esempio):

Il programma procederà nell'esecuzione, calcolerà il fattore correttivo, lo stamperà e lo salverà nella locazione di memoria EEPROM (valore predefinito 0, che può essere cambiato nella sezione dichiarativa: costante EEADD):

Con il successivo sketch, si andrà a verificare l'effettiva scrittura in EEPROM del fattore di correzione.

2)  BANDGAP_1V1_TEST.INO

Stampa su monitor seriale del fattore correttivo salvato su EEPROM

/*
 * Test lettura valore CAL memorizzato nella EEPROM
 * 
 */

#include <EEPROM.h>

const int EEADD=0;     // ind. EEPROM dove è stato memorizzato il fatt. correttivo
float CAL;             // fattore di correzione memorizzato all'indirizzo EEADD

void setup() {
  Serial.begin(9600);
  Serial.print("Indirizzo EEPROM :");
  Serial.println(EEADD);
  
  EEPROM.get(EEADD, CAL);  // legge locazione EEADD e assegna valore a CAL
  
  Serial.print("CAL = ");
  Serial.println(CAL,4);
}

void loop() {

}

Attivando il monitor seriale avremo questo esempio di output:

USARE IL VALORE MEMORIZZATO NELLO SKETCH UTENTE

Nello sketch utente, ovvero lo sketch che impiegherà questo valore occorrerà innanzitutto inserire all'inizio la direttiva di inclusione del file di intestazione della libreria EEPROM:

#include <EEPROM.h>

A seguire, nella sezione globale, si defineranno la costante int EEADD e la variabile float CAL  e la costante  int VREF=1.1

Nel corpo della setup() si richiamerà la seguente funzione di assegnazione del valore letto dalla EEPROM alla variabile CAL:

EEPROM.get(EEADD, CAL);

Nella formula di ricostruzione della tensione analogica, la costante VREF andrà ovviamente moltiplicata per la costante CAL. Esempio:

 int N = analogRead(A0);

 float v = CAL*VREF*N/1024.0;

Un altro debounce (non bloccante) per Arduino Uno

Nell'impiego di interruttori, commutatori o pulsanti meccanici, si verifica quasi sempre un inconveniente che, nella maggioranza dei casi, costituisce causa di malfunzionamento nei circuiti digitali: l'elemento mobile che realizza il contatto, quando viene spostato da una posizione all'altra rimbalza (bouncing) diverse volte prima di stabilizzarsi al valore impostato, sia nella fase di pressione che in quella di rilascio.

Questi continui rimbalzi, che avvengono in un tempo brevissimo (generalmente fra 0,1 e 5ms), vengono percepiti dal software in esecuzione  come ripetute pressioni del pulsante e quindi erroneamente conteggiati. Il problema viene aggirato impiegando soluzioni cosiddette di anti-rimbalzo (debouncing) che possono essere circuitali o software. Una delle soluzioni software più semplici è quella di far eseguire un'istruzione di attesa, di un tempo pari, o leggermente superiore, a quello di rimbalzo, in modo che il programma ignori sicuramente queste innumerevoli commutazioni. Al termine di questo periodo, per sicurezza, si torna a leggere lo stato del pulsante: se è corrispondente a quello attivo (es. livello alto) il pulsante è stato dunque "de-rimbalzato" (debounced) e quindi può essere eseguito il codice previsto all'occorrenza della pressione del bottone.

HARDWARE                                  

Il pulsante N.A. è collegato fra il pin di ingresso (2) e la massa; il resistore di pull-up è quello interno dell'ATmegax8: quindi la pressione del pulsante comporta, a regime, la lettura sul pin 2 di un livello logico LOW, mentre il rilascio comporta, a regime,  la lettura di un livello logico HIGH. Sul pin 9 è collegato un LED (attraverso una resistenza da 220..330 Ohm), che, alla pressione del pulsante, commuterà il suo stato da acceso a spento e viceversa. 

SOFTWARE                                 

Lo sketch è imperniato sull'intercettazione della pressione del pulsante (ovvero del rilascio) attraverso un'istruzione di selezione semplice if, che va a "testare" lo stato corrente del pulsante (memorizzato nella variabile statoP1)  e quello della precedente esecuzione del loop (memorizzato nella variabile statoP1prec).  Se i due stati sono diversi vuol dire che c'è stata una variazione (da HIGH a LOW: pressione oppure da LOW a HIGH: rilascio), ma per essere sicuri che sia la prima variazione - ovvero la pressione o il rilascio - e quindi non una successiva variazione dovuta ai rimbalzi, occorre testare una terza variabile di flag che assume valore 0 solo quando non si è ancora verificata la prima variazione.

Se dunque si verifica la condizione logica (stato attuale pulsante NOT EQUAL a quello precedente AND flag=0) dalla pressione (ovvero dal rilascio) , attraverso un marker temporale (variabile t1) viene "segnato" l'istante conteggiato dalla funzione millis() e ovviamente settata a 1 la variabile flag, essendosi verificato l'evento di prima variazione.

Successivamente , a ogni loop, si andrà a leggere il valore  millis() e a confrontarlo con t1, se la differenza è MAGGIORE O UGUALE a 5ms (tempo tipico di attesa per l'esaurirsi del debounce; potrebbe essere necessario aumentarlo, se la qualità dei pulsanti è bassa) si andrà allora a testare lo stato del pulsante: se LOW, allora è una condizione di pressione e quindi si va ad eseguire il codice previsto all'occorrenza della pressione del pulsante.

Diversamente, verrà eseguito il codice restante dello sketch, cioè quello non relativo all'evento della pressione del pulsante, senza alcuna pausa. Infatti l'uso di millis()rende la gestione "non bloccante" dell'intero software, a differenza delle istruzioni di delay(): infatti il "costo" temporale delle istruzioni di check del tempo trascorso sono assolutamente trascurabili rispetto alle decine di millisecondi che avrebbe richiesto una delay.

Ad ogni loop, ovviamente, occorrerà aggiornare lo stato precedente del pulsante per il successivo loop, che ovviamente sarà uguale a quello attuale. Generalmente questa istruzione viene messa come ultima nel corpo della loop().

MIO_DEBOUNCE.INO

/*
 *  Debounce con millis() sulla pressione e sul rilascio
 *  del pulsante.
 *
*/
const int P1=2;   // pulsante 
const int L1=9;   // LED

int statoP1=LOW;       // stato P1 (premuto LOW / rilasciato HIGH)
int statoP1prec=LOW;   // stato precedente P1
int statoL1=LOW;       // stato LED (spento LOW / acceso HIGH)
int flag=0;            // 1: pressione o rilascio
int T=5;               // tempo attesa bouncing (5ms)
unsigned long t1;      // marker temporale di millis()

void setup() {
  pinMode(P1, INPUT_PULLUP);  // attiva la R pull-up interna
  pinMode(L1, OUTPUT);
  digitalWrite(L1, statoL1);
}

void loop() {

  statoP1 = digitalRead(P1);

  // rilevata una pressione o un rilascio
  if (statoP1 != statoP1prec && !flag)
  {
     flag=1;        // flag di avvenuta pressione/rilascio
     t1=millis();   // marca inizio conteggio tempo
  }

  // se si è esaurito il rimbalzo
  if ( millis()-t1 >= T && flag) 
  {
     flag=0;    // azzera flag  (per successive pressioni/rilasci)
      
     // se è una pressione
     if (statoP1==LOW)
     {
        // istruzioni da eseguire alla pressione di P1: 
        statoL1=!statoL1;
        digitalWrite(L1, statoL1);
     }
  }
  
  // istruzioni da eseguire al di fuori della pressione di P1:


  
  statoP1prec = statoP1;
}

Installare Packet Tracer 8.2 su Fedora, OpenSUSE, Arch, Manjaro 64-bit

Aggiornamento 08/08/2022: viene attualmente installata la nuova versione 8.2

Come avviene già dalla versione 7.3.0, la Cisco ha deciso di distribuire il suo software Linux solo nel formato Debian (.deb). 

Quindi, nessun problema per chi usa Debian, Ubuntu e le tante distribuzioni derivate, ma per chi, invece, preferisce altre distribuzioni che non usano il formato Debian (es. Fedora, OpenSUSE, Arch, Manjaro ecc) occorre provvedere manualmente a installare i file di installazione e fare delle modifiche di sistema.

Fortunatamente ho trovato in rete uno script di installazione (curato dall'ottimo sviluppatore brasiliano Marcelo Baptista) che automatizza l'intera procedura. Può essere usato anche su Arch/Manjaro, sempre su sistemi operativi a 64-bit e indipendentemente dall'ambiente desktop (Gnome, KDE Plasma, XFCE, Cinnamon ecc).

Va da sé che, volendo, questo script di installazione può essere eseguito anche su sistemi basati su pacchetti .deb (Debian, Ubuntu ecc...)

Vediamo i passi da seguire:

Step #0: avere un account Cisco Netacad

Il software viene eseguito inserendo le proprie credenziali dell'account Cisco Netacad. Nel caso si fosse sprovvisti di tale account, occorrerrà crearne uno (gratuitamente) seguendo la procedura accessibile al seguente link: https://id.cisco.com/signin/register

Step #1 : accettare i termini di licenza

La lettura e l'accettazione dei termini di licenza della Cisco è una procedura prodepeutica all'installazione e all'utilizzo del software.

https://www.netacad.com/portal/resources/packet-tracer

Occorrerà inserire la propria login Netacad, andare nel paragrafo "Download" e cliccare sui link  CISCO END USER LICENSE AGREEMENT (“EULA”) e THE SUPPLEMENTAL END USER LICENSE AGREEMENT

Se si accettano i suddetti termini, passare allo step #2

Step #2: eseguire lo script di installazione

Da terminale non privilegiato:

curl -s https://raw.githubusercontent.com/marcelobaptista/packettracer/master/install_pt.sh | sudo bash

Attendere il termine dello scaricamento e dell'esecuzione dello script. I tempi di download potrebbero essere abbastanza lunghi.

Step #3: lanciare il programma

Il programma può essere lanciato digitando "packet tracer" nella casella di ricerca del proprio DE oppure lanciando lo script "packettracer" in un terminale utente.  In KDE Plasma, inoltre, viene creato un collegamento sotto il menù di avvio "Oggetti smarriti", che può essere ovviamente inviato al desktop per un avvio rapido.

Cisco CLI IOS: i comandi utili nell'attività laboratoriale

 

Di seguito verranno descritti alcuni comandi che rendono più produttività l'esperienza di amministrazione di una macchina Cisco, soprattutto nel contesto laboratoriale. Infatti, a differenza del contesto di produzione, nell'attività di laboratorio si tende a privilegiare sicuramente la semplificazione operativa anche se a scapito della sicurezza.

1. Non impostare password

Quando si usa la CLI in ambito laboratoriale (sia reale ma anche con Packet tracer) gli apparati vengono usati da più studenti; una password non conosciuta, impostata da un altro studente, comporta il reset fisico dell'apparato con evidenti ricadute sull'esperienza di laboratorio. Pertanto è buona norma non impostare alcuna password in nessuna modalità utente o privilegiata.

2. Disabilitare il DNS lookup

E' il primo comando EXEC sicuramente da immettere (subito dopo quello dell'assegnazione dell'hostname). Forse è quello più indispensabile. 

Quando si inserisce un comando errato, in alcune circostanze, il sistema prova a interrogare il server DNS impostato di default, nel tentativo di risolvere il nome (ipotizza che la stringa immessa sia il nome di un host al quale ci si vuole collegare). Esempio:

Switch# conifg
Translating "conifg"...domain server (255.255.255.255)

Dopo qualche minuto di blocco della console (non è possibile interrompere in nessun modo da tastiera questa interrogazione DNS...), il sistema risponde con il seguente messaggio, "rilasciando" così l'uso della console:

% Unknown command or computer name, or unable to find computer address
Switch# config terminal

Il problema viene aggirato disabilitando il lookup DNS con il seguente comando EXEC:

Switch(config)# no ip domain-lookup

3. Mitigare i disturbi del syslogging su console 

Il demone syslog del sistema operativo Cisco IOS logga sulla console, in qualsiasi momento, messaggi di sistema, per esempio attivazione/disattivazione di interfaccia, messaggi di protocolli ecc. Se in quel momento si sta, per esempio, usando la console per inserire un comando questo verrà "spezzato" e nel mezzo inserito il messaggio di syslog. Esempio:

R0(config-if)#ip address 192.168.1.10 255.2
%LINEPROTO-5-UPDOWN: Line protocol on Interface GigabitEthernet0/0, changed state to down
55.255.0

La prima soluzione potrebbe essere quella di disabilitare totalmente il logging di syslog attraverso i seguenti comandi:

Switch(config)# line console 0
Switch(config-line)# no logging console

Questa soluzione potrebbe però impedire di leggere messaggi importanti di sistema. Esistono diverse soluzioni alternative che risolvono o mitigano il problema (si rimanda a questo link). 

Il metodo consigliato sui testi Cisco è quello di mantenere abilitato il logging su console, ma in modo "sincrono". In questo modo il comando che si stava inserendo verrà ristampato esattamente dopo la stampa su console dell'evento syslog:

R0(config)#ip address 192.168.1.10 255.2
%LINEPROTO-5-UPDOWN: Line protocol on Interface GigabitEthernet0/0, changed state to up

R0(config)#ip address 192.168.1.10 255.2

ll logging sincrono viene abilitato con i seguenti comandi:

Switch(config)# line console 0
Switch(config-line)# logging synchronous

Se si prevede di usare login SSH/Telnet (VTY terminal) , ripetere i comandi:

Switch(config)# line vty 0 15
Switch(config-line)# logging synchronous

4. Disabilitare il timeout di sessione

Di default dopo 5 minuti di inattività (sia console che SSH/Telnet), il sistema disconnette l'accesso. E' evidente che in un ambiente esercitativo, non di produzione, sarebbe preferibile non disconnettere mai che viene codificato con la coppia 0 ore, 0 min:

Switch(config)# line console 0
Switch(config-line)# exec-timeout 0 0

Se si prevede di usare login SSH/Telnet (Virtual Teletype) , ripetere i comandi:

Switch(config)# line vty 0 15
Switch(config-line)# exec-timeout 0 0

Ovviamente  per salvare sulla memoria di avvio le modifiche fatte  e quindi non perderle con un reboot della macchina,  occorrerà lanciare il comando:

Switch# copy run start

________________

Sitografia/Bibliografia

• Solved: logging synchronous - Cisco Community
• WENDELL ODOM, CCENT/CCNA ICND1 100-105, CISCOPRESS

Cisco Catalyst 2960: aggiornamento firmware mediante CLI

Ho comprato mesi fa su eBay uno Switch Cisco Catalyst 2960 ricondizionato, insieme ad altri apparati della stessa casa a un prezzo davvero conveniente, con lo scopo di allestirmi un classico CCNA lab per fare pratica con i comandi CLI di CISCO IOS.

Lo switch 2960 in mio possesso è la versione 24-TT-L non più in produzione e con supporto cessato nel 2019. L'apparato oltre alle 24 porte rame 10/100 ha altre 2 porte rame 10/100/1000 (tutte non PoE) che possono essere usate per i collegamenti di uplink. 

La guida che andrò a descrivere si riferisce all'aggiornamento del firmware dell'apparato usando un computer con sistema operativo Windows 11 (o 7/8/10) versione 64-bit

1. Gli strumenti software/hardware necessari

Oltre ovviamente a un computer con Windows 7/8/10/11 64-bit, dotato di porta RS232 o USB e porta Ethernet (con relativo cavo di rete RJ45/RJ45) occorrono:

Cavo Rollover

Occorrerà un cavo di programmazione rollover DB-9/RJ45 (se avete un computer ancora con la porta RS232 DB9). Se avete, invece, un computer con la sola porta USB la scelta è ovviamente la versione USB/RJ-45 . Se avete già il cavo DB9/RJ45 ma vi serve USB potete ovviamente usare qualsiasi cavo adattatore DB-9/USB

Il cavo andrà collegato, per l'estremità RJ45 nel retro (porta console) dell'apparato, l'estremità USB/DB9 ovviamente al computer:

   

Software emulazione terminale 

Come software di emulazione terminale, per collegarci tramite la porta COM (reale o virtuale USB), il software più usato è senz'altro l'ottimo freeware Putty, che andrà scaricato all'URL:

https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html

Applicazione server TFTP

Il file binario dell'aggiornamento una volta scaricato sul computer, verrà, a sua volta, scaricato dallo switch mediante una sessione TFTP: quindi lo switch agirà da client e il computer agirà da server. Occorre quindi che sul PC sia in esecuzione un servizio TFTP. A tale scopo i documenti Cisco consigliano un'applicazione server TFTP free, per Windows, molto semplice da configurare e usare; è scaricabile al seguente indirizzo:

https://bitbucket.org/phjounin/tftpd64/downloads/Tftpd64-4.64-setup.exe

Vedremo più avanti come usarlo e configurarlo.

2. Che versione di firmware ho attualmente sulla macchina?

Per interagire con l'apparato abbiamo bisogno dell'emulatore terminale. Lanciamo PuTTY e lo configuriamo per la connessione seriale con lo switch:

• Serial line
  La porta COM della seriale fisica (RS232) o virtuale (USB), es. COM3. Se non si conosce il numero è possibile individuarla da "Gestione dispositivi" > Porte seriali.
• Speed
  Va bene anche 9600bps, ma diversi documenti Cisco consigliano 115200bps
• Connection type
  Serial

Conviene salvare il profilo di connessione con un'etichetta "CISCO" in modo da richiamarlo velocemente per le future sessioni

D'ora in poi si supporà che lo switch si trovi configurato ai valori iniziali di fabbrica:

1) tutte le porte fanno parte della VLAN di default (VLAN ID=1)

2) la VLAN di management è la VLAN ID=1 (default management VLAN)

3) non sono state impostate password utente e/o modalità privilegiata

Aperto il terminale, battere INVIO, e al prompt lanciare il seguente comando EXEC:

Switch>show version

scorrendo il terminale, al termine, verrà visualizzata la versione del firmware attualmente in esecuzione:

3. Scarichiamo sul computer il file dell'aggiormanento

La pagina principale per il download del software Cisco è la seguente:

https://software.cisco.com/download/home

N.B. Occorre essere forniti di una login Cisco (la registrazione è libera).

Nel form di selezione del prodotto, digiteremo il modello del nostro apparato (nel nostro caso 2960-24TT-L) , quindi apparirà il link (in azzurro) corrispondente:

Successivamente selezioneremo il tipo di software (IOS):

A questo punto si apre la pagina del download del file di aggiornamento

Come si può notare l'ultima release consigliata è la 12.2.55-SE12(MD) a fronte della versione 12.2.55-SE4 attualmente installata.

Quindi procediamo al download cliccando sull'ultima icona sulla destra, salvando nella cartella "Scaricati" dell'utente corrente di Windows.

Nel nostro caso il nome del file è:    c2960-lanbasek9-mz.122-55.SE12.bin

4. Assegniamo allo switch un indirizzo IP

Lo switch si collega al computer anche mediante un cavo ethernet, che andrà collegato fra la porta ethernet del computer e una qualsiasi porta dello switch. 

Il collegamento di rete, come detto in precedenza, serve affinché lo switch possa "scaricare" dal computer il file di aggiornamento, salvato in una cartella dello stesso computer, mediante una connessione client (lo switch) / server (il computer) usando il protocollo TFTP.

Quindi lo switch dovrà avere una configurazione IP (indirizzo IP host, subnet-mask) in accordo con quella della configurazione IP del computer, dovendo le due macchine, ovviamente, far parte della stessa rete per poter comunicare.

Lo switch 2960 è uno switch layer-2, quindi non può avere porte fisiche associate a indirizzi IP. In questo caso, l'interfaccia IP sarà di tipo virtuale (SVI: Switch Virtual Interface) e sarà associata alla VLAN 1  che corrisponde alla default management VLAN. 

Per conoscere la configurazione IP dell'interfaccia ethernet del computer, dal prompt comandi lanciare il seguente comando:

>ipconfig

Scheda Ethernet Ethernet:

   Indirizzo IPv4. . . . . . . . . . . . : 192.168.1.5
   Subnet mask . . . . . . . . . . . . . : 255.255.255.0
   Gateway predefinito . . . . . . . . . : 192.168.1.1

Quindi l'indirizzo IP server (cioè quello dell'interfaccia ethernet del computer) è 192.168.1.5

Assegniamo allo switch un indirizzo IP host compatibile con la subnet mask, e non assegnato già ad altro end device, per esempio l'indirizzo IP 192.168.1.100.

Dal terminale di Putty:

Switch> en
Switch# conf t
Switch(config)# int vlan 1
Switch(config-if)# ip address 192.168.1.100  255.255.255.0
Switch(config-if)# no shut
Switch(config-if)# exit
Switch(config)# ip default-gateway 192.168.1.1

Lo schema definitivo dei collegamenti è quindi il seguente:

N.B. Si ricorda di attendere, ovviamente, che il LED della porta dello switch diventi verde prima di collegarsi all'apparato

5. Avviamo e configuriamo il server TFTP

Una volta lanciata l'applicazione TFTP server, occorrerà prestare attenzione a impostare le seguenti proprietà:

• Current Directory 
  La cartella dove è stata salvata l'immagine scaricata al precedente punto. Nel nostro caso era la cartella "Scaricati", quindi sarà la s/directory "Downloads" della home dell'utente corrente 
  
  
• Server Interfaces
  Occorre selezionare l'indirizzo IP dell'interfaccia ethernet (cablata), che nel nostro caso è 192.168.1.5 

6. Aggiorniamo il firmware

Da modalità privilegiata (non configurazione), lanceremo il seguente comando:

Switch> en
Switch# copy tftp://192.168.1.5/c2960-lanbasek9-mz.122-55.SE12.bin flash:

Terminata la fase di copia (battere INVIO alle domande), lanciare i comandi:

Switch# show flash:

Directory of flash:/

    2  -rwx     9827106   Mar 1 1993 03:25:11 +00:00  c2960-lanbasek9-mz.122-55.SE12.bin

  617  -rwx         108   Mar 1 1993 00:15:20 +00:00  info

    3  -rwx        1048   Mar 1 1993 00:00:59 +00:00  multiple-fs

  622  drwx         192   Jun 6 2012 10:16:14 +00:00  c2960-lanbasek9-mz.122-55.SE4

Se è andato tutto correttamente, dovrebbe essere visualizzate entrambe le immagini, sia la nuova (SE12) che la precedente (SE4).

Facciamo il boot con la nuova immagine, salviamo la nuova configurazione dalla NVRAM alla memoria flash di avvio e riavviamo il sisteam:

Switch# conf t
Switch(config)# boot system flash:c2960-lanbasek9-mz122-55.SE12.bin
Switch(config)# end
Switch# copy run start
Switch# reload

Riavviato il sistema, verifichiamo con il comando:

Switch> show version

che sia stata caricata la nuova versione del firmwre

7. Conclusioni

La procedura mediante CLI appare la più flessibile e ovviamente portabile su ogni sistema operativo usato per l'aggiornamento. Indipendentemente dal proprio os, occorrerà ovviamente avere un'applicazione TFTP server in esecuzione sul proprio sistema operativo e un'applicazione di emulazione terminale per potersi interfacciare con l'apparato di rete per l'invio dei comandi CLI (comandi EXEC). Applicazioni entrambe reperibili, gratuitamente, per qualunque sistema operativo.

________________

Sitografia: https://www.cisco.com/c/en/us/support/docs/smb/switches/cisco-550x-series-stackable-managed-switches/smb5566-upgrade-firmware-on-a-switch-through-the-command-line-interf.html

Fedora 35: installare Unifi controller

 

 

Per installare il controller Unifi, occorrerà in buona sostanza:

1. installare il binario da RPM Fusion (pre-requisito: abilitare RPM Fusion)

2. configurare/riavviare il firewall

3. configurare/avviare il servizio UniFI

3. installare MongoDB server, che non è incluso nei repo ufficiali

1. installare il binario da RPM fusion

 

pre-requisito: abilitare RPM Fusion

sudo dnf install unifi

2. configurazione firewall

sudo firewall-cmd --permanent --add-service=unifi

sudo firewall-cmd --permanent --add-service=unifi-cloud

 

Riavvio del servizio firewall:

 

sudo firewall-cmd --reload

 

3. configurazione servizio unifi

sudo systemctl enable unifi.service
sudo systemctl start unifi.service

 

4. installazione mongoDB server

sudo nano /etc/yum.repos.d/mongodb.repo 

e aggiungere il seguente contenuto:

[Mongodb]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/8/mongodb-org/4.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc

Salvare il file con Ctrl-O

Installare il pacchetto:

sudo dnf install mongodb-org mongodb-org-server

Quindi abilitarlo e avviarlo:

sudo systemctl enable mongod.service 

sudo systemctl start mongod.service 

5. Avviare UniFi

Da un browser sarà ora possibile avviare UniFI, aprendo l'URL

https://localhost:8443

Buon lavoro!

 

 

 

 

------------------------

 

Sitografia:

[1] https://rpmfusion.org/Howto/Unifi#How_to_setup_the_Ubiquiti_Unifi_Controller_on_Fedora_.26_EL 

[2] https://tecadmin.net/install-mongodb-on-fedora/