#PEBBLE Emulador in web IDE for Pebble #CloudPebble

Hola!

In the last few months I’ve not dedicated much time to the Pebble. Today I get back some projects and I find a cool new feature in the Web Ide, we now have an emulator!

Note: Remember that the friends of Pebble have SDK for Windows.

I get used to deploy apps directly to my smartwatch using an Android or iPhone, and now I have the chance to use an emulator on the web (quite attractive). If you wonder how the emulator looks, as it looks pretty good.

When you flip the app in the emulator, then you have full control over it. Here is an example

This is a great feature! However, you must keep in mind a couple of things

· This emulator is great for apps that do not have need for a Smartphone, if you use services of the SmartPhone because… you have to find an alternative solution

· In the image above we can see that we can simulate certain features of the Smartphone as a battery, BlueTooth, etc.

· The emulator also allows you to interact with the keyboard using the X, Y, Z keys to click in the right area and shift-X, shift – and shift-Z to click in the left side

So well, since January of 2015 we have a feature very good if you develop apps for Pebble in Windows environments.

Saludos @ Madrid

/El Bruno

References

– CloudPebble, https://cloudpebble.net/

Advertisements

#PEBBLE Emulador en el IDE web de Pebble #CloudPebble

Hola!

Estos últimos meses tenía abandonado al Pebble. Hoy me toca ponerlo al día y me encuentro con la novedad de que en el IDE Web que nos da Pebble, ahora tenemos un emulador!

Nota: Recordemos que los amigos de Pebble no tienen SDK para Windows.

Pues eso, ahora además de poder desplegar las apps directamente a nuestro smartwatch utilizando un Android o iPhone, tenemos la posibilidad de utilizar un Emulador en la web que es bastante atractivo. Si te preguntas como se ve el emulador, pues el mismo se ve bastante bien.

Cuando despliegas la app en el emulador, luego tienes control total sobre la misma. Veamos un ejemplo

2015 06 23 Pebble Emulator

Es una excelente funcionalidad! Ahora bien, hay que tener en cuenta un par de cosas

– Este emulador es genial para apps que no tengan necesidad de un Smartphone, si utilizas servicios propios del SmartPhone pues … tienes que buscar una solución alternativa

– En la imagen superior podemos ver que podemos simular ciertas funcionalidades del Smartphone como la batería, el bluetooth, etc

– El emulador también permite interactuar con el teclado con las teclas X, Y, Z para clic en la zona derecha y shift-X, shift-Y, shift-Z para clic en la zona izquierda

Así que bien, desde enero del 2015 tenemos una funcionalidad buenísima si desarrollas apps para Pebble en entornos Windows.

Saludos @ Madrid

/El Bruno

References

– CloudPebble, https://cloudpebble.net/

[#PEBBLE] HowTo: Get information in a SmartPhone and send it to the #Pebble

Hello!

In the post from 2 days ago, I put a small example on how to use the JS files in the world of development of Pebble. This files are executed in the smartphone that is associated with the pebble and today, I’m going to extend the previous example to show how information can be sent from the JS to the Pebble.

On the above example, I modified the JS with the following changes

-According to the option that is received from the Pebble, a specific value is stored in the variable selectedButton (line 9)

-At the end of the evaluation, be sends this value to the Pebble using Pebble.sendAppMessage (line 27). It defines message dictionary item is used and we also have the possibility of using callbacks to process the errors and the Ok of the function.

In the file C have the following changes

-In line 95 is subscription to input in the function in_received_handler messages

-Each one of the elements which are received in the dictionary for the exchange of messages processed this function (line 11)

-Finally in line 28, it evaluates the message and displays the information that is received from the Pebble

Reference: https://elbruno.com/2014/10/01/pebble-how-to-use-a-js-file-from-the-pebble/

Greetings @ Home

The Bruno

image image image Google

[#PEBBLE] HowTo: Obtener informacion desde un SmartPhone y enviarla hacia el #Pebble

Hola!

En el post de hace 2 días, puse un pequeño ejemplo sobre cómo se utilizan los archivos JS en el mundo de desarrollo de Pebble. Esto archivos se ejecutan en el smartphone asociado con el pebble y hoy, voy a extender el ejemplo anterior para mostrar como se puede enviar información desde el JS hacia el Pebble.

Sobre el ejemplo anterior he modificado el JS con los siguientes cambios

– De acuerdo a la opción que se recibe desde el Pebble, se almacena un valor específico en la variable selectedButton (línea 9)

– Al final de la evaluación, se envía este valor hacia el Pebble utilizando Pebble.sendAppMessage() (línea 27). En el mismo se define que item del diccionario de mensajes se utiliza y además tenemos la posibilidad de utilizar callbacks para procesar los errores y el Ok de la funcion.

En el archivo C tenemos los siguientes cambios

– En la línea 95 se realiza la suscripción a los mensajes de entrada en la función in_received_handler

– Esta función (línea 11) procesa cada uno de los elementos que se reciben en el diccionario de intercambio de mensajes

– Finalmente en la línea 28, se evalua el mensaje y se muestra la información que se recibe desde el Pebble

Referencia: https://elbruno.com/2014/09/30/pebble-como-utilizar-un-archivo-js-desde-el-pebble/

Saludos @ Home

El Bruno

image image image Google

[#PEBBLE] How to use a JS file from the pebble

Hello!

One of capabilities makes the Pebble, powerful is the ability to execute JS files. This has a bit because it is not actually the smart watch that executes the JavaScript code. It runs on the smartphone which is paired with the pebble. Then to communicate the pebble and the smartwatch have an array of messages in format dictionary (key / value), that we can use for this.

The following example shows how according to the hold button on the Pebble, register a debug message from the Pebble and sent a message to the JS with the information of the button pressed. In the JS, this message will be processed and recorded a new debug message.

1 I think an example project from Cloudpebble.net with the template for “Button Sample”

2. in the settings of the project, add a new Message Key called “exchangeData”

image

3. inside of the main code we modified the button_click.c file with the code-sharing at the end. In it we can see a specific section specific to create a Tuple (key / value) which is which we will then send to the JS. Then click, we send a different message for each button.

4. in the main project add a new file type JavaScript file.

image

Important the file always has to be “pebble-js-app.js”

5. in the JS file and C we modified with the following code

 

 

6. We compile, deploy, and activate the logs

image

The content we will be similar to the following lines, after pressing the button UP, SELECT and DOWN

[PHONE] pebble-app.js:?: {'runhost client uuid' = 00000000-0000-0000-0000-000000000000}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:LAUNCHING
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:3 JS4 Pebble.addEventListener ready 
[PHONE] pebble-app.js:?: {'runhost client uuid' = 12501411-9e26-4ac7-bf1c-f39baef5580c}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:READY-RUNNING
[DEBUG] button_click.c:27: click UP
[PHONE] pebble-app.js:?: {'runhost client uuid' = 00000000-0000-0000-0000-000000000000}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:PREVIOUSLY-RUNNING
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:9 {"exchangeData":2}
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:16 Button UP
[DEBUG] button_click.c:21: click SELECT
[PHONE] pebble-app.js:?: {'runhost client uuid' = 00000000-0000-0000-0000-000000000000}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:PREVIOUSLY-RUNNING
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:9 {"exchangeData":1}
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:12 Button SELECT
[DEBUG] button_click.c:33: click DOWN
[PHONE] pebble-app.js:?: {'runhost client uuid' = 00000000-0000-0000-0000-000000000000}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:PREVIOUSLY-RUNNING
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:9 {"exchangeData":3}
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:20 Button DOWN

If you look at the Pebble file (.)(C), we will see that it sends a different message for each click of each button, creating a dictionary and processing this with app_message_outbox_begin () and app_message_outbox_send () (lines 11-18).

Then within the JS, the reception of the message is processed with a listener at the event of type “appmessage” (line 6) and displays a different message according to the content of the message received from the Pebble.

Within these lines of debug, we can see how the Debug “jumps” from the pebble to the smartphone and in each case the corresponding debug message is processed.

Reference: https://developer.getpebble.com/2/api-reference/group___app_message.html

Saludos @ Home

El Bruno

image image image Google

[#PEBBLE] Como utilizar un archivo JS desde el pebble

Hola!

Una de las capacidades que hace potente al Pebble, es la capacidad de ejecutar archivos JS. Esto tiene un poco de trampa porque en realidad no es el smart watch el que ejecuta el código JavaScript. El mismo se ejecuta en el smartphone que está emparejado con el pebble. Luego para comunicar el pebble y el smartwatch tenemos un array de mensajes en formato diccionario (clave y valor), que podemos utilizar para esto.

El siguiente ejemplo muestra cómo de acuerdo al botón presionado en el Pebble, se registrará un mensaje de debug desde el Pebble y se enviará un mensaje al JS con la información del botón presionado. En el JS se procesará este mensaje y se registrará un nuevo mensaje de debug.

1. Creo un proyecto de ejemplo desde Cloudpebble.net con la plantilla para “Button Sample”

2. En las settings del proyecto, agrego una nueva Message Key llamada “exchangeData”

image

3. Dentro del código principal modificamos el archivo button_click.c con el código compartido al final. Dentro del mismo podemos ver una sección específica específica para crear un Tuple (clave / valor) que es el que luego enviaremos al JS. Luego en el click , enviamos un mensaje diferente para cada botón.

4. En el proyecto principal agregamos un nuevo archivo de tipo JavaScript file.

image

Importante el nombre del archivo SIEMPRE TIENE QUE SER “pebble-js-app.js”

5. En el archivo JS y en el C modificamos con el siguiente código

6. Compilamos, desplegamos y activamos los logs

image

El contenido que tendremos será similar a las siguientes líneas, después de presionar el boton UP, SELECT y DOWN

[PHONE] pebble-app.js:?: {'runhost client uuid' = 00000000-0000-0000-0000-000000000000}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:LAUNCHING
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:3 JS4 Pebble.addEventListener ready 
[PHONE] pebble-app.js:?: {'runhost client uuid' = 12501411-9e26-4ac7-bf1c-f39baef5580c}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:READY-RUNNING
[DEBUG] button_click.c:27: click UP
[PHONE] pebble-app.js:?: {'runhost client uuid' = 00000000-0000-0000-0000-000000000000}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:PREVIOUSLY-RUNNING
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:9 {"exchangeData":2}
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:16 Button UP
[DEBUG] button_click.c:21: click SELECT
[PHONE] pebble-app.js:?: {'runhost client uuid' = 00000000-0000-0000-0000-000000000000}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:PREVIOUSLY-RUNNING
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:9 {"exchangeData":1}
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:12 Button SELECT
[DEBUG] button_click.c:33: click DOWN
[PHONE] pebble-app.js:?: {'runhost client uuid' = 00000000-0000-0000-0000-000000000000}:{'webapp uuid' = 1fb036ee-6679-4978-a22d-33dc75b0f626}: ++_JS_LIFECYCLE_++:PREVIOUSLY-RUNNING
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:9 {"exchangeData":3}
[PHONE] pebble-app.js:?: JavaScript_Sample_04__1/pebble-js-app.js:20 Button DOWN

Si analizamos el archivo de Pebble (.C), veremos que el mismo envía un mensaje diferente para cada click de cada boton, creando un diccionario y procesandolo con  app_message_outbox_begin() y app_message_outbox_send() (líneas 11 a 18).

Luego dentro del JS la recepción del mensaje se procesa con un listener en el evento de tipo “appmessage” (línea 6) y se muestra un mensaje diferente de acuerdo al contenido del mensaje recibido desde el Pebble.

Dentro de estas líneas de debug, podemos ver como el Debug “salta” del pebble al smartphone y en cada caso se procesa el mensaje de debug correspondiente.

 

Referencia: https://developer.getpebble.com/2/api-reference/group___app_message.html

Saludos @ Home

El Bruno

image image image Google

[#PEBBLE] Send #Lync2013 messages to your Pebble

Hello!

The work with distributed teams is more than interesting, it relies on having Lync 2013 all the time online and see how many people respect the States Available, Busy, or Away. It is very likely that if these in front of the computer and a colleague of Australia does not start a conversation, Miss the opportunity to speak with that person until the following day.

One option is to have a Lync in your Windows Phone 8, however if you have a Pebble, and access to Microsoft Lync 2013 SDK, you can create an app for console that sends a notification to your Pebble whenever someone starts a conversation with you in Lync.

Bonus: you can see a couple of interesting examples of LyncSdk in this link .

For this we must have attached our Pebble with your computer (as I explained here) and then in a console app, we implement the following code.

It shows as connected to the Pebble (line 4) once the app subscribes to the new conversation event. The same (line 11) Gets the name of the participants of the conversation and a message is sent to the Pebble with this information.

As always a (poor quality) video accompanies the example.

PebbleLync

Download: http://www.microsoft.com/en-us/download/confirmation.aspx?id=36824

Saludos @ La Finca

El Bruno

image image image Google

[#PEBBLE] Envia mensajes de #Lync2013 a tu Pebble

Hola!

Lo de trabajar con equipos distribuidos es más que interesante, se basa en tener Lync 2013 todo el tiempo online y ver cuantas personas respetan los estados Available, Busy o Away. Es muy probable que si no estas delante del ordenador y algún compañero de Australia inicia una conversación, pierdas la oportunidad de volver a hablar con esa persona hasta el día siguiente.

Una opción es tener Lync en tu Windows Phone 8, sin embargo si tienes un Pebble, y acceso a Microsoft Lync 2013 SDK, puedes crear una app de consola que envíe una notificación a tu Pebble cada vez que alguien inicia una conversación contigo en Lync.

Bonus: puedes ver un par de ejemplos interesantes sobre LyncSdk en este link.

Para esto tenemos que tener conectado nuestro Pebble con el ordenador (como expliqué aquI) y luego en una app de consola, implementamos el siguiente código.

El mismo muestra como una vez conectados al Pebble (línea 4) la app se suscribe al evento de nueva conversación. En la misma (línea 11) se obtiene el nombre de los participantes de la conversación y se envía un mensaje al Pebble con esta información.

Como siempre un video (de mala calidad) acompaña al ejemplo.

PebbleLync

Download: http://www.microsoft.com/en-us/download/confirmation.aspx?id=36824

Saludos @ Home

El Bruno

image image image Google

[#PEBBLE] Working with accelerometer

Hello!

Finally, this week I spend a couple of days playing with Visual Studio 2013 and C++ for Pebble. One of the topics I have pending is to learn is how to work with the motion sensor API.

The first thing we have to bear in mind, is that like the clock, accelerometer works as a service (link). We should subscribe to a specific event in the Init() in order to process the data, and then get data that the sensor sends us. In the following example, we see how in lines 30 and 31, he is subscribing to the event of the motion sensor and then the timer_callback sends this data as a LOG to the console.

If tomorrow I implement it in full mode, I show an example of the finished app.

Saludos @ La Finca

El Bruno

image image image Google

[#PEBBLE] Trabajando con el sensor de movimiento

Hola!

Por fin, creo que esta semana podré dedicar un par de días a programar un poco con Visual Studio 2013 para el Pebble. Uno de los temas que tengo pendiente es ver como funciona la API del sensor de movimiento.

Lo primero que tenemos que tener en cuenta, es que al igual que el reloj, el sensor de movimiento funciona como un servicio (link). Es decir, debemos suscribirnos al mismo en Init() para poder procesar los datos, y luego con un timer procesar los datos que nos envía el sensor. En el siguiente ejemplo, podemos ver cómo en las líneas 30 y 31, se realiza la suscripción al evento del sensor de movimiento y luego el timer_callback envía estos datos como un LOG a la consola.

Si mañana lo implemento en modo completo, muestro un ejemplo de la app terminada.

Saludos @ Home

El Bruno

image image image Google