Archivi categoria: Informatica

Revisiting the Unix philosophy in 2018

In 1984, Rob Pike and Brian W. Kernighan published an article called “Program Design in the Unix Environment” in the AT&T Bell Laboratories Technical Journal, in which they argued the Unix philosophy, using the example of BSD’s cat -v implementation. In a nutshell that philosophy is: Build small, focused programs—in whatever language—that do only one thing but do this thing well, communicate via stdin/stdout, and are connected through pipes.

Image result for unix logo att

IBM To Acquire Red Hat, Completely Changing The Cloud Landscape And Becoming World’s #1 Hybrid Cloud Provider

Most significant tech acquisition of 2018 will unlock true value of cloud for business

– IBM and Red Hat to provide open approach to cloud, featuring unprecedented security and portability across multiple clouds

[IBM Changes Cloud Landscape with Red Hat Acquisition]
IBM Changes Cloud Landscape with Red Hat Acquisition

– Deal accelerates IBM’s high-value business model, making IBM the #1 hybrid cloud provider in an emerging $1 trillion growth marke

 

E-Mobility Startup

Revisione 0.01.

Sta avvenendo il cambio tecnologico nella mobilità dal motore termico a quello elettrico.

Assistiamo ad una enorme offerta tecnologica e nuove complessità da gestire in modo radicalmente diverso da quanto siamo abituati

 

I nuovi mezzi elettrici sono estremamente complessi sotto il profilo informatico

  1. dotati di veri e propri computer
    1. connessi localmente ed a internet in molteplici modi
    2. invece delle vecchie, spartane e costosissime centraline elettroniche
  2. sono costruiti per essere connessi in diversi modi

    1. WiFi
    2. 3G 4G e prossimi
    3. bluetooth
      1. classe dal tipo 1 al tipo 5 con un gran numero di varianti
      2. bluetooth LE
    4. IoT
    5. banche dati
    6. monitoraggio remoto
    7. sistemi sorveglianza, sicurezza, antifurto
    8. controllo remoto
      1. stato ricarica
      2. stato batterie
      3. programmazione viaggi
    9. stradari con gestione automatica punti e tempi rifornimento
      1. tipo colonnine e connettori
        1. solo f.e.m. 220 V AC
        2. 22KW ovvero 400V 64A
        3. 50 KW
        4. 100 KW

Entro la fine del decennio assisteremo all’avvio decisivo della e-mobility. Si passerà dalle e-bike, ormai mature con favolosi motori Bosh e batterie Samsung o Panasonic, agli scooter alle moto che in primavera prossima vedremo in grande offerta, quadricicli, city car, automobili, veicoli commerciali.

I paesi ben organizzati riusciranno a costruire una distribuzione, in particolare ultimo miglio, di energia da dotare il territorio nazionale delle moderne e veloci colonnine da 100KW.

Gli altri paesi, arretrati e dipendenti, dovranno puntare forse sul fuel cell e l’idrogeno, in particolare allo stato liquido. Idrogeno prodotto altrove.

Comunque il mezzo con motore termico è primitivo perché

  1. è molto complicato: pistoni, cambio, turbina, alternatore, batteria, motore avviamento, distribuzione, radiatori, impianto raffreddamento, impianto olio, centralina costosissima sebbene modestissima, …
  2. quindi non si riesce a starci dietro, tutte le risorse vanno in manutenzioni costosissime, tagliandi, ed il mezzo degradanon permettendo di spendere risorse in valori aggiunti quali la guida automatica, il monitoraggio e la connettività reale.

 

Il mezzo con motore elettrico si semplifica enormemente il motore, il pacco batteria, carrozzeria e parti meccaniche essenziali ed il computer.

Se le batterie sono a noleggio, l’utilizzatore si dimentica ogni problema legato alle stesse.

Il motore elettrico rimane praticamente inalterato anche dopo 200.000 o 300.000 Km: si vedano le Tesla usate ora in vendita …

Inoltre i motori elettrici possono avere una precisione tale necessaria alla robotica. E quindi si entra nei cinque livelli previsti di guida automatica. Realtà impossibile dai rozzi ed inutilmente complessi motori termici.

Il computer di bordo è potente e non è nemmeno lontano parente delle centraline dei precedenti veicoli.

Computer che in breve permette di utilizzare o realizzare

      1. app mobile
      2. monitoraggio remoto
      3. banca dati informazioni
      4. robotica
      5. sicurezza
      6. multimedia ed intrattenimento
      7. assistenza

La proposta potrebbe essere di progettare una startup innovativa sulla mobilità elettrica per individuare, commercializzare e gestire proposte specifiche sostituendo la grande marca come brand a specifici modelli di nuovi produttori.

Primo Incontro Il Semaforo Arduino

Il primo incontro sull’Unità Didattica Il Semaforo Arduino si è tenuto con un gruppo ristretto di partecipanti dall’età prescolare, alle medie, alle superiori, a genitori ed appassionati.

Il bilancio è decisamente positivo e al centro dell’affermazione si può porre la piccola in età prescolare, che non sa ancora leggere e capace di seguire i discorsi introduttivi, ma nel momento di vivo laboratorio si è letteralmente scatenata nell’apprendere dalle immagini della guida stampata, a corredo del kit, come realizzare il Semaforo Arduino e vederlo funzionare. Non sapeva leggere numeri e parole quali GND, ma ha collocato i fili nel posto giusto, e nel momento di erogare energia alla scheda è rimasta visibilmente entusiasta: le luci colorate brillavano nella sequenza sperata. E’ stato un momento semplice, ma speciale vederla guardare soddisfatta per un bel po’ di tempo sua realizzazione.

I giovani, ma anche i genitori distratti da ben altri problemi, si sono rivolti all’esperienza con interesse vivo, ed alla fine un’affermazione di un genitore riassume l’intera esperienza: “non sapevo che fosse così interessante, adesso ho capito ed è importante“.

Quindi il gioco con i computer in miniatura per introdurre questioni realmente ostili, come la programmazione delle macchine calcolatrici, funziona ed alla grande.

Prevediamo di organizzare anche altri incontri allargati.

 

AMD Optimistic About 7nm EPYC Future for Servers

AMD first announced its EPYC Process for datacenter servers back in June 2017 and has been steadily evolving the silicon ever since.

“We are seeing the largest demand for our top of the stack 24 and 32-core EPYC processors, which combine industry-leading core counts and I/O to deliver performance advantages across cloud, virtualization and HPC workloads,” Su said.

AMD Product logos

The Ryzen is AMD’s desktop processor and Su noted that she has seen strong demand for the higher end Ryzen 7, Ryzen 5 and Ryzen Threadripper processors.

Vivaldi 2.1 Adds AV1 Video Codec Support, Puts More Power into Quick Commands

Vivaldi Technologies released today Vivaldi 2.1, the first point release to the 2.x series of the Chromium-based, cross-platform web browser.

Vivaldi is known as “the web browser for power users,” so Vivaldi 2.1 continues to bring more productivity additions in an attempt to make you more efficient when using Vivaldi to browse the Web or do whatever work you’re doing at the office.

Vivaldi 2.1 released

Mark Shuttleworth Details Ubuntu 18.10 Cosmic Cuttlefish Linux Release

The Ubuntu 18.10 Linux release became generally available on Oct 18, providing new capabilities for desktop, server and cloud users.

On the desktop side, there is a new theme called “Yaru” that provides a different look and feel than what was provided by default in the prior Ubuntu 18.04 LTS release.

On the server side, Ubuntu 18.10 benefits from an updated Linux 4.18 kernel as well as support for TLS 1.3 encryption. The Ubuntu Server 18.10 integrates the OpenStack Rocky release, providing users with a stable version of the most recent open source OpenStack cloud platform release.

Networking configuration gets a boost in 18.10 as well with netplan.io, which is a network configuration abstraction utility.

 

Linux 4.19

Date Mon, 22 Oct 2018 08:32:24 +0100
From Greg KH <>
Subject Linux 4.19

Hi everyone!

It’s been a long strange journey for this kernel release…

While it was not the largest kernel release every by number of commits,
it was larger than the last 3 releases, which is a non-trivial thing to
do. After the original -rc1 bumps, things settled down on the code side
and it looks like stuff came nicely together to make a solid kernel for
everyone to use for a while. And given that this is going to be one of
the “Long Term” kernels I end up maintaining for a few years, that’s
good news for everyone.

Ubuntu 18.10 (Cosmic Cuttlefish) released

Codenamed "Cosmic Cuttlefish", 18.10 continues Ubuntu's proud tradition of integrating the latest and greatest open source technologies into a high-quality, easy-to-use Linux distribution. The team has been hard at work through this cycle, introducing new features and fixing bugs.

Risultati immagini per ubuntu images

The Ubuntu kernel has been updated to the 4.18 based Linux kernel, our default toolchain has moved to gcc 8.2 with glibc 2.28, and we've
also updated to openssl 1.1.1 and gnutls 3.6.4 with TLS1.3 support.

Ubuntu Desktop 18.04 LTS brings a fresh look with the community-driven Yaru theme replacing our long-serving Ambiance and Radiance themes.  We
are shipping the latest GNOME 3.30, Firefox 63, LibreOffice 6.1.2, and many others.

Ubuntu Server 18.10 includes the Rocky release of OpenStack including the clustering enabled LXD 3.0, new network configuration via netplan.io,
and iteration on the next-generation fast server installer.  Ubuntu Server brings major updates to industry standard packages available on private
clouds, public clouds, containers or bare metal in your datacentre.

The newest Ubuntu Budgie, Kubuntu, Lubuntu, Ubuntu Kylin, Ubuntu MATE, Ubuntu Studio, and Xubuntu are also being released today.

More details can be found for these at their individual release notes:

    https://wiki.ubuntu.com/CosmicCuttlefish/ReleaseNotes#Official_flavours

intenance updates will be provided for 9 months for all flavours releasing with 18.10.

Nuclear Reactor Startup Transatomic Power going Open Source after Closure

This recently happened with Transatomic Power (founded by Mark Massie and Dr. Leslie Dewan in April 2011), a Nuclear Startup that introduced a brand new design of its own Nuclear Reactor that is a lot more efficient than conventional ones.

Commenti al Firmware Arduino 0.18.08

Revisione 0.03

La nuova versione 0.18.08 del Firmware Arduino permette di realizzare l’Unità Didattica Il Semaforo Arduino.

L’Unità Didattica prevede di realizzare un modello di semaforo con tre LED colorati rosso, giallo e verde, collegati ai pin 2, 4 e 6.

All’avvio, se la sezione SEMAFORO nello sketch è attivata e la variabile semaforo_stato è automatico, allora si avvia il ciclo continuo di accensione e spegnimento con dati ritardi delle luci.

Seguirà l’ implementazione del comando
semaforo automatico|disabilitato|rosso|giallo|verde
da utilizzare nel consueto modo da remoto mediante canale USB .

Il codice sorgente relativo all’Unità Didattica viene attivato con

#define SEMAFORO

In questo caso vengono definite ed inizializzate le seguenti variabili:

#if defined(SEMAFORO)
      String semaforo_stato = “automatico”;
  // manuale|automatico|disabilitato
     String semaforo_luce = “rossa”; // rossa|gialla|verde
     int semaforo_durata_rosso = 3; // in secondi
     int semaforo_durata_giallo = 1; // in secondi
     int semaforo_durata_verde = 3; // in secondi
     int semaforo_pin_rosso = 2;
     int semaforo_pin_giallo = 4;
     int semaforo_pin_verde = 6;
#endif

 

Quindi nella funzione setup()

#if defined(SEMAFORO)

     pinMode(semaforo_pin_rosso, OUTPUT);
     pinMode(semaforo_pin_giallo, OUTPUT);
     pinMode(semaforo_pin_verde, OUTPUT);

#endif

 

E nella funzione loop()

#if defined(SEMAFORO)

if(semaforo_stato == “automatico”)
{
   while(true) {

      digitalWrite(semaforo_pin_rosso, HIGH);
      delay(1000 * semaforo_durata_rosso);
      digitalWrite(semaforo_pin_rosso, LOW);

      digitalWrite(semaforo_pin_giallo, HIGH);
      delay(1000 * semaforo_durata_giallo);
      digitalWrite(semaforo_pin_giallo, LOW);

      digitalWrite(semaforo_pin_verde, HIGH);
      delay(1000 * semaforo_durata_verde);
      digitalWrite(semaforo_pin_verde, LOW);
   }
}
#endif

Arduino Firmware 0.18.08

#define FIRMWARE_VERSION "0.18.08"

/*Language: Wiring/Arduino Serial Console 115200 baud \n ASCII 10 */ 

#define WATCH_DOG_ENABLED
#define LCD_ENABLED // pin 4,5,6,7,8,9 reserved
#define MACRO_01 // per utilizzi specifici

#define SEMAFORO
/* 001
   Si osservi l'utilizzo del C preprocessor,
   macro processor, per compilare il minor codice
   possibile al fine di poter utilizzare
   microcontroller con modeste risorse.
   Il generatore codice sorgente firmware
   provvederà a includere le opportune
   righe di definizione variabili 
   per il prepocessor
*/

// #include <Wire.h>

#if defined(WATCH_DOG_ENABLED)
#include <avr/wdt.h>
#endif
/* 002
   Importante predisposione dei microcontroller:
   watch dog al livello hardware
   che firmware successivi andranno a
   implementare in modo migliore.
   Dovranno tener conto anche del tipo di scheda
   che esegue il firmware, infatti Uno e Mega
   hanno gestione diverse del watch dog 
   a livello hardware
*/
#if defined(LCD_ENABLED)
#include <LiquidCrystal.h>
#endif
/* 003
   La connessione LCD al controller
   adottata lo standard DF-Robots
*/

#if defined(TEENSYDUINO)
/* 004
   Riconoscimento della scheda 
   che esegue il Firmware
*/
// --------------- Teensy -----------------
#if defined(__AVR_ATmega32U4__)
#define BOARD "Teensy 2.0"
#elif defined(__AVR_AT90USB1286__)
#define BOARD "Teensy++ 2.0"
#elif defined(__MK20DX128__)
#define BOARD "Teensy 3.0"
#elif defined(__MK20DX256__)
#define BOARD "Teensy 3.2" // and Teensy 3.1 (obsolete)
#elif defined(__MKL26Z64__)
#define BOARD "Teensy LC"
#elif defined(__MK64FX512__)
#define BOARD "Teensy 3.5"
#elif defined(__MK66FX1M0__)
#define BOARD "Teensy 3.6"
#else
#error "Unknown board"
#endif

#else // --------------- Arduino ------------------
#if defined(ARDUINO_AVR_ADK)
#define BOARD "Mega Adk"
#elif defined(ARDUINO_AVR_BT) // Bluetooth
#define BOARD "Bt"
#elif defined(ARDUINO_AVR_DUEMILANOVE)
#define BOARD "Duemilanove"
#elif defined(ARDUINO_AVR_ESPLORA)
#define BOARD "Esplora"
#elif defined(ARDUINO_AVR_ETHERNET)
#define BOARD "Ethernet"
#elif defined(ARDUINO_AVR_FIO)
#define BOARD "Fio"
#elif defined(ARDUINO_AVR_GEMMA)
#define BOARD "Gemma"
#elif defined(ARDUINO_AVR_LEONARDO)
#define BOARD "Leonardo"
#elif defined(ARDUINO_AVR_LILYPAD)
#define BOARD "Lilypad"
#elif defined(ARDUINO_AVR_LILYPAD_USB)
#define BOARD "Lilypad Usb"
#elif defined(ARDUINO_AVR_MEGA)
#define BOARD "Mega"
#elif defined(ARDUINO_AVR_MEGA2560)
#define BOARD "Mega 2560"
#elif defined(ARDUINO_AVR_MICRO)
#define BOARD "Micro"
#elif defined(ARDUINO_AVR_MINI)
#define BOARD "Mini"
#elif defined(ARDUINO_AVR_NANO)
#define BOARD "Nano"
#elif defined(ARDUINO_AVR_NG)
#define BOARD "NG"
#elif defined(ARDUINO_AVR_PRO)
#define BOARD "Pro"
#elif defined(ARDUINO_AVR_ROBOT_CONTROL)
#define BOARD "Robot Ctrl"
#elif defined(ARDUINO_AVR_ROBOT_MOTOR)
#define BOARD "Robot Motor"
#elif defined(ARDUINO_AVR_UNO)
#define BOARD "Uno"
#elif defined(ARDUINO_AVR_YUN)
#define BOARD "Yun"
// These boards must be installed separately:
#elif defined(ARDUINO_SAM_DUE)
#define BOARD "Due"
#elif defined(ARDUINO_SAMD_ZERO)
#define BOARD "Zero"
#elif defined(ARDUINO_ARC32_TOOLS)
#define BOARD "101"
#else
#define BOARD "Unknown board"
#endif
#endif

boolean lcd_print_sec = true;

#if defined(LCD_ENABLED)
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
// lcd_print_sec   = true;
#endif


#if defined(SEMAFORO)
  
  String semaforo_stato       = "automatico";  // manuale|automatico|disabilitato
  String semaforo_luce        = "rossa";       // rossa|gialla|verde
  int semaforo_durata_rosso   = 3;              // in secondi 
  int semaforo_durata_giallo  = 1;              // in secondi
  int semaforo_durata_verde   = 3;              // in secondi
  int semaforo_pin_rosso      = 2;              
  int semaforo_pin_giallo     = 4;             
  int semaforo_pin_verde      = 6;             
  
#endif

boolean request_response = true;
String end_response = "Done ";
/* 006
   Il protocollo sviluppato utilizza 
   lo schema naturale request / response
   con stringhe di testo e terminate da capo riga
   Il Firmware prevede di poter terminare 
   la risposta del controller con una riga
   che inizia con Done ...
*/

// const int TIMEOUT_CICLE = 200;
int CYCLE_DELAY   = 20;
/* 007
   CYCLE_DELAY è il ritardo nel ciclo principale
   che realizza il poll mediante porta USB
   verrà gestito il comando che
   permetterà di variare il contenuto
*/

byte portType[54];
/* 008
   Matrice fondamentale che contiene la
   configurazione dei PIN del microcontroller
   che è assegnata dal comando CONFIG
*/

char incomingChar = '\0';
String incomingString = "";
String command    = "";
String parameters = "";
String parameter  = "";
String tempString = "";
String tempString1= "";
String tempString2= "";
int port = 0;
String portvalue  = "";
String portname   = "";
int pos  = 0;
int pos1 = 0;
int pos2 = 0;
int pos3 = 0;
int tempInt     = 0;
char tempChar   = '\0';
int inPortMap[7];

int loop_100    = 0;
int loop_10000  = 0;
/* 009
   variabili che realizzano due cicli
   demoltiplicati rispetto al ciclo principale
   ovvero loop_100 diventa vera ogni cento 
   cicli principali   
*/


void setup() 
{

#if defined(WATCH_DOG_ENABLED)
   wdt_enable(WDTO_8S);
#endif

   Serial.begin(115200);
   delay(50);
#if defined(LCD_ENABLED)
lcd.begin(16, 2);
lcd.setCursor(0,0);
lcd.print("IoT ");
lcd.print(FIRMWARE_VERSION);
#endif

   for (int i = 0; i <= 53; i++)
   {
      portType[i] = 0; 
   }

/* 010
   La matrice portType contiene la configurazione
   dei PIN del microcontroller

   Le Schede Mega hanno
      54 port digital, from 9 to 53
      16 port AD, from 0 to 13
   
   I valori in portType significano:

      0   not defined
      1   IN
      2   OUT
      3   PWM
      4   LCD
      5   I2C
      6   SPI
      7   SERIAL
*/

#if defined(LCD_ENABLED)
// 8, 9, 4, 5, 6, 7
portType[4] = 4;
portType[5] = 4;
portType[6] = 4;
portType[7] = 4;
portType[8] = 4;
portType[9] = 4;
#endif

#if defined(SEMAFORO)

pinMode(semaforo_pin_rosso, OUTPUT);
pinMode(semaforo_pin_giallo, OUTPUT);
pinMode(semaforo_pin_verde, OUTPUT);
#endif

   // Wire.begin();

}



void loop() 
{
  loop_100 = loop_100 + 1;
  if (loop_100 = 100)
  {
    loop_100 = 0;
    loop_10000 = loop_10000 +1;
  }

  if (loop_10000 = 100)
  {
    loop_10000=0;
  }

  #if defined(WATCH_DOG_ENABLED)
     wdt_reset();
  #endif
  #if defined(LCD_ENABLED)
     if (lcd_print_sec)
     {
        lcd.setCursor(0,1);
        lcd.print(millis()/1000);
     }
  #endif

#if defined(SEMAFORO)

if(semaforo_stato == “automatico”)
{
while(true) {

digitalWrite(semaforo_pin_rosso, HIGH);
delay(1000 * semaforo_durata_rosso);
digitalWrite(semaforo_pin_rosso, LOW);

digitalWrite(semaforo_pin_giallo, HIGH);
delay(1000 * semaforo_durata_giallo);
digitalWrite(semaforo_pin_giallo, LOW);

digitalWrite(semaforo_pin_verde, HIGH);
delay(1000 * semaforo_durata_verde);
digitalWrite(semaforo_pin_verde, LOW);

}
}




   if (Serial.available() > 0) 
   {
      incomingChar = Serial.read();
      if (incomingChar == '\n') 
      {
         execCommand();
         incomingString = "";
      }
      else 
      {
         incomingString += incomingChar;
         if (incomingString.length() > 254) 
         {
            Serial.print("Error: ");
            Serial.println(incomingString);
            incomingString = "";
         }
       }
   }
}


void execCommand() 
{
   incomingString.trim();
   command = incomingString;
   if (incomingString.indexOf(" ")>0) 
   {
      command = incomingString.substring(0,
      incomingString.indexOf(" "));
      command.trim();
      parameters = incomingString.substring(pos);
      parameters.trim();
   }
   command.toLowerCase();
   if ((command == "version") || (command == "ver"))
   {
      Serial.println(FIRMWARE_VERSION);
   }
   else 
      if ((command == "board"))
      {
         Serial.println(BOARD);
      }
      else if ((command == "help"))
      {
         PrintHelp();
      }
      else if (command == "config")
      {
         configPort();
      }
      else if (command == "write" or command == "set")
      {
         writePort();
      }
      else if (command == "read" or command == "get")
      {
         readPort();
      }
      else if (command == "lcd")
      {
         #if defined(LCD_ENABLED)
            lcdExecCommand();
         #endif
      }
      else
      {
         Serial.println("command unknown");
      }
};

void PrintHelp()
{
   Serial.println( "--------------------------------------------------------");
   Serial.println("");
   Serial.println("Commands (case not sensitive)");
   Serial.println("");
   Serial.println("ver|version");
   Serial.println("board");
   Serial.println("config port 0..53 type unused|IN|OUT|PWM|LCD|I2C|SPI|SERIAL");
   Serial.println("set|write port <n> value 0|low|1|high");
   Serial.println("get|read port <n>");
   Serial.println("lcd on|enable|off|disable");
   Serial.println("lcd clear");
   Serial.println("lcd clear row 1|2");
   Serial.println("lcd print row 1|2 <string>");
   Serial.println("lcd print seconds on|off");
   Serial.println("request_response on|off");
   Serial.println("");
   Serial.println( "------------------------------------------------");

}

void configPort() 
{
   // CONFIG PORT n TYPE out
   parameters = parameters.substring(parameters.indexOf("port") + 5);
   parameters.trim();
   pos = parameters.indexOf(" ");
   String port_number = parameters.substring(0, pos);
   port_number.trim();
   String port_type = parameters.substring(parameters.indexOf("type")+4);
   port_type.trim();
   port_type.toLowerCase();
   int int_port_number = -1;

   if(port_number.length()>0)
   {
      int_port_number = port_number[0] - '0';
   }
   if(port_number.length()>1)
   {
      int_port_number = int_port_number * 10 +    port_number[1] - '0';
   }

   if (int_port_number>=0 and (BOARD=="Mega" or (BOARD=="Uno" and int_port_number< 14)) )
   {
      if (port_type=="unused")
      {
         portType[int_port_number] = 0;
      }
      else if (port_type=="in" or port_type=="input")
      {
         portType[int_port_number] = 1;
         pinMode(int_port_number, INPUT);
      }
      else if (port_type=="out" or port_type=="output")
      {
         portType[int_port_number] = 2;
         pinMode(int_port_number, OUTPUT);
      }
      else if (port_type=="pwm")
      {
         portType[int_port_number] = 3;
         pinMode(int_port_number, OUTPUT);
      }
      else if (port_type=="i2c")
      {
         portType[int_port_number] = 5;
      }
      else if (port_type=="spi")
      {
         portType[int_port_number] = 6;
      }
      else if (port_type=="serial")
      {
         portType[int_port_number] = 7;
      }
      else
      {
         incomingString = "not "+incomingString;
      }

   } else
   {
      incomingString = " not "+incomingString;
   }

/* Mega
54 port digital, from 9 to 53
16 port AD, from 0 to 13

portType value

0 unused
1 IN
2 OUT
3 PWM
4 LCD
5 I2C
6 SPI
7 SERIAL

*/

   if (request_response)
   {
      Serial.println(end_response+ incomingString);
   }
}

void lcdExecCommand() 
{
#if defined(LCD_ENABLED)

   if (parameters.indexOf("clear")>0 or parameters.indexOf("CLEAR")>0 )
   {
      lcd_print_sec = false;
      if (parameters.indexOf("row")>0 or parameters.indexOf("ROW")>0 )
      {
         if (parameters.indexOf("1")>0 )
         {
            lcd.setCursor(0,0);
            lcd.print(" ");
         }
         if (parameters.indexOf("2")>0 )
         {
            lcd.setCursor(0,1);
            lcd.print(" ");
         }
      } 
      else
      {
         lcd.setCursor(0,0);
         lcd.print(" ");
         lcd.setCursor(0,1);
         lcd.print(" ");
      }

      if (request_response)
      {
         Serial.println(end_response+ incomingString);
      }

      } else if (parameters.indexOf("print")>0 and (parameters.indexOf("seconds")>0 or parameters.indexOf("second")>0 or parameters.indexOf("SECOND")>0 or parameters.indexOf("SECONDS")>0 ))
      {
         if (parameters.indexOf("off")>0 or parameters.indexOf("OFF")>0 )
            lcd_print_sec = false;
         else
            lcd_print_sec = true;

         if (request_response)
         {
             Serial.println(end_response+ incomingString);
         }
      } else if (parameters.indexOf("print")>0 and ( parameters.indexOf("row 1")>0) )
      {
         lcd.setCursor(0,0);
         lcd.print(parameters.substring( parameters.indexOf("row") + 6 ) ); 
         if (request_response)
         {
            Serial.println(end_response+ incomingString);
         }
      } else if (parameters.indexOf("print")>0 and (parameters.indexOf("row 1")>0) )
      {
         lcd.setCursor(0,0);
         lcd.print(parameters.substring( parameters.indexOf("row") + 7 ) ); 
         if (request_response)
         {
            Serial.println(end_response+ incomingString);
         }
      } else if (parameters.indexOf("print")>0 and (parameters.indexOf("row 2")>0) )
      {
         lcd.setCursor(0,1);
         lcd.print(parameters.substring( parameters.indexOf("row") + 6 ) ); 
         if (request_response)
         {
            Serial.println(end_response+ incomingString);
         }
     } else if (parameters.indexOf("print")>0 and (parameters.indexOf("row 2")>0) )
     {
        lcd.setCursor(0,1);
        lcd.print(parameters.substring( parameters.indexOf("row") + 7 ) ); 
        if (request_response)
        {
            Serial.println(end_response+ incomingString);
        }
        } else
        {
            Serial.println("lcd on");
        }
#endif
}


void writePort()
{
   // WRITE PORT n VALUE out

   parameters = parameters.substring( parameters.indexOf("port") + 5);
   parameters.trim();

   pos = parameters.indexOf(" ");
   String port_number = parameters.substring(0, pos); 
   port_number.trim();

   String port_value = parameters.substring( parameters.indexOf("value")+5);
   port_value.trim(); 
   port_value.toLowerCase();
   int int_port_number = -1;
   if(port_number.length()>0)
   {
      int_port_number = port_number[0] - '0';
   }
   if(port_number.length()>1)
   {
      int_port_number = int_port_number * 10 +    port_number[1] - '0';
   }

   if (int_port_number>=0 and (BOARD=="Mega" or (BOARD=="Uno" and int_port_number< 14) ) and portType[int_port_number]== 2 )
   {
      if (port_value=="1" or port_value=="true" or port_value=="high")
      {
         digitalWrite(int_port_number, HIGH);
      }
      else if (port_value=="0" or port_value=="false" or port_value=="low")
      {
         digitalWrite(int_port_number, LOW);
      }
      else
      {
         incomingString = " not "+incomingString;
      }
   } else
   {
      incomingString = " not "+incomingString;
   }
   if (request_response)
   {
      Serial.println(end_response+ incomingString);
   }
}

void readPort()
{

   // WRITE PORT n VALUE out

   parameters = parameters.substring(parameters.indexOf("port") + 5);
   parameters.trim();
   pos = parameters.indexOf(" ");
   String port_number = parameters.substring(0, pos);
   port_number.trim();
   int int_port_number = -1;
   if(port_number.length()>0)
   {
      int_port_number = port_number[0] - '0'; 
   }
   if(port_number.length()>1)
   {
      int_port_number = int_port_number * 10 + port_number[1] - '0';
   }

  if (int_port_number>=0 and (BOARD=="Mega" or (BOARD=="Uno" and int_port_number< 14) ) and portType[int_port_number]== 1 )
  {
     Serial.println(digitalRead( int_port_number));
  }
  else
  {
     incomingString = " not "+incomingString;
  }
  if (request_response)
  {
     Serial.println(end_response+incomingString);
  }
}

void getPort()
{
   pos = parameters.indexOf(" ");
   while ( pos > 0 ) 
   {
      parameter = parameters.substring(0, pos);
      parameter.trim();
      parameters = parameters.substring(pos);
      parameters.trim();
      if (parameter.length() == 1 ) 
      {
         parameter.setCharAt(1, tempChar);
         tempChar = tempChar - 48;
         if ((tempChar >= 0) && (tempChar <= 7))
         {
            port = tempChar + 22 ;
            // digitalRead(port);
         }
      }
      else 
      {  
         // Errore:
      };
   };
}

 

Unità Didattiche con Laboratorio di Tecnologia e Scienza.

Laboratorio di Informatica
Revisione 0.02

UNIX Linux
il Sistema Operativo liberamente utilizzabile, immune da virus ed estremamente robusto

  1. Linux Kernel
  2. Distribuzioni Linux
    1. Debian
    2. Red Hat
    3. Ubuntu
    4. Suse
  3. il computer per tutti
      1. LibreOffice
      2. Chrome e Firefox
      3. Oracle VirtualBox
      4. Gimp
      5. Programmi Multimediali
    1. immune da virus
    2. Open Source
    3. iniziativa Revisione Computer Dismessi
      1. recupero parco macchine obsoleto mediante allestimento Linux
      2. iniziativa che permette di utilizzare vecchie macchine
        1. a costo zero
        2. e contribuendo alla diminuzione del conferimento di inquinanti

RaspberryPi
il computer completo, di dimensioni e costo  minimi

  1. un computer completo per la didattica dell’informatica
    1. computer ARM 32 e 64 bit
    2. Debian compilato ARM Rpi: Raspbian
    3. lo standard Python nella programmazione
  2. Catalogo dei Progetti Didatti Internazionali
  3. Istituti Scolastici con Gruppi di Interesse attivi
  4. Il Network Globale degli Appassionati e Gruppi di Interesse
  5. MagPi
    1. traduzione
  6. Allestimento di un Raspberry Pi Multimediale
    1. Ascolto Musica, Radio Internet, Netflix
  7. la comunicazione tra Raspberry Pi ed altri dispositvi
    1. rete
    2. WiFi
      1. RaspberryPi zero
    3. seriale
    4. USB
  8. il controllo da Raspberry Pi di Arduino attraverso porte USB
    1. Qt app
  9. Raspberry Pi GPIO
    1. Raspbian modulo kernel
      1. utilizzo da terminae
      2. Python sorgente

Arduino
il computer miniaturizzato che interagisce con il mondo esterno

  1. laboratorio di didattica dell’informatica di base
  2. esperienze concrete di utilizzo
  3. Attuatori
  4. Sensori
  5. Principali tipi di schede
  6. Come alimentare le schede Arduino
  7. Porte I/O
    1. standard 5V e 3.3V
    2. I/O
      1. PWM
    3. AD
    4. DA
    5. seriale
    6. SPI
    7. I2C
  8. La programmazione di Arduino
    1. come programmare Arduino
      1. IDE e connessione USB
      2. configurazione
      3. Terminale Seriale
      4. Controllo remoto attraverso cavo USB
    2. Programmi Elementari
    3. allestimento ed utilizzo di un computer per programmare Arduino
    4. prime esperienze
      1. Accensione di un LED Colorato
      2. Accensione di due LED Colorati Intermittenti
      3. Il Semaforo
  9. La comunicazione mediante porte USB
    1. creazione di un linguaggio specifico per comunicare con Arduino
    2. UNIX Linux
      1. porta USB
        1. identificativi di produttore, modello e seriale
      2. udev
      3. P&P
      4. connessione
        1. questio reset alla connessione e, per certe schede, anche alla sconnessione
      5. firmware standard per controllo da dispositivo, per esempio computer o Raspberry Pi, attraverso USB
      6. Qt Poll App
        1. protocollo di comunicazione
        2. wrapper verso RDBMS
          1. PostgreSQL
      7. CEnni a codice Python
  10. Internet delle Cose
  11. interazione con un computer
    1. Raspberry Pi, Arduino, Sensori ed Attuatori
  12. esperienze introduttive
  13. esperienze con Opto Elettronica ed Illuminotecnica
  14. esperienze elementari con la Musica
    1. esperienze in ambito tessile: il vestito con equipaggiamento tecnologico
  15. Progetti Tecnologi
  16. Progetti Artistici
  17. Nozioni di Elettronica di Base

 

 

Informatica

  1. introduzione alla programmazione delle macchine calcolatrici
    1. UNIX Linux
      1. elementi di programmazione in
        1. C e C++
        2. Python
    2. Programmazione WEB
      1. elementi di Yii2, Crud
    3. RDBMS
      1. PostgreSQL, pgSQL, PL Python3 Untrusted
  2. Sistemi Operativi
    1. per processori Intel 32 bit, Intel ed AMD 64 bit, ARM 32 bit ed ARM 64 bit
  3. Il computer per uso domestico
  4. Il computer in ambito Aziendale
    1. Il server
  5. Sicurezza e prevenzione
  6. Monitoraggio
  7. Principi di Networking
    1. la rete domestica
    2. WiFi
    3. la rete Aziendale
      1. sistemi UTM e sicurezza aziendale
  8. Questioni Forensi

Internet of Things ed elettronica

  1. Processori
  2. Controller
  3. Sensori
  4. Attuatori
  5. Protocolli
  6. Linguaggi
  7. Standard I.o.T.

Scienza

  1. Introduzione alla Matematica
    1. il numero in natura
    2. matematica antica
      1. gli Elementi di Euclide
      2. l’eredità del mondo Greco Antico
        1. osservare lontano perchè non si capisce il vicino
        2. dall’astronomia alla geometria
        3. il pensiero geometrico che aumenta la complessità nel tramandare la cultura matematica
        4. notazioni per numeri che inibiscono il pensiero algebrico
      3. la nascita del sistema posizionale decimale
        1. algoritmi di calcolo moderni
      4. il Mondo Arabo nel Medio Evo
      5. Fibonacci
      6. il pensiero algebrico
        1. nozione moderna di insieme con struttura
        2. insiemi con operazioni
        3. algoritmo di calcolo
        4. notazione dei numeri diversa dalle lettere per l’alfabeto
        5. calcolo letterale: lettere al posto di un dato numero, lettere al posto di incognite
        6. nozione di equazione
      7. Newton e la nascita della scienza moderna
        1. la differenza nello spazio geometrico  omogeno; la materia
        2. corrispondenza biunivoca tra numeri e realtà: il metodo delle coordinate
      8. definire numeri con approssimazioni
      9. denso e continuo
      10. Felix Klein e i Programmi di Erlangen
        1. nuova classificazione delle discipline scientifiche sui gruppi di trasformazioni
      11. Geometria Proiettiva nell’Ottocento
      12. Scienza Razionale: il metodo assiomatico
    3. Insiemi Numerici
      1. Naturali, Interi, Razionali, Reali e Complessi
      2. insieme ed operazioni
        1. il Teorema Fondamentale dell’Algebra per sancire l’esistenza di al più due tipi di operazione: additivo e moltiplicativo
    4. Linguaggio degli insiemi
    5. Corrispondenze tra Insiemi
    6. Fondamenti Di Matematica
    7. La visione della Matematica dopo Felix Klein
      1. La nuova concezione dello Spazio Geometrico
    8. Storia della Matematica
      1. Storia dei numeri
      2. Storia del Pensiero Geometrico
      3. Storia del Pensiero Algebrico
      4. La Matematica nel Mondo Greco Antico
        1. Il pensiero Geometrico che compromette lo sviluppo Algebrico e la Didattica
    9. Matematica Antica
    10. Matematica Moderna
    11. Metodo Assiomatico
    12. Algebra sul Concetto di Insieme ed Invarianza
  2. Fisica di base
    1. Lo Spazio della Fisica sullo Spazio Geometrico
    2. Materia
    3. Il metodo delle Coordinate
    4. la nozione di Misura
    5. Sistemi Inerziali
    6. Newton e La nascita della Scienza Moderna
      1. i Principi di Newton

 

Coradia iLint

It was 2 years ago, at InnoTrans 2016 in Berlin that Alstom presented the Coradia iLint for the first time. The launch of the CO2-emission-free regional train that represents a true alternative to diesel power positioned us as the first railway manufacturers in the world to develop a passenger train based on hydrogen technology. And just two years later, at this year’s edition of InnoTrans 2018, the iLint enters into commercial service in Germany.
 

Coradia iLint

Ubuntu 18.10 Release Date, New Features and Everything Important Associated With it

Ubuntu 18.10 will be released on 18th October 2018.

Ubuntu 18.10 Cosmic Cuttlefish

Unlike the previous releases, there will be no alpha or beta milestones. This will be replaced by ‘testing weeks’.

18.10 a short-term release and will be supported for nine months from its release i.e. July’19.

new features:

1. GNOME 3.30
2. New default theme
3. Better battery life for laptops (possibility)
4. Support for fingerprint scanner
5. Startup time boost and XDG Portals support for Snap applications
6. Android integration
7. Linux Kernel 5.0
8. 32-Bit support diminishing from flavors
9. Faster boot with new compression algorithms

Ethec

La moto elettrica che vedete in questo video e in queste foto si chiama Ethec, è un prototipo sviluppato dall’Università di Zurigo in Svizzera e da qualche giorno è sulla bocca di tutti per due motivi principali: fa 400 km con una sola carica.

 

Sarà la prima moto elettrica con recupero energetico in frenata.

La batteria è composta da 1260 celle a ioni di litio ed è raffreddata da un sistema termoelettrico: una cella di Peltier abbinata ad una sistema di iniezione olio.  La capacità è di 15 kWh, con recupero energetico. I motori sono due, uno anteriore e uno posteriore, per un totale di 22 kW di potenza cioè circa 30 CV.

ethec side

ethec battery cooling

Battery Cooling: Battery cooling system with fan, pumps, a peltier element and an expansion tank. For a durable and powerful battery an efficient cooling is required. An air circuit discharges the heat from the oil circuit with the help of peltier elements. The oil circuit directly flows around the battery cells.

ethec battery structure

Battery Structure: Structure of battery including two modules from 1260 Lithium-ion-cells. In view, the regular arrayed circuit boards and perfectly placed temperature sensors, which control the cooling system precisely

 

 

Il Semaforo Arduino

Laboratorio di Informatica per Introdurre l’Interazione tra Computer Miniaturizzato e Realtà circostante.
Revisione 0.04

L’Unità Didattica si rivolge a chi desidera introdursi nel mondo dei Computer Miniaturizzati che interagiscono con la realtà circostante.

Il livello di difficoltà è basso, quindi è aperta a tutti i Gruppi di Interesse: dal bambino con il genitore all’insegnante che cerca stimoli da realizzare nel Laboratorio d’Informatica della sua Scuola.

La lezione introduce il popolare, soprattutto in ambito  della Didattica dell’Informatica nelle Scuole, Arduino.

Ai partecipanti verrà presentato il Kit Semaforo Arduino con parti da utilizzare nell’esperienza di Laboratorio:

  1. piccole schede computer Arduino Mega
    1. il contesto crea una prima occasione per utilizzare le schede Arduino
    2. schede dotate di sketch nella versione 0.18.08 che estendono il firmware di base con il comando semaforo
  2. pacchi batterie ricaricabili, con le usuali prese USB a 5V, da usare come Alimentatori
    1. sono introdotte le principali modalità di alimentazione delle schede Arduino
  3. cavi USB per collegare gli Arduino agli Alimentatori
    1. il partecipante utilizza il popolare standard USB per alimentare l’Arduino, ma poi anche per programmarlo e per controllarlo da computer
  4. piccoli emettitori di luce verde, giallo e rossa
    1. l’unità didattica utilizzare i popolari componenti elettronici emettitori di luce, LED, per realizzare un semaforo in miniatura
  5. cavi per collegare Arduino a tre emettitori di luce verde, gialla e rossa
  6. il programma di base versione 0.18.08 con modifiche specifiche che fa funzionare Arduino
  7. alcuni computer UNIX Linux Ubuntu da utilizzare per la programmazione Arduino
    1. primo approccio all’ambiente che permette di creare i programmi per Arduino mediante un computer
    2. con l’occasione introduciamo l’utilizzo di un computer UNIX Linux Ubuntu
    3. sarà poi possibile creare il nuovo scenario di controllare la scheda Arduino direttamente dal computer mediante cavo USB

La prima parte dell’evento ha l’obiettivo di introdurre i nuovi materiali e metodi a chi non ne ha mai avuto occasione.

Quindi i partecipanti potranno realizzare un vero e proprio semaforo in miniatura, che fa scattare, ciclicamente, il verde poi un breve giallo ed infine il rosso.

La seconda parte dell’esperienza viene introdotta dal problema di come variare le temporizzazioni dei colori.

Il formatore mostrerà

  • come collegare l’Arduino ad uno dei computer presenti
  • come cambiare il codice che la scheda Arduino esegue
  • e quali siano i valori da modificare per completare l’unità didattica

I partecipanti quindi completeranno in autonomia l’esperienza di laboratorio e, completata l’esperienza, avranno ben aperta una nuova prospettiva di ricerca, che realizza un fondamentale tassello nella sua Formazione di Tecnologie Informatiche di Base.

Calendario

  1. da definire
    1. Presso: da definire
  2. da definire
  3. da definire

Numero partecipanti

Previsti da 15 a 30,  con i quali ci sarà laboratorio ed interazione.

Propedeutico

Nessuna conoscenza, per tutti i gruppi di interesse. I bambini devono essere accompagnati, come sempre, da un genitore.

L’esperienza è rivolta a tutti i Gruppi di Interesse  ed ha un significato propedeutico ad ogni altra unità didattica in tema.

 

 

Didattica ed Intrattenimento

Didattica dell’Informatica. Revisione 0.07
Per contattare il Gruppo Didattico.

Calendario e Locandine Incontri
Esperienze di Laboratorio d’Informatica Elementare

  1. Incontro Introduttivo alla Didattica ed Intrattenimento con Arduino
    1. Locandina
    2. Data: 24 ottobre 2018 ore 19.00
  2. Il Semaforo Arduino
    1. Locandina
    2. Un Incontro
    3. date da definire
  3. Arduino Luci e Colori
    1. Locandina
    2. Ciclo di tre Incontri
    3. date da definire
  4. Sartoria Arduino
    1. Locandina
    2. Ciclo di tre Incontri
    3. date da definire
  5. Arduino Serra
    1. Locandina
    2. Ciclo di tre Incontri
    3. date da definire
  6. Il Telecomando Arduino
    1. Locandina
    2. Ciclo di cinque Incontri
    3. date da definire
  7. Arduino Led Streap
    1. Locandina
    2. Ciclo di due Incontri
    3. date da definire
  8. Arduino Music Light
    1. Locandina
    2. Ciclo di quattro Incontri
    3. date da definire
  9. Arduino Pet
    1. Locandina
    2. Ciclo di cinque Incontri
    3. date da definire
  10. Il Computer Tascabile RaspberryPi
    1. Locandina
    2. Ciclo di cinque Incontri
    3. date da definire

 

Unità Didattiche con Laboratorio di Tecnologia e Scienza

Gruppi di interesse

  1. Bambini, età da 8 a 13 anni con genitori
  2. Ragazzi, dai 14 ai 17 anni
  3. Giovani
  4. Studenti Universitari
  5. Insegnanti
    1. Scuole Elementari
    2. Scuole Medie
    3. Istituti Superiori
  6. Appassionati

 

 

Calendario Unità Didattiche

In corso di definizione.

 

 

The Linux Kernel Has Grown By 225k Lines of Code So Far This Year From 3.3k Developers

Even on an EPYC server with Optane 900p NVMe SSD storage, the gitstats process on the hearty Linux kernel repository is quite a task. But the process is done and offering a fresh look at the current Linux kernel activity in Git.

LINUX KERNEL --

Here are some of the findings:

The kernel repository is at 782,487 commits in total from around 19.009 different authors. The repository is made up of 61,725 files and from there around 25,584,633 lines — keep in mind there is also documentation, Kconfig build files, various helpers/utilities, etc.

Zero Motorcycles

Zero Motorcycles Inc. is an American manufacturer of electric motorcycles. Formerly called Electricross, it was started in 2006 by Neal Saiki, a former NASA engineer, in Santa Cruz, California. The company is now located nearby in Scotts Valley.

ZERO S ZF7.2 ZERO S ZF13.0 ZERO S ZF13.0 +Power Tank
City? 89 miles (143 km) 161 miles (259 km) 206 miles (332 km)
Highway, 70 mph (113 km/h)? 45 miles (72 km) 81 miles (130 km) 103 miles (166 km)
Combined? 60 miles (97 km) 108 miles (174 km) 138 miles (222 km)
Peak torque 78 ft-lb (106 Nm) 81 ft-lb (110 Nm) 81 ft-lb (110 Nm)
Peak power? 34 hp (25 kW) @ 4,300 rpm 60 hp (45 kW) @ 5,300 rpm 60 hp (45 kW) @ 5,300 rpm
Top speed (max)? 91 mph (146 km/h) 98 mph (158 km/h) 98 mph (158 km/h)
Max capacity? 7.2 kWh 13.0 kWh 16.6 kWh

 

How to Connect Your Android Phone to Linux via Airdroid

Airdroid is a unique and useful application that lets you transfer files, send SMS messages and control your phone through your PC. It is available within the Google Play store and the iOS App Store and provides a useful alternative if you need to grab a file but don’t have a USB cable at hand. While Windows has a full rich client that allows easy access to the features, those of us on Linux have to use the web-based interface, but this doesn’t make the application any less useful.

Smart ring

A smart ring is a wearable electronics device with advanced mobile components that combine features of mobile devices with innovative features useful for mobile or handheld use. Smart rings, which are typically the size of traditional rings or larger, combine the features of a mobile device, such as the ability to make payments and mitigate access control, with popular innovative uses such as gesture control and activity tracking. Smart rings can communicate directly with smart phones or personal computers through a variety of applications and websites, and operate without the need to carry a smart phone, such as when interacting with back-end systems on the cloud through or performing standalone functions such as activity tracking. They typically do not have a display and operate by contextual relevance, such as by making a payment when near a payment terminal, unlocking an electronic lock when near the lock, or controlling home appliances when making gestures in the home. Some smart rings have physical or capacitive buttons to use as an activation mechanism, such as to initiate a gesture.

 

 

In 2013, the English firm McLear released the first smart ring for sale. The market is currently around $25 million.

 

Security

Secure access control such as for company entry and exit, home access, cars, and electronic devices was the first use of smart rings. Smart rings change the status quo for secure access control by increasing ease of use, decreasing physical security flaws such as by ease of losing the device, and by adding two-factor authentication mechanisms including biometrics and key code entry.

Payments and ticketing

Smart rings can perform payments and metro ticketing similar to contactless cards, smart cards, and mobile phones. Security of the transaction is equal to or greater than contactless cards. The first smart ring to be created with contactless payments was the NFC Payment Ring, which was mass produced and unveiled at the Olympics Summer Games at Rio de Janeiro in August 2016.

Activity

Replicating smartwatches, smart rings provide features including activity tracking (i.e. step tracking), heart beat tracking, and sleep tracking (through measuring heart beats and movements). The smart ring form factor contains enough space to contain the same components as smart watches. Due to size constraints, smaller components are typically used in current smart ring products in market, such as smaller and less accurate accelerometers, and smaller batteries leading to lower battery life than smart watches.

Social

Smart rings provide social feedback to users and can be used to engage in the user’s environment in a way that other wearables and mobile devices do not permit. Ringly produces a women’s fashion smart ring which lights to notify the user when the user receives a text message, phone call, or other notification. This enables the user to be aware of the notification without having to constantly check her or his smart phone.

RFID / NFC Smart Ring – Size 12 – NTAG213

NFC (near field communication) technology is a great way to interact wirelessly with projects. With the RFID/NFC Smart Ring your ring can communicate with your smart phone/tablet, computer, or much more! Contains two MiFare Ultralight C – NTAG 213’s with 144 bytes of read/write memory. One is on the ‘inside’ of the ring towards the palm, the other is underneath the jewel. You can use tags to launch apps, unlock your phone, transmit a URL, control an Arduino, etc.

RFID / NFC Smart Ring - Size 12 - NTAG213