Partizione GPT in Windows XP

Mi e' capitato di prendere un disco esterno da 500 Gb che non usavo da un po' di tempo e di non riuscire a montarlo su Windows Xp
Il sintomo e' che la periferica e' stata riconosciuta nella catena USB ma non veniva mostrata tra i dischi disponibili. Una verifica sugli strumenti di amministrazione/gestione dischi ha mostrato che il disco risultava integro ma con una partizione di protezione GPT...probabilmente avevo usato il disco su Windows 7.

Rimuovere la partizione GPT da Windows XP non e' banalissimo e comporta comunque la perdita dei dati.
Seguendo le istruzioni sul sito di Lacie si deve

entrare in shell (cmd), lanciare diskpart ed individuare il numero del disco (in questo caso 6)

ed effettuare
select disk 6
clean

a questo punto il disco di puo' formattare sotto Windows XP

Ext2/Ext3 su Windows

Dato che ho praticamente tutti i computer su Debian e' abbastanza ovvio che anche i dischi di backup siano formattati con filesytem Linux

Oggi pero' avevo la necessita' di scaricare i dati (e quindi di montare anche in sola lettura) i dischi di backup su un Windows Xp

La prima prova e' stata con Ext2Fsd. Questo metodo funziona ma ha dei grossi limiti, il piu' evidente e' quello di non riuscire a copiare dei file il cui nome includa caratteri speciali (spazi, accenti) il che e' abbastanza comune oggi

Il secondo tentativo e' stato con ExtFs, un prodotto commerciale che una licenza libera per uso personale

Il programma si comporta decisamente meglio del precedente (anche se non e' esente da difetti) e mi ha permesso di copiare oltre 10 Gb di dati con poche correzioni manuali

Web Radio con VLC

Controradio
Radio Due
Radio Tre
Radio Capital
Radio Virgin Classic

PiBang su Raspberry

fdsa
Mentre stavo cercando di sostituire LXDE con Openbox su Raspbian mi sono imbattuto in PiBang, una versione compilata per Arm di Crunchbang

A differenza di Raspbian, questa distribuzione si presenta come una versione desktop completa (sono preinstallati Gimp, VLC, Abiword e viene proposto in modo semplice di installare Libreoffice).
Per questo motivo e' necessario utilizzare almeno una SD Card da 4 Gb

Le impressioni di utilizzo sono buone nonostante l'hardware limitato ...fra le altre cose al primo avvio viene proposta di effettuare l'overclock fino ad oltre 1GHz (io mi sono fermato a 900 MHz senza troppi problemi)

L'altro aspetto carino e' la semplicita' di configurazione della rete sia cablata che WiFi

L'unico problema reale che ho riscontrato e' stato al momento di inserire (a sistema operativo avviato) il dongle USB della scheda di rete WiFi...il sistema ha crashato senza possibilita' di recupero ed al successivo riavvio il file system era (ovviamente) corrotto

Mandelbrot con Processing+Android

Per mettere alla prova quanto appreso dal post precedente un classico, Mandelbrot
Il programma e' eseguito interamente sul telefono Android dopo essere stato compilato con Processing

Screenshot di Android

Il tempo di esecuzione e' inferiore ai 3 secondi e mezzo sul Samsung Next Turbo

-----------------------------------------
int larghezza = 200;
int altezza = 200;

float re_min = -2.0;
float im_min = -1.2;
float re_max = 1.0;
float im_max = 1.2;
int iterazioni = 255;

float a,b,x,y,x_new,y_new;
int i,j,k;
  
float re_factor=(re_max-re_min);
float im_factor=(im_max-im_min);

void setup() {
  size(200,200);
  background(0,0,0);
  stroke(255);
}

void draw() {
   for (i=0;i<altezza;i++)
    {
      for(j=0;j<larghezza;j++)
      {
        a = re_min+(j*re_factor/larghezza); 
        b = im_min+(i*im_factor/altezza);
   
        x = 0;
        y = 0;

   
        for (k=0;k<iterazioni;k++)
          {
          x_new = (x*x)-(y*y)+a;
          y_new = (2*x*y)+b;
          if (((x_new*x_new)+(y_new*y_new))>4)
             {
             if (k%2 == 0)  point(i,j);
             break;
             }
           x = x_new;
           y = y_new;
           }
  
       }
    }
        
}

Processing ed Android

Con Processing e' possibile sviluppare applicazioni per Android senza la necessita' di utilizzare il metodo tradizionale in Java

Per settare Processing ad compilare per Android si deve prima di tutto avere un SDK Android funzionante ed avere installato installate le API 10 (le altre, sia superiori che inferiori vengono ignorate)

a questo punto si puo' installare Processing 2.0 dal sito di riferimento. Una volta installato si deve cliccare sul menu a discesa nell'angolo in alto a sinistra (dove nell'immagine sottostante si legge Android). Si sceglie quindi Add Mode e si sceglie Android

Al termine dell'installazione viene richiesta la directory di installazione di Android SDK.
Fatto.
A questo punto si puo' collegare il telefono Android via cavo (ovviamente gia' settato in Debuggin Mode come si solito si fa per lo sviluppo) e lanciando gli skecth il risultato sara' visibile sullo schermo del telefono

Xively su Linux/Raspberry

Quanto visto per l'Arduino puo' essere ripetuto anche per un calcolatore che monta Linux (come per esempio Raspberry)

In questo caso verra' impiegato Python per dialogare con Xively come descritto a questo tutorial
Prima di lanciare lo script si devono eseguire i seguenti comandi che impostano Python e scaricano la libreria Xively per Python

$ sudo apt-get install git
$ sudo apt-get install python-setuptools 

$ sudo easy_install pip 

$ sudo pip install virtualenv
$ mkdir xively_tutorial 

$ cd xively_tutorial
$ virtualenv .envs/venv
$ source .envs/venv/bin/activate
$ pip install xively-python
terminata la configurazione si puo' lanciare il seguente script in Python che invia Xively i dati sul carico di lavoro. Come nel caso precedente si devono eseguire delle personalizzazione sulla base delle propri settaggi del device su Xively inserendo la chiave, il feed_id ed il nome del feed (vedi righe evidenziate in giallo)
--------------------------------------------------------------
#!/usr/bin/env python

import os
import xively
import subprocess
import time
import datetime
import requests

# extract feed_id and api_key from environment variables
FEED_ID = 302563049
API_KEY = "KPpjdurjzx9jVhp8PwpMCd6byMSatfcKuOu1CHJbdDkxXrI4"
DEBUG = "true"

# initialize api client
api = xively.XivelyAPIClient(API_KEY)

# function to read 1 minute load average from system uptime command
def read_loadavg():
  if DEBUG:
    print "Reading load average"
  return subprocess.check_output(["awk '{print $1}' /proc/loadavg"], shell=True)

# function to return a datastream object. This either creates a new datastream,
# or returns an existing one
def get_datastream(feed):
  try:
    datastream = feed.datastreams.get("load_avg")
    if DEBUG:
      print "Found existing datastream"
    return datastream
  except:
    if DEBUG:
      print "Creating new datastream"
    datastream = feed.datastreams.create("load_avg", tags="load_01")
    return datastream

# main program entry point - runs continuously updating our datastream with the
# current 1 minute load average
def run():
  print "Starting Xively tutorial script"

  feed = api.feeds.get(FEED_ID)

  datastream = get_datastream(feed)
  datastream.max_value = None
  datastream.min_value = None

  while True:
    load_avg = read_loadavg()

    if DEBUG:
      print "Updating Xively feed with value: %s" % load_avg

    datastream.current_value = load_avg
    datastream.at = datetime.datetime.utcnow()
    try:
      datastream.update()
    except requests.HTTPError as e:
      print "HTTPError({0}): {1}".format(e.errno, e.strerror)

    time.sleep(10)

run()