Month: January 2017

Unix permission

In diverse situazioni è necessario impostare a mano i permessi di directory e file in Unix.

UTENTE APPLICATIVO

L’utente applicativo è l’utente di sistema che deve eseguire delle applicazioni: un web server, un database, ecc.

Questo utente deve essere proprietario di alcuni oggetti e utilizzatore di altri: per esempio l’utente che gestisce Apache (web-server) deve poter accedere al “suo” file-system /var/www come owner, ma come lettore per /usr/lib/libaprutil-1.so.0.4.1

Questa divisione di permessi garantisce l’ordien e la sicurezza del sistema ed è bene che sia mantenuta.

STRANI RISULTATI

Dopo aver installato qualche pacchetto software, capita qualcosa di strano: l’accesso a certe directory non è possibile. Poi verificando ecco qualche risultato strano:

$ ls -la  /var/www/wp-content
ls: cannot access /var/www/wp-content/themes: Permission denied
ls: cannot access /var/www/wp-content/..: Permission denied
ls: cannot access /var/www/wp-content/uploads: Permission denied
ls: cannot access /var/www/wp-content/.: Permission denied
ls: cannot access /var/www/wp-content/index.php: Permission denied
ls: cannot access /var/www/wp-content/plugins: Permission denied
total 0
d????????? ? ? ? ?            ? .
d????????? ? ? ? ?            ? ..
-????????? ? ? ? ?            ? index.php
d????????? ? ? ? ?            ? plugins
d????????? ? ? ? ?            ? themes
d????????? ? ? ? ?            ? uploads

LA RAGIONE

L’origine di questa anomalia è dovuta alla errata scrittura delle ACL sul file-system. Un caso tipico è quello di una creazione di directory come root per poi assegnare in ricorsione la ownership ad un altro utente:

root@vps97297:/var/www# chown -R www-data:www-data /var/www/html/

root@vps97297:/var/www# chmod 666 -R  /var/www/html

LA SOLUZIONE

Per risolvere l’impasse la soluzione è quella di assegnare, anche temporaneamente il permesso di esecuzione “x”:

root@vps97297:/var/www# chmod -R +x /var/www/html

e quindi il risultato è quello che vediamo di seguito.

PRIMA:

$ ls -la /var/www/html
ls: cannot access /var/www/html/..: Permission denied
ls: cannot access /var/www/html/.: Permission denied
ls: cannot access /var/www/html/wp-content: Permission denied
total 0
d????????? ? ? ? ?            ? .
d????????? ? ? ? ?            ? ..
d????????? ? ? ? ?            ? wp-content
$

DOPO:

$ ls -la /var/www/html
total 12
drwxrwxrwx  3 www-data www-data 4096 Jan 25 17:48 .
drwxr-xr-x 10 www-data www-data 4096 Jan 25 17:48 ..
drwxrwxrwx  3 www-data www-data 4096 Jan 25 17:48 wp-content

CONCLUSIONE

Molti, specie alle prime armi, in casi di errori persistenti nella gestione dei permessi sul file-system, ricorrono alla “valanga” di permessi: tutto a tutti, e poi si vede. Purtroppo quel “poi” diventa “mai” e allora son guai!

Sono, o diventano guai perchè in caso di attacco (nell’esempio parlavo di web-server), la perdita di “filtro” che le ACL offrono, rischia di lasciare aperte tutte le porte con le conseguenze che possiamo facilmente immaginare.

 

Se non fosse chiaro, ditemelo e nel frattempo… buon web-server a tutti!

 

 

 

Raspberry… in abito da sera!

Chi utilizza le schede quali Arduino o Raspberry, è consapevole

di usare dei prodotti validi, versatili, ma non industriali. Ma non è tutto così, ci sono prodotti “particolari” e “seri”…

CM3

Questa scheda CM3 (Compute Module 3) è una classica scheda Raspberry senza i circuiti ausiliari: camera, USB, ecc.

La CM3 è utile da usare per progettare circuiti personalizzati. Facciamo un esempio, se ieri prendevo un Raspberry e usando i suoi connettori la collegavo ad un convertitore ADC per leggere le temperature delle sonde termiche (magari delle celle frigo), oggi, con la sola CM3, aggiungo il mio circuito disegnato apposta e tutto è pronto. La mia scheda avrà solo quello che serve (cosa me ne faccio infatti dell’interfaccia per la webcam?), per esempio potrò inserire delle morsettiere optoisolate e via dicendo.

QUALCHE ESEMPIO

Qualcuno, da tempo, con le precedenti versioni di CM aveva già aperto la strada, un “piccolo” produttore: NEC! Questo per capire che il confine tra i SOM didattici ed il mondo produttivo è molto sottile e che non ci sono più i soliti player.

 

In questa foto lo vediamo all’interno di un monitor V484 di NEC.

 

 

 

 

 

POTENZA DI CALCOLO

Come per il modello già noto Raspberry III, la CM3 possiede la stessa potenza di calcolo con il Broadcom BCM2837 – processore da 64bit – una derivazione di ARM Cortex-A53 quad-core – con clock a 1.2GHz. La ram è da 1GB, espandibile a 4GB.

 

ALTRO ESEMPIO: WANAD

Si tratta di un totem pubblicitario basato su monitor tv e collegato a Raspberry III.

Il circuito dei WANAD include modulo GPS, batterie Li-po, inverter 12/220, regolatore di tensione e display di controllo. Si tratta di un circuito elettronico personalizzato: l’utilizzo di CM3 rappresenta la soluzione migliore per costi e prestazioni. Di questo oggetto ne parlerò in seguito…

 

E buona progettazione a tutti!

 

 

 

 

Come usare Virtualbox

C’è una classe di software meno conosciuta ai più, ma molto utile per provare i programmi: sono gli hypervisor.

COSA SONO?

Tecnicamente un hypervisor è un programma che esegue altri sistemi operativi.

In pratica avremo una macchina fisica e diverse altre macchine virtuali. Su ogni computer è installato un sistema operativo: con un hypervisor è possibile avere più macchine (computer) ed i relativi sistemi operativi. Quindi sulla stessa macchina (fisica) posso far girare altre macchine (virtuali), una alla volta oppure in contemporanea.

Tra i più diffusi hypervisor abbiamo: Virtualbox di Oracle e VMware.

 

A COSA SERVONO?

Lo scopo di avere più macchine virtuali è quello di poter creare/usare/cancellare un sistema operativo e relativa macchina senza compromettere il computer vero e proprio. Sarà infatti successo a molti di dover reinstallare il sistema operativo dopo che questo rallentava il computer, oppure dopo che una installazione aveva danneggiato il sistema. La reinstallazione, oltre ad essere delicata, richiede il fermo-macchina con tutti i disagi che questo comporta.

Ma non è tutto. Con le macchine virtuali è possibile “creare” un computer virtuale e trasferirlo per farlo eseguire su un altro computer fisico senza installare alcunchè.

 

COME FUNZIONA

Un hypervisor funge da tramite tra la macchina ospitata (virtuale) e quella ospitante (reale).

In pratica quando una macchina virtuale deve accedere al disco fisso o al video, lo fa passando prima da Virtualbox il quale traduce la richiesta per la macchina reale.

L’uso di risorse quali la connessione di rete, da parte della macchina virtuale, avviene sempre tramite hypervisor.

MATERIALE OCCORRENTE

Per eseguire una macchina virtuale occorre:

  • Computer con almeno 6GB ram e disco da 500GB
  • VirtualBox
  • Ubuntu 16 64bit oppure Windows 8/10

Il software necessario è disponibile qui.

INSTALLAZIONE

L’installazione di VirtualBox è semplice: un po’ di setup, click, ecc.

Al termine avremo l’ambiente pronto per poter creare delle macchine.

(continua…)

 

Salva

Salva

…un grazie a tutti!

Nell’ultima edizione di cooperazione dove si parla di stampa 3D, siamo in

copertina con il FAB-LAB di Grono.

Questo è il link.

Si tratta di un grande riconoscimento per la nostra piccola struttura, ma in particolare desidero ringraziare tutti coloro che, in diversi modi, hanno contribuito e continuano a contribuire al diffondersi della cultura (ed utilizzo) di queste nuove tecnologie!

Ricordo che la struttura è aperta a tutti, gratuitamente.

Un buon 2017 a tutti, ed ancora: GRAZIE!

e buona progettazione a tutti…

 

 

Controllo traffico

Dalla email di Mario:

“…Per quanto riguarda la problematica del timer ho individuato su internet il seguente

circuito basato su mudulo DS1307:  esempio:
secondo lei potrebbe risolvere il problema della data e ora?
Per quanto riguarda la registrazione dei dati non sarebbe possibile aggiungere una SD card e registrare i dati su file tipo l’esempio del seguente sito?
Essendo poco pratico di elettronica e di arduino, non capisco se sto dicendo delle “castronerie”..“

CIRCUITO A BLOCCHI

Un sistema per rilevare delle masse metalliche in transito può essere sintetizzato a blocchi:
Il componente tratteggiato indica la possibilità di collegamento ad un microcontrollore: questo consente una maggiore scalabilità e connettività del sistema.

COMPONENTI EXTRA

Come scriveva Mario, sono necessarii dei componenti specifici, da reperire a parte. Si tratta di due moduli:
  • RTC Real Time Clock, un orologio con data
  • SD-mod, per scrivere/leggere delle SD card

In realtà mancano tutti gli altri componenti della figura a blocchi precedenti: oscillatore, filtro, alimetatore, ecc., ma questo è solo un esercizio (su questo è utile riprendere il concetto di FabLab).

INTERFACE STUBBING

Per scrivere il codice useremo la tecnica dell’interface stubbing. Di che si tratta?
Semplice, si tratta di un metodo per far credere ad un programma di avere ricevuto (o inviato) dei dati da una funzione. In pratica faremo finta di avere sia il modulo RTC e sia SD. Questo significa isolare le componenti, l’unica cosa che dobbiamo sapere è come gestire l’interfaccia, ovvero come chiamare la funzione e come trattare i relativi parametri.
Faccio un esempio: devo completare un programma che userà un sensore di pressione. Il sensore vero e proprio non mi é ancora arrivato, ma ho a disposizione le informazioni tecniche dal suo produttore. Egli mi dice che il sensore darà una tensione di uscita lineare da 0-4.3V proporzionale al range di pressione da 0 a 10bar.
Questa è una parte del programma “padre”:
...
// leggo pressione entrata PS1
wps1 = rd_ps (1);
 e questa è la funzione chiamata che ritorna un valore fisso a 2.33:
double rd_ps (int pport) {
   return (2.33);
/*
   parte di codice che legge effettivamente la porta assegnata al sensore...*/
}
 Chiaramente prima di andare in produzione lo stub dovrà essere tolto e al suo posto si dovrà usare la funzione corretta.
 Ecco una prima parte:
/*
  Moesa d'Ur SA

  engineering staff of M'AU
  
  project:    lab20_ard1
  file name:  som_lab20_00.ino
  porpouse:   traffic monitor
 
who       when        what 
---------------------------------------------
mr       09.01.2017   creates 
*/

int wcurrport = 0; 

/* stub
#include <swRTC.h>
swRTC rtc; //create a new istance of the lib
*/
 
void setup() {
/*        rtc.stopRTC(); //stop the RTC
        rtc.setTime(12,0,0); //set the time here
        rtc.setDate(4,6,2012); //set the date here
        rtc.startRTC(); //start the RTC
        */
         int wcurrport = 0; 
pinMode(wcurrport, INPUT); 
Serial.begin(9600);
Serial.print( "controllo traffico: ");
}
 
void loop() {
int whour;
int wminu;
int wseco;
   int wcurrval = analogRead(wcurrport);     
   if (wcurrval > 60.0) {
/* stub
     whour = rtc.getHours();
   wminu = rtc.getMinutes();
   wseco = rtc.getSeconds();
   */
   Serial.println(whour); 
   Serial.print(":");
   Serial.print(wminu); 
   Serial.print(":");
   Serial.println(wseco); 
    }
    delay(10);
}

continua…

Come archiviare i progetti 3D

Quando cominciamo ad usare la nostra stampante 3D, inizieremo anche a produrre diversi file di stampa o GCode. Questo vale sia per chi disegna e stampa e sia per chi semplicemente scarica i files da stampare.

Quello di cui parlerò oggi è relativo ad un metodo di archiviazione, valido per tutte le piattaforme:

  • Linux
  • Windows
  • MacOs

ELEVATO NUMERO

Col tempo questo numero di file aumenta, infatti per ogni disegno abbiamo almeno un STL e per ogni stampante avremo diversi profili

num_file = (num_disegni * profili * stampanti ) * 3

cioè, ad esempio, se il nostro laboratorio ha 3 stampanti con relativi 12 profili, e abbiamo prodotto 20 disegni (che sono pochissimi…), avremo (teoricamente):

(20 * 12 * 3 ) * 3 = 2160 file

Un gran bel numero, tenendo conto che 20 progetti, o disegni, sono una quantità irrisoria. Io stesso, disegnando poco, ho almeno 400 disegni.

 

IL FATTORE “3”

Il “3” presente nell’equazione precedente sta ad indicare i tre tipi di file:

  • originale
  • STL
  • GCode

IL VALORE DELL’ORDINE

Per molti l’ordine è prassi quotidiana, ma vale sempre la pena ricordare che archiviare con metodo permette di risparmiare molto tempo e quindi denaro.

GLI STRUMENTI

Per archiviare sono necessari due strumenti:

  • foglio elettronico
  • directory o cartelle

 

LE CARTELLE

Per prima cosa è bene stabilire che un disegno può avere diverse versioni o correzioni, quindi divideremo i disegni in alcuni grandi gruppi o classi in modo da ottenere una struttura simile:

 

dove

  • “ct” è una classe
  • 0040 è il numero di disegno
  • 00 è il numero della versione
  • orig contiene il disegno originale (Autocad, Archicad, Sketchup, ecc.)
  • CAE contiene gli STL corretti
  • CAM contiene i GCode
  • img contiene le immagini, compresi gli screenshot del progetto nei dei diversi programmi

All’interno della cartella “classe.disegno.versione” ho inserito in file di testo per delle note relative al disegno (tipo delle modifiche, richieste, ecc.). Nell’immagine precedente questo file si chiama “ct004100.txt”.

classe_A
        +-----disegno_1
                      +---------versione_0
                                         +---orig
                                         +---CAE
                                         +---CAM
                                         +---img
                      +---------versione_1                                         
                                         +---orig
                                         +---CAE
                                         +---CAM
                                         +---img
classe_B
       +-----disegno_1
                      +---------versione_1
                                         +---orig 
                                         +---CAE  
                                         +---CAM 
                                         +img
. . .

NOMI DEI FILE

Istintivamente il nome di un file rispecchia il suo contenuto. Su tutti i sistemi operativi è facile nomi lunghi dei file oltre a punteggiatura e spazi.

A questa “libertà” per i nomi dei file si contrappone il limite di visualizzazione del nome file sulla stampante: molte stampanti hanno 16 o 20 caratteri disponibili e quindi scrivere “appartamento p.zza del Sole-prop. Guerra” diventa lo stesso di “appartamento p.zz“. Di questo limite o legge del minimo, bisognerà tenerne conto.

Per risolvere questo limite possiamo utilizzare un foglio elettronico, così strutturato:

 

A questo punto diventa facile collegare la descrizione ad un nome di file. Quest’ultimo sarà un codice composto:

classe + disegno + versione

 

NOMI FILE GCODE

Il passagio alla stampa 3D richiede (è consigliato) l’utilizzo dei profili.

I profili dipendono dalla stampante e dai diversi filamenti.

Quindi ogni profilo avrà un suo codice e questo sarà unito al nome file del disegno per creare il nome file di stampa definitivo.

Sembra complesso? No, questione di metodo ed abitudine.

 

CORREZIONE DISEGNO

Una volta esportato in STL un disegno dovrà essere corretto. Questo passaggio, CAE, lo definiremo con la lettera “f” da inserire nel nome del file.

 

STRUTTURA PROFILI

Lo stesso foglio elettronico può contenere uno “sheet” con la lista dei profili e magari, delle stampanti:

 

le prime due colonne (K.PRN e K.PROF) formeranno il codice del profilo: “bab” , “bat”, ecc.

Chiaramente ogni stampante e contraddistinta da una lettera dell’alfabeto.

 

NOME FILE COMPLETO

Dopo avere definito i codici del disegno e dei profili possiamo creare il nome file definitivo:

classe + disegno + versione + correzione + profilo

e come esempio

ct + 0041 + 00 + "_" + f + bab +1 + c

ct004100_fbab1c.gcode

In questo nome ho ancora aggiunto qualcosa: “1c”. Stanno a significare 1 copia, disposta in centro.

 

Per chi fosse interessato è possibile scaricare il modello di foglio elettronico.

 

… e a tutti, buona stampa 3D…ordinata!