Trivial FTP su Debian

Puo' servire, specialmente per aggiornare firmware di apparati di rete, dover configurare un server TFtp, una sorta di Ftp con servizi decisamente alleggeriti.
Il server lavora su porta UPD 69 e supporta solo le funzioni di base (download/upload, non e' supportata l'autenticazione utente, non sono supportate le sottodirectory ed il listing della directory ...quindi se non ci conosce il nome del file non si lavora)

Su Debian esistono varie scelte per un server Tftp, in questo caso ho usato quello piu' semplice
Per l'installazione si digita semplicemente (server piu' client)

apt-get install tftp tfpd

al contrario di altri servizi, questo viene gestito direttamente da /etc/inet.conf dalla seguente riga

tftp dgram udp wait nobody /usr/sbin/tcpd /usr/sbin/in.tftpd /srv/tftp
l'ultimo parametro e' la directory in cui saranno contenuti e saranno salvati i file del server Tftp

per lo stop ed il restart non c'e' uno script in /etc/init.d. Si deve riavviare tutto il servizio di rete

Battery Pack con Arduino e Raspberry

Ho fatto qualche prova per vedere quanto puo' funzionare una scheda Raspberry od una scheda Arduino alimentandola semplicemente via USB con una batteria esterna

Da un primo semplice confronto si vede che Raspberry ha una richiesta, per la verita' variabile in funzione anche del carico di lavoro, di circa 350 mA

Raspberry

Al contrario Arduino mostra valori sempre inferiori a 10 mA (spesso il display indicava 0.00)

Arduino

In modo molto empirico

Raspberry: alimentando Raspberry con una batteria da 5000 mAh (partendo da carica completa) il sistema e' rimasto acceso 8 ore

Arduino: alimentando una Arduino Nano con una batteria da 2000 mAh il sistema e' rimasto acceso per circa  32 ore (per essere precisi  la batteria non alimentava solo Arduino ma anche un CH376 ed il voltmetro USB che anche loro un po' consumano)

C'e' da fare una osservazione: non tutte le batterie esterne sono risultate idonee ad alimentare Arduino

Da sinistra a destra tre pacchi batteria rispettivamente SBS da 2000 mAh, una cinesata (dovrebbe ricaricarsi mediante il pannello solare ma di fatto non funziona) dichiarato da 5000 mAh ed un da 10000 mAh. Il secondo ed il terzo hanno un pulsante di accensione mentre quello piu' a sinistra basta connetterlo e funziona.
Ho visto che Arduino funziona bene con il primo ed il terzo mentre con la batteria da 5000 mAh, la scheda si accende da dopo circa un secondo si spenge tutto (sia i led sulla scheda che sulla batteria), mi e' venuto il sospetto che non sentendo un carico significativo sulla porta USB il circuito sulla batteria stacchi l'alimentazione; infatti connettendola ad una Raspberry, la cui richiesta di corrente e' decisamente superiore, la batteria funziona regolarmente

Arduino e CH376S

Questo post e' a seguito di quanto gia' visto nella precedente prova
Lo scopo e' sempre il solito: creare un sistema che permette di scrivere in automatico un file su una chiavetta USB all'inserimento della stessa.
Il sistema era gia' funzionante con Raspberry ma una delle richieste del sistema e' quella di essere alimentato a batteria e la batteria deve durare almeno 48 ore; visto che con Raspberry una batteria da 5000 mA e' durata circa una notte ho modificato il progetto per usare Arduino (nello specifico una Nano) ed il modulo CH376S sperando in consumi minori

Il modulo CH376S e' chip specifico per effettuare scrittura e lettura di file system che puo' essere pilotato da Arduino.
I collegamenti sono banali (4 fili)

Fonte : http://arduinobasics.blogspot.it/2015/05/ch376s-usb-readwrite-module.html

Per questa prova ho modificato il codice ripreso da questo link
Il nucleo del programma e' evidenziato in giallo: prima controllare che il modulo USB sia connesso, dopo controlla che ci sia un dispositivo USB inserito, infine scrive il file

-----------------------------------------------------------------------------------
#include <SoftwareSerial.h>

byte computerByte;           //used to store data coming from the computer
byte USB_Byte;               //used to store data coming from the USB stick
int LED = 13;                //the LED is connected to digital pin 13 
int timeOut = 2000;          //TimeOut is 2 seconds. This is the amount of time you wish to wait for a response from the CH376S module.
String wrData = "Lanterna 2000";     //We will write this data to a newly created file.

SoftwareSerial USB(10, 11);                           // Digital pin 10 on Arduino (RX) connects to TXD on the CH376S module
                                                      // Digital pin 11 on Arduino (TX) connects to RXD on the CH376S module
                                                      // GND on Arduino to GND on CH376S module
                                                      // 5V on Arduino to 5V on CH376S module
                                                      
int connessione;
int chiave_presente;


//==============================================================================================================================================
void setup() {
  Serial.begin(9600);                                 // Setup serial communication with the computer (using a baud rate of 9600 on serial monitor)
  USB.begin(9600);                                    // Setup serial communication with the CH376S module (using the default baud rate of 9600)
  pinMode(LED,OUTPUT);                                // Define digital pin 13 as an OUTPUT pin - so that we can use it with an LED
  digitalWrite(LED,LOW);                              // Turn off the LED
  Serial.println("Iniziato");
}

//================================================================================================================================================
void loop() {
connessione = 0;
chiave_presente = 0;
checkConnection(0x01);
if (connessione == 1)
    {
      Serial.println("Connessione Presente");
      set_USB_Mode(0x06);    
      if (chiave_presente == 1)
        {
          resetALL(); 
          writeFile("lant200.txt", wrData); 
          Serial.println("************FINE*************");
        }
  }
  
if(USB.available()){                                 // This is here to capture any unexpected data transmitted by the CH376S module
    Serial.print("CH376S has just sent this code:");
    Serial.println(USB.read(), HEX);
  }  
delay(5000);
}

//END OF LOOP FUNCTION ========================================================================================================================================


void checkConnection(byte value){
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x06);
  USB.write(value);
  
  if(waitForResponse("checking connection")){       //wait for a response from the CH376S. If CH376S responds, it will be true. If it times out, it will be false.
    if(getResponseFromUSB()==(255-value)){
       //Serial.println(">Connection to CH376S was successful.");
       connessione = 1;
    } else {
      //Serial.print(">Connection to CH376S - FAILED.");
      connessione = 0;
    }
  }
}

void set_USB_Mode (byte value){
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x15);
  USB.write(value);
  
  delay(20);
  
  if(USB.available()){
    USB_Byte=USB.read();
    //Check to see if the command has been successfully transmitted and acknowledged.
    if(USB_Byte==0x51){                                   // If true - the CH376S has acknowledged the command.
        //Serial.println("set_USB_Mode command acknowledged"); //The CH376S will now check and monitor the USB port
        USB_Byte = USB.read();
        
        //Check to see if the USB stick is connected or not.
        if(USB_Byte==0x15){                               // If true - there is a USB stick connected
          //Serial.println("USB is present");
          chiave_presente = 1;
          blinkLED();                                     // If the process was successful, then turn the LED on for 1 second 
        } else {
          chiave_presente = 0;
          //Serial.print("USB Not present. Error code:");   // If the USB is not connected - it should return an Error code = FFH
          //Serial.print(USB_Byte, HEX);
          //Serial.println("H");
        }
        
    } else {
        //Serial.print("CH3765 error!   Error code:");
        //Serial.print(USB_Byte, HEX);
        //Serial.println("H");
        chiave_presente = 0;
    }   
  }
  delay(20);
}

//resetALL=========================================================================================
//This will perform a hardware reset of the CH376S module - which usually takes about 35 msecs =====
void resetALL(){
    USB.write(0x57);
    USB.write(0xAB);
    USB.write(0x05);
    //Serial.println("The CH376S module has been reset !");
    delay(200);
}

void writeFile(String fileName, String data){
  resetALL();                     //Reset the module
  set_USB_Mode(0x06);             //Set to USB Mode
  diskConnectionStatus();         //Check that communication with the USB device is possible
  USBdiskMount();                 //Prepare the USB for reading/writing - you need to mount the USB disk for proper read/write operations.
  setFileName(fileName);          //Set File name
  if(fileCreate()){               //Try to create a new file. If file creation is successful
    fileWrite(data);              //write data to the file.
  } else {
    Serial.println("File could not be created, or it already exists");
  }
  fileClose(0x01);
}

  
void setFileName(String fileName){
  Serial.print("Setting filename to:");
  Serial.println(fileName);
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x2F);
  USB.write(0x2F);         // Every filename must have this byte to indicate the start of the file name.
  USB.print(fileName);     // "fileName" is a variable that holds the name of the file.  eg. TEST.TXT
  USB.write((byte)0x00);   // you need to cast as a byte - otherwise it will not compile.  The null byte indicates the end of the file name.
  delay(20);
}

void diskConnectionStatus(){
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x30);

  if(waitForResponse("Connecting to USB disk")){       //wait for a response from the CH376S. If CH376S responds, it will be true. If it times out, it will be false.
    if(getResponseFromUSB()==0x14){               //CH376S will send 0x14 if this command was successful
    } else {
    }
  }
}

void USBdiskMount(){
  Serial.println("Mounting USB disk");
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x31);

  if(waitForResponse("mounting USB disk")){       //wait for a response from the CH376S. If CH376S responds, it will be true. If it times out, it will be false.
    if(getResponseFromUSB()==0x14){               //CH376S will send 0x14 if this command was successful
    } else {
    }
  }
}

void fileOpen(){
  Serial.println("Opening file.");
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x32);
  if(waitForResponse("file Open")){                 //wait for a response from the CH376S. If CH376S responds, it will be true. If it times out, it will be false.
    if(getResponseFromUSB()==0x14){                 //CH376S will send 0x14 if this command was successful  
    } else {
    }
  }
}

//setByteRead=====================================================================================
//This function is required if you want to read data from the file. 
boolean setByteRead(byte numBytes){
  boolean bytesToRead=false;
  int timeCounter = 0;
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x3A);
  USB.write((byte)numBytes);   //tells the CH376S how many bytes to read at a time
  USB.write((byte)0x00);
  if(waitForResponse("setByteRead")){       //wait for a response from the CH376S. If CH376S responds, it will be true. If it times out, it will be false.
    if(getResponseFromUSB()==0x1D){         //read the CH376S message. If equal to 0x1D, data is present, so return true. Will return 0x14 if no data is present.
      bytesToRead=true;
    }
  }
  return(bytesToRead);
} 

//getFileSize()===================================================================================
//writes the file size to the serial Monitor.
int getFileSize(){
  int fileSize=0;
  Serial.println("Getting File Size");
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x0C);
  USB.write(0x68);
  delay(100);
  Serial.print("FileSize =");
  if(USB.available()){
    fileSize = fileSize + USB.read();
  } 
  if(USB.available()){
    fileSize = fileSize + (USB.read()*255);
  } 
  if(USB.available()){
    fileSize = fileSize + (USB.read()*255*255);
  } 
  if(USB.available()){
    fileSize = fileSize + (USB.read()*255*255*255);
  }     
  Serial.println(fileSize);
  delay(10);
  return(fileSize);
}


//fileRead========================================================================================
//read the contents of the file
void fileRead(){
  Serial.println("Reading file:");
  byte firstByte = 0x00;                     //Variable to hold the firstByte from every transmission.  Can be used as a checkSum if required.
  byte numBytes = 0x40;                      //The maximum value is 0x40  =  64 bytes

  while(setByteRead(numBytes)){              //This tells the CH376S module how many bytes to read on the next reading step. In this example, we will read 0x10 bytes at a time. Returns true if there are bytes to read, false if there are no more bytes to read.
    USB.write(0x57);
    USB.write(0xAB);
    USB.write(0x27);                          //Command to read ALL of the bytes (allocated by setByteRead(x))
    if(waitForResponse("reading data")){      //Wait for the CH376S module to return data. TimeOut will return false. If data is being transmitted, it will return true.
        firstByte=USB.read();                 //Read the first byte
        while(USB.available()){
          Serial.write(USB.read());           //Send the data from the USB disk to the Serial monitor
          delay(1);                           //This delay is necessary for successful Serial transmission
        }
    }
    if(!continueRead()){                       //prepares the module for further reading. If false, stop reading.
      break;                                   //You need the continueRead() method if the data to be read from the USB device is greater than numBytes.
    }
  }
  Serial.println();
  Serial.println("NO MORE DATA");
}

//fileWrite=======================================================================================
//are the commands used to write to the file
void fileWrite(String data){
  Serial.println("Writing to file:");
  byte dataLength = (byte) data.length();         // This variable holds the length of the data to be written (in bytes)
  Serial.println(data);
  Serial.print("Data Length:");
  Serial.println(dataLength);
  delay(100);
  // This set of commands tells the CH376S module how many bytes to expect from the Arduino.  (defined by the "dataLength" variable)
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x3C);
  USB.write((byte) dataLength);
  USB.write((byte) 0x00);
  if(waitForResponse("setting data Length")){      // Wait for an acknowledgement from the CH376S module before trying to send data to it
    if(getResponseFromUSB()==0x1E){                // 0x1E indicates that the USB device is in write mode.
      USB.write(0x57);
      USB.write(0xAB);
      USB.write(0x2D);
      USB.print(data);                             // write the data to the file
  
      if(waitForResponse("writing data to file")){   // wait for an acknowledgement from the CH376S module
      }
      Serial.print("Write code (normally FF and 14): ");
      Serial.print(USB.read(),HEX);                // code is normally 0xFF
      Serial.print(",");
      USB.write(0x57);
      USB.write(0xAB);
      USB.write(0x3D);                             // This is used to update the file size. Not sure if this is necessary for successful writing.
      if(waitForResponse("updating file size")){   // wait for an acknowledgement from the CH376S module
      }
      Serial.println(USB.read(),HEX);              //code is normally 0x14
    }
  }
}

//continueRead()==================================================================================
//continue to read the file : I could not get this function to work as intended.
boolean continueRead(){
  boolean readAgain = false;
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x3B);
  if(waitForResponse("continueRead")){       //wait for a response from the CH376S. If CH376S responds, it will be true. If it times out, it will be false.
     if(getResponseFromUSB()==0x14){         //CH376S will send 0x14 if this command was successful
       readAgain=true;
     }
  }
  return(readAgain);
} 

//fileCreate()========================================================================================
//the command sequence to create a file
boolean fileCreate(){
  boolean createdFile = false;
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x34);
  if(waitForResponse("creating file")){       //wait for a response from the CH376S. If file has been created successfully, it will return true.
     if(getResponseFromUSB()==0x14){          //CH376S will send 0x14 if this command was successful
       createdFile=true;
     }
  }
  return(createdFile);
}


//fileDelete()========================================================================================
//the command sequence to delete a file
void fileDelete(String fileName){
  setFileName(fileName);
  delay(20);
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x35);
  if(waitForResponse("deleting file")){       //wait for a response from the CH376S. If file has been created successfully, it will return true.
     if(getResponseFromUSB()==0x14){          //CH376S will send 0x14 if this command was successful
       Serial.println("Successfully deleted file");
     }
  }
}
  

//filePointer========================================================================================
//is used to set the file pointer position. true for beginning of file, false for the end of the file.
void filePointer(boolean fileBeginning){
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x39);
  if(fileBeginning){
    USB.write((byte)0x00);             //beginning of file
    USB.write((byte)0x00);
    USB.write((byte)0x00);
    USB.write((byte)0x00);
  } else {
    USB.write((byte)0xFF);             //end of file
    USB.write((byte)0xFF);
    USB.write((byte)0xFF);
    USB.write((byte)0xFF);
  }
  if(waitForResponse("setting file pointer")){       //wait for a response from the CH376S. 
     if(getResponseFromUSB()==0x14){                 //CH376S will send 0x14 if this command was successful
       Serial.println("Pointer successfully applied");
     }
  }
}


//fileClose=======================================================================================
//closes the file
void fileClose(byte closeCmd){
  Serial.println("Closing file:");
  USB.write(0x57);
  USB.write(0xAB);
  USB.write(0x36);
  USB.write((byte)closeCmd);                                // closeCmd = 0x00 = close without updating file Size, 0x01 = close and update file Size

  if(waitForResponse("closing file")){                      // wait for a response from the CH376S. 
     byte resp = getResponseFromUSB();
     if(resp==0x14){                                        // CH376S will send 0x14 if this command was successful
       Serial.println(">File closed successfully.");
     } else {
       Serial.print(">Failed to close file. Error code:");
       Serial.println(resp, HEX);
     }  
  }
}

//waitForResponse===================================================================================
//is used to wait for a response from USB. Returns true when bytes become available, false if it times out.
boolean waitForResponse(String errorMsg){
  boolean bytesAvailable = true;
  int counter=0;
  while(!USB.available()){     //wait for CH376S to verify command
    delay(1);
    counter++;
    if(counter>timeOut){
      Serial.print("TimeOut waiting for response: Error while: ");
      Serial.println(errorMsg);
      bytesAvailable = false;
      break;
    }
  }
  delay(1);
  return(bytesAvailable);
}

//getResponseFromUSB================================================================================
//is used to get any error codes or messages from the CH376S module (in response to certain commands)
byte getResponseFromUSB(){
  byte response = byte(0x00);
  if (USB.available()){
    response = USB.read();
  }
  return(response);
}



//blinkLED==========================================================================================
//Turn an LED on for 1 second
void blinkLED(){
  digitalWrite(LED, HIGH);
  delay(100);
  digitalWrite(LED,LOW);
}
-----------------------------------------------------------------------------------

Tempo di risposta App Store

Un breve riassunto sulla mia esperienza sulla pubblicazioni di applicazioni sui vari Store 

Google Play

Il costo della licenza era (circa 4 anni fa) di 18 euro e non ha scadenza temporale. Il sistema di pubblicazione e' di tipo sostanzialmente automatico e passano poche ore dall'upload dell'apk alla presenza sul Google Play. L'applicazione risulta presente nel motore di ricerca nelle 24 ore successive

Apple Store

Il costo della licenza e' aumentata a 100 euro l'anno. In generale dal momento dell'upload dell'applicazione passano 6 giorni prima che venga presa in carico dal sistema di validazione (rigorosamente umana). Se tutto va bene il programma viene esaminato nelle 24 ore successive ed entra nel motore di ricerca nelle 48 ore successive. C'e' da dire che a seconda della persona che esamina l'applicazione ci possono essere i piu' svariati metri di misura (per esempio ho aspettato due mesi prima di pubblicare una applicazione quando, una volta cambiato esaminatore, e' stata immediatamente accettata)

Windows Phone

Il costo della licenza da sviluppatore e' di circa 15 euro e la durata e' di un anno. La pubblicazione e' sottoposta a validazione (non e' chiaro se umana od automatica) che e' giunta il giorno successivo alla richiesta di pubblicazione. L'applicazione e' entrata nel motore di ricerca dello store nelle 24 ore successive

Firefox MarketPlace

Non ci sono costi per la licenza di sviluppatore. La pubblicazione e' particolarmente lenta (l'esame e' di tipo umano e normalmente fatto da volontari) , la mia ultima applicazione e' stata sottoposta a validazione il 29 luglio ed e' stata pubblicata il 22 agosto 

Amazon Store

Non pervenuto. Ho provato una sola volta a pubblicare su questo store. Il sistema di compilazione del form mi indica un errore sulla presenza di una traduzione non accettata. Non riuscendo a capire quale fosse il problema ho aperto un ticket verso l'assistenza tecnica che non ha mai avuto risposta. Ho lasciato perdere

Arduino Nano e usb2.0-serial

Nella foto ci sono i due cloni di Arduino Nano che ho nella mia collezione.
La prima a sinistra, l'ho comprata qualche tempo fa e non mi mai dato problemi.
Quella a destra invece e' un recentissimo acquisto e quando lo ho connessa ad Arduino IDE (sotto Windows e Mac) ho avuto la spiacevole sorpresa che non era presente la porta seriale e su Windows era richiesto il driver usb2.0-serial (i driver Arduino era gia' correttamente installati)

La soluzione risiede nell'installare i pacchetti scaricabili a questo indirizzo
http://www.arduined.eu/ch340g-converter-windows-7-driver-download/
perche' sui cloni Arduino recenti viene montato un convertitore CH340G USB/Serial al posto del normale FTDI

Midi over Usb con Arduino

Arduino non puo' diventare un vero e proprio dispositivo Midi a meno che non si faccia una modifica al firmware (nel qual caso poi non diventi poi piu' programmabile) ma puo' comunque inviare stringhe MIDI via seriale che sono poi convertite, via software, da programmi Serial->Midi.

Questa prova e' stata fatta su Mac ma in linea di principio e' ripetibile anche su Windows (con altri software) ma io non ci sono riuscito

(da importare la libreria Arduino Midi Library, codice modificato dal primo esempio)
-------------------------------------------------
#include <MIDI.h>

MIDI_CREATE_DEFAULT_INSTANCE();

#define LED 13      

void setup()
{
    pinMode(LED, OUTPUT);
    MIDI.begin(1);         
    Serial.begin(115200);
}

void loop()
{
        digitalWrite(LED,HIGH);
        MIDI.sendNoteOn(42,127,1);  // Send a Note (pitch 42, velo 127 on channel 1)
        delay(1000);        // Wait for a second
        MIDI.sendNoteOff(42,0,1);   // Stop the note
        digitalWrite(LED,LOW);
}
-------------------------------------------------

Poi si va in Applicazioni/Utility e si carica Configurazioni Midi Audio, Mostra Studio Midi Driver IAC e si attiva il driver

Per la conversione del segnale seriale derivante da Arduino in segnale Midi si puo' usare Hairless-MidiSerial. Il funzionamento e' quanto mai semplice. A sinistra si imposta la porta seriale dell'Arduino e sulla destra gli input ed output Midi (nel mio caso era solo un input in quanto Arduino spedisce solo dati)

Come destinatario del segnale Midi, non avendo altro a disposizione, ho provato Virtual Midi Piano Keyboard

Tramite questa catena e' possibile far suonare ad Arduino il pianoforte Midi

E' ovviamente noioso ma basta inserire un po' di pulsanti e riprogrammare Arduino per rendere tutto piu' interattivo

Samba su Centos 7

Per installare Samba su Centos 7 ho seguito questi passi (la macchina ha Selinux disattivato)

yum install samba samba-client samba-common

ed in seguito

systemctl enable smb.service
systemctl enable nmb.service
systemctl restart smb.service
systemctl restart nmb.service

ad un primo tentativo il servizio nmd non veniva tirato su, ho risolto facendo uno yum update (e' quindi consigliabile farlo da subito prima dell'installazione dei pacchetti)

dato che il server su cui lo ho installato ha due interfacce (una con ip pubblico ed una con ip privato)  ho modificato il file /etc/samba/smb.conf per mettere in ascolto solo sull'interfaccia interna modificando

[global] 

interfaces = 10.1.1.16 lo 

bind interfaces only = yes

per verificare che tutto sia andando a buon fine si puo' digitare netstat -tapn | grep smbd

Rimane da aprire la porta del firewall 

firewall-cmd --permanent --zone=public --add-service=samba

firewall-cmd reload

visto che era richiesto l'accesso autorizzato ad una cartella condivisa e' stato creato un utente samba generico che permette di scrivere sulla directory del web server

smbpasswd -a www_user

il file smb.conf finale e' di questo tipo

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

[global]

workgroup = WORKGROUP

server string = Samba Server %v

netbios name = centos

security = user

map to guest = bad user

dns proxy = no

interfaces = 10.1.1.16 lo

bind interfaces only = yes

#============= Share Definitions ==============

[www]

path = /var/www/html

valid users = www_user

read only = No

create mask = 0777

directory mask = 0777