Blog di Federicopanigari

Stabilire una connessione tra due computer all’interno della stessa rete locale (LAN) e tra computer di reti diverse coinvolge diversi passaggi. Vediamo una panoramica generale di come avvengono questi processi utilizzando i protocolli TCP/IP, che sono ampiamente utilizzati nelle reti moderne.

Connessione tra PC nella stessa rete (LAN):

1. Individuazione degli indirizzi IP:
   • Ogni computer nella rete deve avere un indirizzo IP univoco. L’assegnazione può avvenire staticamente (manualmente) o dinamicamente (tramite DHCP)

1. Creazione del frame Ethernet:
   • I dati sono suddivisi in “frames” a livello di collegamento (livello 2 del modello OSI). Il frame Ethernet contiene l’indirizzo MAC del mittente e del destinatario.
2. Trasmissione del frame sulla LAN:
   • Il frame viene inviato tramite il mezzo di trasmissione della LAN (ad esempio, cavi Ethernet) e raggiunge il destinatario.
3. Ricezione del frame da parte del destinatario:
   • Il destinatario controlla se il frame è destinato a lui tramite l’indirizzo MAC. Se sì, il frame viene estratto e i dati sono consegnati al livello superiore (livello 3).

Connessione tra PC di reti differenti:

1. Routing:
   • Se i computer sono in reti diverse, è necessario un router per instradare i dati tra di esse. Il router utilizza la tabella di routing per determinare il percorso migliore.
2. Creazione del pacchetto IP:
   • I dati vengono suddivisi in “pacchetti” a livello di rete (livello 3 del modello OSI). Ogni pacchetto contiene l’indirizzo IP del mittente e del destinatario.
3. Indirizzamento MAC tramite ARP (Address Resolution Protocol):
   • Per inviare il pacchetto IP su una rete Ethernet, è necessario conoscere l’indirizzo MAC del router. L’ARP traduce l’indirizzo IP del router nel suo indirizzo MAC.
4. Creazione del frame Ethernet e trasmissione:
   • Il frame Ethernet contiene l’indirizzo MAC del mittente, del router e del destinatario. Il frame viene quindi trasmesso sulla LAN del mittente.
5. Routing del pacchetto al destinatario:
   • Il router riceve il frame, estrae il pacchetto IP, determina la migliore route, crea un nuovo frame Ethernet e inoltra il pacchetto alla LAN del destinatario.
6. Ricezione del pacchetto da parte del destinatario:
   • Il destinatario riceve il frame Ethernet, estrae il pacchetto IP e i dati sono consegnati al livello superiore.

Nel video, l’oratore spiega il concetto di machine learning, un ramo dell’intelligenza artificiale che permette ai computer di apprendere e migliorare le loro prestazioni attraverso l’analisi dei dati:

Apprendimento supervisionato:

Una delle principali tecniche di machine learning menzionate è l’apprendimento supervisionato, dove il computer impara da un set di dati di input etichettati per fare previsioni o prendere decisioni.

Algoritmi e modelli:

Nella presentazione vengono discussi vari algoritmi e modelli utilizzati nel machine learning, come le reti neurali artificiali, che imitano il funzionamento del cervello umano.

Big data:

Un altro punto sottolineato è l’importanza dei big data nel machine learning. Grandi quantità di dati vengono utilizzate per addestrare i modelli e migliorare le previsioni e le decisioni.

Set di addestramento e set di test:

Durante il processo di apprendimento, i dati vengono suddivisi in set di addestramento e set di test. Il primo viene utilizzato per allenare il modello, mentre il secondo viene utilizzato per valutare le sue prestazioni.

Classificazione e regressione:

Due tipi comuni di problemi affrontati nel machine learning sono la classificazione e la regressione. La classificazione prevede l’assegnazione di un’etichetta a un’istanza di dati, mentre la regressione prevede un valore numerico.

Applicazioni del machine learning:

Il video mette in evidenza diverse applicazioni del machine learning in vari settori, come la medicina, la finanza, la pubblicità mirata e i veicoli autonomi.

Etica nel machine learning:

Un punto cruciale menzionato è l’etica nel machine learning. È importante garantire che i modelli siano imparziali e non discriminatori, evitando di amplificare gli stereotipi o violare la privacy delle persone.

Futuro del machine learning:

Secondo l’oratore, il machine learning continuerà a evolversi e ad avere un impatto significativo sulla società. Nuove tecnologie e approcci consentiranno di affrontare sfide più complesse e migliorare le prestazioni dei modelli.

Opportunità e sfide:

Infine, il video sottolinea le opportunità e le sfide legate al machine learning. Mentre offre nuove prospettive e soluzioni innovative, richiede anche competenze specializzate e la gestione responsabile dei dati.

Una topologia di rete rappresenta  le relazioni di connettività, fisica o logica, tra gli elementi costituenti la rete stessa .Ci sono diverse topologie di rete tra cui scegliere, ad anello, a bus, a stella e a maglia ecc. La scelta della topologia dipende dalle esigenze dell’organizzazione e dalla disponibilità di risorse di rete. Oggi vi parlerò delle topologie a stella, ad anello, a maglia (totale) e ad albero.

Topologie a stella

La topologia a stella è caratterizzata che tutti i dispositivi di una rete sono collegati a un hub centrale. In questo tipo di topologia, ogni dispositivo si connette all’hub attraverso un cavo di rete separato. L’hub gestisce la trasmissione dei dati tra i dispositivi.

vantaggi e svantaggi

Come vantaggi ha una migliore gestione del traffico di rete, ha maggior sicurezza e semplifica la risoluzione dei problemi di rete.Come svantaggi ha una connettività limitata e ha un costo limitato

Topologie a anello

La topologia ad anello è caratterizzata che da ogni dispositivo viene connesso ad un anello unidirezionale. In questa configurazione, i dati sono trasmessi da un nodo all’altro in un unico senso, seguendo l’anello fino a raggiungere la destinazione.

vantaggi e svantaggi

Come vantaggi può supportare molte connessioni senza perdere la qualità del segnale e ha una manutenzione di rete facile. Come svantaggi ha una configurazione costosa e è vulnerabile alla rottura del cavo.

Topologie a maglia (totale)

La topologia a maglia totale è una tipologia di rete informatica in cui ogni dispositivo è connesso direttamente a tutti gli altri dispositivi della rete, non c’è un nodo centrale e la connessione è diretta tra tutti i nodi.

vantaggi e svantaggi

Vantaggi: ha una alta velocità, una buona affidabilità ed è scalabile. Svantaggi: Ha un costo elevato, è molto complesso ed ha problemi di sicurezza

Topologie a albero

La topologia ad albero è una struttura di rete che presenta una gerarchia a forma di albero, dove un nodo radice è il centro di controllo per tutti gli altri nodi. I nodi sono collegati tramite connessioni punto-punto, che partono dal nodo padre fino ai nodi figli.

vantaggi e svantaggi

Vantaggi: Ha una gestione molto facile, è scalabile e affidabile. Svantaggi: ha un costo elevato, è molto complesso e in caso di guasto del nodo radice, l’intero sistema può essere compromesso.

La topologia più usata tra queste è quella a stella

Le reti WAN, MAN e LAN sono tre tipologie di reti informatiche e hanno differenti estensioni, dimensioni e velocità.

LAN

La LAN (Local Area Network) è la rete più piccola delle tre ed è utilizzata per collegare dispositivi all’interno di un’area geografica limitata, come un ufficio o un edificio. Le LAN sono solitamente gestite da un singolo amministratore di sistema e possono fornire una velocità di trasferimento dati molto elevata.

MAN

La MAN (Metropolitan Area Network) è una rete più grande che copre una zona geografica più ampia, come una città, essa è gestita da una o più organizzazioni e collega diverse LAN tra loro. La velocità di trasferimento dei dati in una MAN è inferiore rispetto a quella di una LAN.

WAN

La WAN (Wide Area Network) è la rete più estesa e collega diverse reti MAN e LAN tra loro che si trovano in aree geografiche molto distanti tra loro. La WAN può coprire una regione, un paese o addirittura tutto il mondo. Le velocità di trasferimento dei dati in una WAN possono essere molto variabili e dipendono dalla infrastruttura di telecomunicazioni utilizzata.

le reti LAN, MAN e WAN servono per la connessione di dispositivi e la trasmissione di dati tra aree geografiche diverse. La scelta di rete da utilizzare dipende dalle esigenze dell’organizzazione e dal livello di interconnessione richiesto.

Dato un arduino con 1 sensore di luce e 1 termometro
fare in modo che questo scriva ogni secondo (scrivere il tempo) la temperatura e la sua luminosità

scrivere i dati su un file csv dove ci sono le seguenti informazioni

tempo , temperatura , luminosità

#include <Adafruit_BMP280.h>

Adafruit_BMP280 bmp; 
float QNH = 1024.67; //Change the "1022.67" to your current sea level barometric pressure (https://www.wunderground.com)
const int BMP_address = 0x76;
float pressure;   
float temperature;  
float altimeter; 
//char charRead;
char dataStr[100] = "";
char buffer[7];

void setup(){
  Serial.begin(9600);
  bmp.begin(BMP_address); 
}

void loop(void){
 dataStr[0] = 0; //clean out string
 pressure = bmp.readPressure()/100;  //and convert Pa to hPa
 temperature = bmp.readTemperature();
 altimeter = bmp.readAltitude (QNH); //QNH is local sea level pressure
 //----------------------- using c-type ---------------------------
 //convert floats to string and assemble c-type char string for writing:
 ltoa( millis(),buffer,10); //convert long to charStr
 strcat(dataStr, buffer); //add it to the end
 strcat( dataStr, ", "); //append the delimiter
 
 //dtostrf(floatVal, minimum width, precision, character array);
 dtostrf(pressure, 5, 1, buffer);  //5 is minimum width, 1 is precision; float value is copied onto buff
 strcat( dataStr, buffer); //append the converted float
 strcat( dataStr, ", "); //append the delimiter

 dtostrf(temperature, 5, 1, buffer);  //5 is minimum width, 1 is precision; float value is copied onto buff
 strcat( dataStr, buffer); //append the converted float
 strcat( dataStr, ", "); //append the delimiter

 dtostrf(altimeter, 5, 1, buffer);  //5 is minimum width, 1 is precision; float value is copied onto buff
 strcat( dataStr, buffer); //append the converted float
 strcat( dataStr, 0); //terminate correctly 
 Serial.println(dataStr);
 delay(1000);  
} 

L’intelligenza artificiale (IA) è una delle tecnologie più interessanti e promettenti del nostro tempo. In poche parole, l’IA è la capacità di un computer di imitare l’intelligenza umana. Questo può includere l’apprendimento, il ragionamento, la risoluzione dei problemi e la comprensione del linguaggio naturale.

L’IA ha già cambiato il mondo in molti modi. Ad esempio, i motori di ricerca come Google utilizzano l’IA per comprendere meglio le query degli utenti e fornire risultati migliori. Gli assistenti vocali come Siri di Apple e Alexa di Amazon utilizzano l’IA per comprendere il linguaggio naturale e rispondere alle domande degli utenti.

Ma l’IA può fare molto di più. Ad esempio, gli scienziati stanno utilizzando l’IA per analizzare grandi quantità di dati medici e identificare potenziali cure per malattie come il cancro. Le auto autonome utilizzano l’IA per navigare sulle strade e prendere decisioni sulla guida in tempo reale. E in futuro, l’IA potrebbe essere utilizzata per creare robot intelligenti che possono aiutare le persone anziane o disabili a vivere autonomamente.

Ma ci sono anche alcune preoccupazioni riguardo all’IA. Alcune persone temono che l’IA possa diventare così avanzata da diventare una minaccia per l’umanità. Ad esempio, se gli algoritmi di un’arma autonoma sbagliassero il bersaglio, potrebbe causare danni irreparabili.

Per questo motivo, è importante che gli sviluppatori di IA si concentrino sulla sicurezza e sulla responsabilità. Dobbiamo assicurarci che l’IA sia sviluppata in modo responsabile e che sia utilizzata per migliorare la vita delle persone, anziché minacciarla. Con la giusta attenzione e responsabilità, l’IA potrebbe essere una delle tecnologie più importanti e positive del nostro tempo.

DOPOTUTTO,QUESTO TESTO é STATO FATTO DA UN INTELLIGENZA ARTIFICIALE.

Creare un sistema che risponde ciao appena entra in funzione (sul display)

possa ricevere 5 input diversi numerici e possa incrementare sul display gli output
derivanti dalle funzioni richiamate

tasto 1 accendi una serie di led  
tasto 2  casualmente decidi quale funzione fare
tasto 3 prendi la temperatura
tasto 4 sensore di luce
tasto 5 sensore di distanza

ogni misura del sensore deve essere accompagnata da una frase casuale diversa generata
se riesci in maniera casuale da un set di parole inserite in un array nel formato soggetto verbo complemento oggetto
3 array diversi con parole da comporre casualmente e stampare in console ed lcd 
Più gli array di parole saranno riempiti maggiori le frasi casuali da generare saranno varie.

componenti necessari
predisporre lcd

IMMAGINE

codice

#include <LiquidCrystal.h> // libreria per il display LCD
#include <Adafruit_DHT.h>  // libreria per il sensore di temperatura DHT
#include <NewPing.h>       // libreria per il sensore di distanza HC-SR04

#define LED_PIN 7          // pin per i led
#define BUTTON1_PIN 2      // pin per il tasto 1
#define BUTTON2_PIN 3      // pin per il tasto 2
#define BUTTON3_PIN 4      // pin per il tasto 3
#define BUTTON4_PIN 5      // pin per il tasto 4
#define BUTTON5_PIN 6      // pin per il tasto 5
#define DHT_PIN 8          // pin per il sensore di temperatura
#define TRIGGER_PIN 9      // pin per il trigger del sensore di distanza
#define ECHO_PIN 10        // pin per l'echo del sensore di distanza

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // inizializza il display LCD
Adafruit_DHT dht(DHT11, DHT_PIN);      // inizializza il sensore di temperatura
NewPing sonar(TRIGGER_PIN, ECHO_PIN);  // inizializza il sensore di distanza

const char* greetings[] = {           // array di saluti casuali
  "Ciao!",
  "Benvenuto!",
  "Buongiorno!",
  "Ehi!",
  "Salve!",
  "Ciao ciao!",
  "Ciao bello!",
  "Bentornato!",
  "Eccomi qui!",
  "Ciao amico!"
};
const int numGreetings = 10;

const char* verbs[] = {              // array di verbi casuali
  "prendo",
  "misuro",
  "calcolo",
  "registro",
  "valuto",
  "analizzo",
  "controllo",
  "monitoro",
  "esamino",
  "stimolo"
};
const int numVerbs = 10;

const char* complements[] = {        // array di complementi oggetto casuali
  "la temperatura",
  "la luce",
  "la distanza",
  "il livello di umidità",
  "la pressione atmosferica",
  "il rumore ambientale",
  "la quantità di gas",
  "la vibrazione",
  "la forza",
  "la velocità"
};
const int numComplements = 10;

void setup() {
  pinMode(LED_PIN, OUTPUT);         // imposta il pin per i led come output
  pinMode(BUTTON1_PIN, INPUT_PULLUP);  // imposta i pin per i tasti come input
  pinMode(BUTTON2_PIN, INPUT_PULLUP);
  pinMode(BUTTON3_PIN, INPUT_PULLUP);
  pinMode(BUTTON4_PIN, INPUT_PULLUP);
  pinMode(BUTTON5_PIN, INPUT_PULLUP);
  lcd.begin(16, 2);                 // inizializza il display LCD con 16 colonne e 2 righe
  lcd.print("Ciao!");               // stampa il saluto iniziale sul display
}

void loop() {
  if (digitalRead(BUTTON1_PIN) == LOW) { // se viene premuto il tasto 1
    digitalWrite(LED_PIN, HIGH);         // accende i led
    lcd.clear();                         // cancella il display

Nell’architettura di von Neumann, ci sono generalmente tre tipi di memorie:

1. Memoria di lettura/scrittura (RAM): è la memoria principale del computer, utilizzata per conservare i dati e le istruzioni necessarie per eseguire le operazioni. La RAM può essere letta o scritta da parte del processore, ed è tipicamente di tipo volatile, ovvero i dati vengono persi quando il computer viene spento.
2. Memoria di sola lettura (ROM): è una memoria che contiene dati di sola lettura, ovvero dati che non possono essere modificati. Questa memoria viene utilizzata per conservare le istruzioni del firmware, come il BIOS o l’EFI del computer.
3. Memoria di archiviazione (disco rigido, SSD): è una memoria di massa utilizzata per archiviare i dati in modo permanente. A differenza della RAM, la memoria di archiviazione è non volatile, il che significa che i dati conservati non vengono persi quando il computer viene spento.

Per quanto riguarda le politiche di indirizzamento, esse definiscono come gli indirizzi di memoria vengono generati e utilizzati dal processore per accedere alla memoria. Solitamente, l’architettura di von Neumann utilizza un sistema di indirizzamento a due livelli, dove un registro di base indica l’inizio dell’area di memoria, e un registro di offset indica l’offset all’interno di quella memoria. In questo modo, il processore può accedere alla memoria utilizzando solo un indirizzo.

Per quanto riguarda le memorie utilizzate dal sistema operativo Android, esse includono:

1. RAM: Android utilizza la RAM per conservare temporaneamente le applicazioni in esecuzione e i dati. La quantità di RAM presente su un dispositivo Android può variare, ma di solito è di almeno 2 GB.
2. Memoria interna: questa memoria di archiviazione viene utilizzata per archiviare le applicazioni, i dati dell’utente e il sistema operativo Android stesso. Solitamente, i dispositivi Android offrono opzioni di archiviazione interna da 32 GB a 512 GB.
3. Memoria esterna: Android supporta l’uso di schede di memoria esterne per l’archiviazione aggiuntiva dei dati. Le schede di memoria esterne possono essere utilizzate per archiviare foto, video, file musicali e altre informazioni personali.

Crea un sistema che possa controllare un lcd in un ascensore e un tastierino numerico di chiamata dell’ascensore

Realizza il codice per un grattacielo di 35 piani ma crea un prototipo per 3 soli piani
il tastierino di chiamata fa visualizzare su tutti i display dove il l’ascensore si trova o dove si sposta.

Implementare le specifiche che desideri sul sistema ( minimo 3 arduino)

documentare codice e creare articolo blog entro la consegna.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Inizializzazione del display LCD
LiquidCrystal_I2C lcd(0x27,16,2);

void setup() {
  // Inizializzazione del display LCD
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("  Benvenuto!   ");
  lcd.setCursor(0,1);
  lcd.print("Progetto Ascensore");
}

void loop() {
  // il display LCD è statico, non necessita di aggiornamenti continui
}


#include <Keypad.h>

// Definizione del keypad
const byte ROWS = 4; // quattro righe
const byte COLS = 4; // quattro colonne
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
   
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6}; // le righe del keypad sono collegate ai pin 9, 8, 7, 6 dell'Arduino
byte colPins[COLS] = {5, 4, 3, 2}; // le colonne del keypad sono collegate ai pin 5, 4, 3, 2 dell'Arduino
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup() {
  // Inizializzazione della seriale per la debug
  Serial.begin(9600);
}

void loop() {
  // Lettura del tastierino numerico
  char key = keypad.getKey();
 
  if (key != NO_KEY) {
    // Invio del tasto premuto alla seriale per debug
    Serial.println(key);
   
    // Aggiornamento del display LCD con il piano selezionato
    lcd.setCursor(0,1);
    lcd.print("Piano: ");
    lcd.print(key);
  }
}



#include <AccelStepper.h>

// Definizione del motore passo-passo
#define HALFSTEP 8

Dato il sistema con 2 arduino collegati i2c realizzare un sistema 
che premendo il tasto 2 visualizza la temperatura premendo il tasto 3 converte la temperatura da gradi a Faranheit
premendo il tasto 4 scriva sul lcd in modalità lampeggiante la temperatura e la luminosità
Inserire sul tasto 5 la conversione di un valore dal potenziometro moltiplicato con la temperatura
Tasto 6 scrivere il primo numero intero successivo alla temperatura
tasto 7 accendere un led se la temperatura supera 37 gradi
tasto 8 stampare un quarto del valore della temperatura utilizzando una funzione
tasto 9 moltiplicare la temperatura per il valore inserito dal potenziometro /2 in input del tasto 5

codice

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

// definizioni dei pin
#define TEMPERATURE_SENSOR_PIN A0
#define LED_PIN 13
#define POTENTIOMETER_PIN A1
#define BUTTON_2_PIN 2
#define BUTTON_3_PIN 3
#define BUTTON_4_PIN 4
#define BUTTON_5_PIN 5
#define BUTTON_6_PIN 6
#define BUTTON_7_PIN 7
#define BUTTON_8_PIN 8
#define BUTTON_9_PIN 9

// inizializzazione dei componenti
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  // inizializzazione della comunicazione I2C
  Wire.begin();

  // inizializzazione del display LCD
  lcd.init();
  lcd.backlight();

  // inizializzazione dei pin
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_2_PIN, INPUT_PULLUP);
  pinMode(BUTTON_3_PIN, INPUT_PULLUP);
  pinMode(BUTTON_4_PIN, INPUT_PULLUP);
  pinMode(BUTTON_5_PIN, INPUT_PULLUP);
  pinMode(BUTTON_6_PIN, INPUT_PULLUP);
  pinMode(BUTTON_7_PIN, INPUT_PULLUP);
  pinMode(BUTTON_8_PIN, INPUT_PULLUP);
  pinMode(BUTTON_9_PIN, INPUT_PULLUP);
}

void loop() {
  // lettura del valore della temperatura
  float temperature = readTemperature();

  // gestione dei pulsanti
  if (digitalRead(BUTTON_2_PIN) == LOW) {
    // visualizzazione della temperatura
    lcd.clear();
    lcd.print("Temp: ");
    lcd.print(temperature);
    lcd.print(" C");
  }
  else if (digitalRead(BUTTON_3_PIN) == LOW) {
    // conversione della temperatura in gradi Fahrenheit
    lcd.clear();
    lcd.print("Temp: ");
    lcd.print(convertToFahrenheit(temperature));
    lcd.print(" F");
  }
  else if (digitalRead(BUTTON_4_PIN) == LOW) {
    // visualizzazione della temperatura e della luminosità in modalità lampeggiante
    lcd.clear();
    while (digitalRead(BUTTON_4_PIN) == LOW) {
      lcd.setCursor(0, 0);
      lcd.print("Temp: ");
      lcd.print(temperature);
      lcd.print(" C");
      lcd.setCursor(0, 1);
      lcd.print("Light: ");
      lcd.print(analogRead(A5));
      lcd.print(" ");
      delay(500);
      lcd.setCursor(0, 1);
      lcd.print("         ");
      delay(500);
    }
  }
  else if (digitalRead(BUTTON_5_PIN) == LOW) {
    // conversione del valore del potenziometro moltiplicato per la temperatura
    float potentiometerValue = analogRead(POTENTIOMETER_PIN) / 1023.0;
    float convertedValue = temperature * potentiometerValue;
    lcd.clear();
    lcd.print("Temp * Pot: ");
    lcd.print(convert