Pebble Time tearing

PS dopo una decina di giorni mi sono accorto che il problema persiste (meno di prima ma persiste) e non sembra legato alla flat del cavo. Lo schermo infatti si aggiorna solo premendo il pulsante in basso a destra...forse un problema software??? non e' possibile saperlo perche' non posso aggiornare il firmware

Livello di difficolta' : 1/5

Io amo Pebble Time per i seguenti motivi

1) la batteria dura ben oltre una settimana ed il cavo di ricarica ad aggancio magnetico e' comodissimo

2) Oramai su Ebay si trovano in offerta a circa 10 euro (basta aspettare)

3) Esiste GadgetBridge


Il problema e' che ogni tanto lo schermo si corrompe fino a che viene fatto il refresh manualmente premendo i tasti...negli ultimi tempi il fenomeno stava diventando molto frequente e fastidioso

Ho scoperto su internet che e' un problema comuni ai Pebble (indipendentemente dal modello) ed e' legato alla flat di connessione tra la scheda madre e lo schermo..fortunatamente si puo' facilmente riparare. Aprire il Pebble e' semplice...basta avere il giusto cacciavite. Dopo di cio' si deve rimuovere il coperchio con calma perche il sistema di vibrazione e' incollata alla cover e deve essere staccato prima di alzare completamente il coperchio..Meglio spengere il Pebble prima di operare

Dopo di cio' si puo' inserire uno spessore di carta per schiacciare in sede la flat (vedi la differenza tra le due foto)

Ricomposto il tutto lo schermo e' tornato a funzionare

questo invece un video non di mia produzione

Mandelbrot su Pebble

Visto che sono riuscito ad installare SDK Pebble perche' non provarlo con un classico??

Per il codice mi sono basato su altro esempio di Mandelbrot su Pebble presente su GitHub (peraltro fatto molto meglio del mio)

La gestione dello schermo non e' banalissima perche' e' presente una gerarchia di livelli sovrapposti.

Una cosa significativa: non e' possibile avere dati di debug in formato float (non ne capisco il motivo ma e' cosi')

---------------------------------------------
#include <pebble.h>

static Window *schermo;
static Layer *render_layer;

static void disegna(Layer *layer, GContext *ctx)
{
float re_min = -2.0;
float im_min = -1.2;
float re_max = 1.0;
float im_max = 1.2;
int r = 0;

int itera = 40;
int xres=0;
int yres=0;

float a,b,x,y,x_new,y_new;
int i,j,k;

GRect layer_bounds = layer_get_bounds(layer);

xres=layer_bounds.size.w;
yres=layer_bounds.size.h;

a = 0.0;
b = 0.0;
x_new = 0.0;
y_new = 0.0;

float re_factor = (re_max-re_min);
float im_factor = (im_max-im_min);

// scrive messaggi di debug che possono essere letti in shell con il comando
// pebble logs
APP_LOG(APP_LOG_LEVEL_DEBUG,"WIDTH=%d HEIGHT=%d",xres,yres);

for (i=0;i<yres;i++)
    {
    a = re_min+(i*re_factor/yres);
    for (j=0;j<xres;j++)
{

b = im_min+(j*im_factor/xres);
x = 0.0;
y = 0.0;
//APP_LOG(APP_LOG_LEVEL_DEBUG,"X=%d Y=%d",j,i);
for (k=1;k<itera;k++)
{
x_new = (x*x)-(y*y)+a;
y_new = (2*x*y)+b;
if (((x_new*x_new)+(y_new*y_new))>4)
   {
   r = k%2;
   //APP_LOG(APP_LOG_LEVEL_DEBUG,"K=%d R=%d",k,r);
   if (r == 1)
{
GPoint punto = GPoint(j,i);
//window_set_backgroung_color(&windows,GColorBlack);
graphics_draw_circle(ctx,punto,1);
}
   break;
   }
x = x_new;
y = y_new;
}
}
    }

}

static void carica_schermo(Window *window)
{
APP_LOG(APP_LOG_LEVEL_DEBUG,"CARICA SCHERMO");
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_bounds(window_layer);
render_layer = layer_create(bounds);
layer_set_update_proc(render_layer,disegna);
layer_add_child(window_layer, render_layer);
}

static void scarica_schermo(Window *window){
}

static void init(void){
APP_LOG(APP_LOG_LEVEL_DEBUG,"INIT");
schermo = window_create();
#ifdef PBL_SDK_2
window_set_fullscreen(schermo,true);
window_set_backgroung_color(schermo,GColorWhite);
#endif

window_set_window_handlers(schermo,(WindowHandlers){
   .load = carica_schermo,
   .unload = scarica_schermo,
   });
const bool animated=true;
window_stack_push(schermo,animated);
}

static void deinit(void)
{
window_destroy(schermo);
}

int main(void) {
  APP_LOG(APP_LOG_LEVEL_DEBUG,"MAIN");
  init();
  APP_LOG(APP_LOG_LEVEL_DEBUG,"%p",schermo);
  app_event_loop();
  deinit();
}
---------------------------------------------

e visto che ci siamo perche' non provare a pubblicarla sullo store di Pebble (non e' necessario un pagamento)

ed infine la prova reale (tempo di calcolo circa 6 secondi)

Pebble SDK su Centos 7

Colpo di genio del nuovo anno : comprare un Pebble (usato) e scoprire un paio di giorni dopo che Pebble e' stato acquistato da FitBit e che quindi dismetteranno tutto il supporto compreso il cloud !!

Mi sono quindi affrettato almeno a configurarmi l'SDK di Pebble prima che diventi non disponibile

Le istruzioni riportate sul sito sono per distribuzioni Linux basate su apt ma ho provato lo stesso l'installazione su Centos
Il pacchetto dell'SDK 64 di Pebble si scarica da qui

-----------------------------
mkdir ~/pebble-dev/
cd ~/pebble-dev/
tar -jxf ~/Downloads/pebble-sdk-4.5-linux64.tar.bz2
echo 'export PATH=~/pebble-dev/pebble-sdk-4.5-linux64/bin:$PATH' >> ~/.bash_profile
. ~/.bash_profile
-----------------------------

si deve poi installare pip ed virtualenv di Python (e nessun problema)

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

cd ~/pebble-dev/pebble-sdk-4.5-linux64 

virtualenv --no-site-packages .env 

source .env/bin/activate 

pip install -r requirements.txt 

deactivate

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

in questo caso deactivate mi ha dato errore ma non ha creato problemi per i passi futuri

Vengono scaricati diversi pacchetti ma non sono riuscito a trovare una opzione per configurare il proxy server.

Si devono poi installare le dipendenze per il compilare. Nessun problema per installare libpixman e libsdl (peraltro gia' presenti)  ma su Centos non esiste un pacchetto precompilato per la libreria libfdt e si deve quindi partire dai sorgenti.

Si scarica il file tgz da GitHub e si lancia

make

nella sottodirectory libfdt viene creata la libreria libfdt-1.3.0.so. Il problema e' che l'emulatore di Pebble ricerca la libreria libfdt.so.1. Quindi e' necessario o rinominare il file oppure creare un symlink con il nome richiesto.
Usanso make install non funziona e quindi ho copiato a mano la libreria compilato in /usr/lib e /usr/lib64

L'installazione delle applicazioni sul telefono non avviene mediante il cavo, che di fatto e' funzionale solo alla ricarica, ma passa attraverso il telefono a cui e' accoppiato l'orologio

Si deve quindi attivare il pulsante a scorrimento. Non funziona con il telefono in modalita' HotSpot ma in associazione ad un vero e proprio Access Point

per creare un nuovo progetto (Javascript o C) si usa
pebble new-project [--simple] [--javascript] [--worker] [--rocky] NAME

che genera un template su cui iniziare a lavorare

pebble build per compilare

ed infine per installare si usa

pebble install --phone IP (per il telefono)

pebble install --emulator basalt (per l'emulatore. i nomi dei vari dispositivi sono riportati qui sotto)

Emulatore in esecuzione

Per interagire con l'emulatore si usano i tasti freccia

freccia su = Up

freccia giu' = Down

freccia destra = Select

freccia sinistra = Back

Per visualizzare i log si usa

pebble log

per fare piu' in fretta si puo' fare
pebble wipe & pebble build & pebble install --emulator diorite --logs