Blast Lab @blastlabltd

Blast Lab Ltd. is a R&D company focused on building hardware and software. We are mainly interested in connected devices, internet of things, mobile application development, Bluetooth v4.0 BLE

[blastlab]

An alternative approach to beacons at supermarkets

So far most of the debate about beacons has revolved around its use in the context of apps installed on mobile devices of consumers. This is mainly because massive attention is directed at marketing benefits, push notifications in particular, of deploying BLE technology.

However, beacons can also be used at supermarkets for gathering data from monitoring the movement of shopping carts and hand baskets, not visitors. In fact, there is a number of advantages related to such attitude.

When data is the key

First of all, predominant goal for choosing this option is to gain detailed insights into actual behavior of consumers in real-time. Not socio-demographic data. Why? Once the customer is in the store, it is crucial to understand which sections are of interest to him, where he stops and for how long and to identify the „black holes” in order to get a better understanding of the customer journey. On the basis of these insights, store management is able to create heatmaps  in order to optimally re-design the store layout and activate less frequently visited areas.

Anonymity

One of the greatest advantages of this approach is data anonymity. The system follows only how the baskets and carts are used. In other words, it tracks how fast the cart is moving, which route it takes and where and how long stops take place. Without linking this with private data or any kind of customer identification.

So how does it work?

From a technical point of view, a little beacon is attached to a shopping cart or basket. It is then detected by stationary BLE beacons installed in the shopping area. Stationary beacons gather data from basket beacons and send them directly to servers.

Customers do not need to download any app, which is a common doubt expressed by retail chains. If the primary goal for them is to gather detailed data, not necessarily to communicate with customers, this is a viable option without certain drawbacks that are characterized by app-based solutions.

In fact, Blast Lab’s approach to BLE technology in which beacons communicate with each other can be similarly applied to hospitals, rest-homes, kindergartens, day-care and many more. We will cover this topic more in depth in the upcoming posts.

image courtesy of stockimages at FreeDigitalPhotos.net

[blastlab]

Beacons: thoughts on privacy

As we live in an increasingly connected world and BLE technology is becoming more widespread, naturally some issues related to privacy arise. We believe that this needs to be constantly addressed to avoid misconceptions.

First of all, it doesn’t really matter if beacons collect or do not collect data. It is true that most beacons only broadcast signal and it’s the mobile app that gathers all the information. But this aspect is irrelevant since, at the end of the day, the retailer has the data about us: no matter the channel.

What kind of data do we give to brands and retailers? Generally, we are talking about things like the way we move around the store, time spent in particular sections and our product preferences (eg.: through a shopping list, in-app product search or pre-defined preferences).

This data is something we, as users, give in return for high degree of marketing personalization. Crucial factors which increase likelihood of a successful beacon-based platform implementation for retailers and brands basically revolve around those 3 issues:

1)      Clear value added: In order for users to download the app and use it, companies need to give their visitors very clear reason. In the accumulation of apps (we can basically say that there is an app for everything now), they need to receive something valuable for opting in. Be it nice discounts, freemiums, additional loyalty points to name just a few. In short: it has to be worthwhile.

2)      Transparency: it is crucial that brands explicitly inform at the very beginning that they collect data and what kind of data is gathered. This is extremelely important as making users aware of that fact renders companies fair and honest and respect is everything here. This also means that consumers need to be able to say no.

3)      Don’t spam: beacons enable location-based, highly customized, real-time proximity marketing which can be a great thing for both parties lifting marketing to a whole new level. However, the key is to understand that visitors will not like to be bombarded with one notification after another. All the shopping malls and brands we have talked to understand this very well: there is no doubt that anyone would just simply delete the app if it annoyed us. And we don’t like to give second chances to things like that so there probably won’t be any room for asking users for forgiveness.

 There’s no doubt about the fact that retailers need to make sure that they ask users for their consent to collect data and sent notifications in exchange for highly personalized service (protection of that data should be beyond any discussion). But most of them state it very clearly and always give a possibility to opt out. This is voluntary for users and the buzz created around this issue seems a little bit exaggerrated making beacons and BLE technology unfairly evil. Consider all the tracking (or surveillance) technologies that have been in use for some time now without user’s awareness (not mentioning obtaining consent): passive WiFi monitoring, facial recognition and other. With nothing in return.

[blastlab]

Micro-location and indoor navigation in public administration: smart citizens in smart cities

A lot has been said about the use of Bluetooth Low Energy technology in retail with benefits such as turn-by-turn directions, personalized, location-dependent marketing communication, gathering data regarding customer journey etc. Let’s not limit ourselves, however, merely to commercial, profit-oriented use cases.

We are also all familiar with uses of Bluetooth Low Energy technology in assisting disabled, deaf or visually impaired people in accessing buildings, integrating and digitalizing all the processes in hospitals from patient’s perspective as well as the staff, management and equipment one. In addition, an impressive numer of museums already use beacons to power up their audioguides.

Recently, during our talks with various organizations, we have been faced with a slightly different stakeholder in city areas: local governments and their issue on how to create more friendly public administration for residents in the digital world of smart cities.

Probably most of us have to or had to deal with blurry procedures when trying to done things like building permit or vehicle registration (it is worth noting that these procedures are very often not clearly understood by clerks as well). Very often we get frustrated just by thinking about what’s next: wandering around from counter to counter in order to receive information, staying in long queues, visiting again an office to deliver missing documents etc.

But there is a way to facilitate these processes and mitigate the hassle and frustration for citizens with BLE technology. Taking indoor navigation as a foundation, we can build a complete mobile platform which will essentially be a personal assistant to every resident equipped with a smartphone. The side result (important though!) would also be the streamline of the work of clerks who won’t need to devote so much time to explaining every visitor what, where, when and in which order to perform certain steps of a procedure.

So how can it work exactly? Here are some of our ideas:

 Smart app which, by typing in basic information regarding where we live and what  need to get done, would present us an entire procedure, step by step, with all the required documents in each phase, and where exactly we have to or can go to in order to complete it.

Remote booking of a place in queue or a visit from your smartphone so that one does not have to waste a lot of time at the office itself. The system could inform you in real-time about how the queue is proceeding in order for you to arrive at the office exactly on time.

Turn-by-turn, indoor navigation to particular counters or rooms according to our „citizen journey”, based on the steps that need to be undertaken in order to complete a certain procedure.

Integration of the BLE technology with GPS in order to direct citizens to remote public administration building whenever a procedure requires visits in dispersed offices.

 Automatic update of the steps order or required documents in the procedure whenever the law changes.

Real-time notifications in the app regarding basic information like opening hours, and any changes to procedures which have already been commenced by us.

Personalized, accessible (by citizens) account in the app for every citizen where all the information would be stored. The systems would inform clerks that a particular person has just entered the building (or is approaching) and could prepare all the necessary documents in advance.

Obviously, implementing such solution requires a lot of initial work from the entire office staff, especially in terms of content management, in order to guarantee that all the information in the system is up-to-date and complete. Because of this, there is a great risk that the staff will be reluctant to the deployment as this equals to a little revolution in their worklife. There is no doubt about that. Nevertheless, clear benefits for citizens prevail as we talk about this idea with people.  Well, it doesn’t seem like rocket science but we strongly believe that it would make our lives as residents of smart cities a lot easier. What do you think about that?

[blastlab]

A reminder from #InfoShare where our #CTO Bartosz presented a review about #BT4.0 tech in aspect of building own device

[blastlab]

Our CTO @Bartosz Reichel present a short review of #BLE solutions in the context of software on the #InfoShare 2015 Conference in Gdańsk.

Here (http://www.slideshare.net/BartoszReichel/bluetooth-49399835) you can see slides from his seminar. 

[blastlab]

Security in IoT

Sometimes low-level connecting to devices, for example in the context of Internet of Things (IoT), needs to be secured, especially when data we are sending is sensitive...

In IoT some of the data is sensitive and usually is exchanged in the communication by regular sockets. Such data can be easily intercepted and read by third party. IoT is about data, so leaving it unsecured can cause problems. Information about our fitness are not so sensitive. However when with our mobile device we are able to control thermostats, heating or other component of our smart home, the security is a more important aspect. With help comes an encrypted communication by SSL. Below is quick tutorial on how to create in Java, a self-signed certified SSL connection.

Self-signed certificates are not verified by third-party, so we can use them only in case we are sure they are authentic. In this case, when we are developing both parts - the client and the server - this is not a problem.

Firstly, we have to generate certificate for server side. We use a keytool, which is build in JDK:

keytool -genkey -alias serverca -keyalg RSA -keystore keystore.jks -validity 30 keytool -export -alias serverca -file server.cer -keystore keystore.jks

After executing this commands and filling all required data (passwords for keystore, key and certificate details) two files should be generated:

keystore.jks with both public and private key for our server - don't share it!

server.cer with public certificate.

Now we need to put keystore in server app's resource files and certificate in client app's resources.

Secondly we have to create second pair of keystore and certificate for client with similar commands, only change alias for key and output certificate file name. This time keystore should be put in client's resources and certificate in server's resources.

This step can be ommited if you don't want to validate your clients on connection. Validating only server's certificate is common situation in for example HTTPS connection from web browser.

Last thing to do is to create SSLServerSocket and SSLSocket in out applications, but with SSLContext that is aware of ours keystores and certificates. To do this we need to call SSLContext.init() with proper parameters, but you can use simple helper class that we developed to not reinventing the wheel. Just load .jks and .cer resources to File() objects, set them to SSLContextInitializer, and call SSLContextInitializer.initContext(SSLContext).

You don't need to specify both keystore and list of certificates, common situation is accepting connections as SSLServerSocket without clients' authorization and connecting to such server without own certificate.

Full working demo with more about generating, checking and converting certificates is available on our github profile.

[blastlab]

Performance tests of the Parse.com

A while ago we've prepared the performance tests of the Parse mobile app backend. Check out our results and see Parse in action. 

We have configured our server to periodically run 2 very simple scripts. Every hour it makes 4 different Parse.com actions:

A big query - select ~250 records from database.

Small queries - select one record 8 times (a different one every time).

A file download - download one small file (~537780 bytes).

Many concurrent queries - select one record 35 times in the same moment.

The first shows how fast we can obtain a list of over 200 elements from database. The second gives the average time to get a single object from database. The third is to calculate the average download speed, which is very important to us. And the fourth reveals the time of getting single object when many users do this in the same time.

  The scripts were configured to run on our server for one week every hour. What we've got is shown below.

Average times:

Big query: 1306.56 ms

Small query (1 of 8): 475.84 ms

Concurrent query: 511.24 ms

Average file downloading speed is 208.80 kB/s.

We have also prepared another test to make the same requests but in changed order. The concurrent queries are made at the beginning to check their impact on the next queries. The test was configured to run exactly between two calls of the first one. These are the results:

Average times:

Big query = 933.45 ms

Small query (1 of 8) = 458.83 ms

Concurrent query = 640.57 ms

Average file downloading speed is 191.34 kB/s.

As you can see the test results differ from each other. It seems that the order of requests has a meaning. The first query takes longer, no matter what type of request you make. The next queries are faster. The time offset between tests execution was too small to influence the results (it was only 30 minutes).

Also the concurrent queries are slower than the ordered ones. This is something that we expected.

  In general the time results are not so bad, but what really scares us is the number of timeouts and file downloading speed. The Parse.com system seems to be very instable. We started the test at first because we've had experienced timeouts and unavailability of the dashboard a few times in short period of time (and nothing was mentioned on Parse.com status page).

You can have a look at the script files and the full results being attached to this article. The very important thing to say is that you should always compare your test results to Parse.com incident history. We did it and MOST OF THE LAGS AND TIMEOUTS IS NOT CONNECTED TO ANY REGISTRED INCIDENT! The history is stored at http://status.parse.com/

Another issue with Parse.com is refusing connections while uploading many files one by one. This is something we have NOT CONFIRMED yet but we would like to test it and will share the results for sure. You can read more here: https://www.parse.com/questions/batch-upload-of-images

We hope you found our adventures with Parse.com interesting and helpful. If you consider Parse.com as a backend for your mobile app you should probably read a short discussion on Stack Overflow: http://stackoverflow.com/questions/11283729/how-scalable-is-parse

We fully agree with Robert Charest saying:

'I know the question may be old, but wanted to provide my 2 cents for others out there who may be considering parse....

Under the simplest of scenarios, parse may work well. As soon as you need to scale up to more complex queries, I have personally found nothing but headaches.

Queries are limited to 1000 records. Initially, you may think this is not an issue, until you start dealing with sub queries, and realize weird data is returned because the sub query cuts records off without warning or error. (FYI, the default is 100 records unless you specify a limit up to 1000, so the problem is even worse if you are not paying attention).

For some strange reason there is a limit to the number of times you can issue a count query in a min. (and this limit appears to be really low). Be prepared to try and throttle your code so you don't hit this limit, otherwise errors are thrown.

Background Jobs do not run reliably. I have had a background job set to run every 5 min, and there are times it takes 20+ min before the job will kick in.

Lots of Timeouts. This is the one that gives me the most heartburn.

A. If you have a cloud function that takes a while to process, you have about 6 or 7 seconds to get it done or it will cut you off.

B. I get the feeling that there is a general instability with the system. Periodically, I run into issues which seems to last for about an hour or so where timeouts happen more frequently (and with relatively simple functions that should return immediately).’

Best regards!

[blastlab]

Grapedit - help again

This tool helped again! On some computers, the filters did not work out as we need. In this case, code snippet for c#

    public class SaveGraph     {                  [DllImport("ole32.dll")]         static extern int StgCreateDocfile([MarshalAs(UnmanagedType.LPWStr)]             string pwcsName, StgmConstants grfMode, uint reserved, out IStorage ppstgOpen);         //Code based on MSDA         /// <summary>         /// Save graph filter         /// </summary>         /// <param name="pGraph">pointer to graph filter</param>         /// <param name="wszPath">Path to save</param>         /// <returns></returns>         public int SaveGraphFile(IGraphBuilder pGraph, string wszPath)         {             const string wszStreamName = "ActiveMovieGraph";             int hr;             IStorage pStorage;             hr = StgCreateDocfile( wszPath,                 StgmConstants.STGM_CREATE | StgmConstants.STGM_TRANSACTED |                 StgmConstants.STGM_READWRITE | StgmConstants.STGM_SHARE_EXCLUSIVE,                 0, out pStorage);             if (hr < 0)             {                                 return hr;             }             IStream pStream;             hr = pStorage.CreateStream( wszStreamName,                 StgmConstants.STGM_WRITE | StgmConstants.STGM_CREATE | StgmConstants.STGM_SHARE_EXCLUSIVE,                 0, 0,  out pStream);             if (hr < 0)             {                 pStorage = null;                 return hr;             }             IPersistStream pPersist;             pPersist = (IPersistStream)pGraph;             hr = pPersist.Save(pStream, true);             pStream = null;             pPersist = null;             if (hr>=0)             {                 hr = pStorage.Commit(StgcConstants.STGC_DEFAULT);             }             pStorage = null;             return hr;         }     }     /*      * Code below based on pinvoke.net and msdn. Modified to comfortably benefited from it.      *      * WARNING: It should not be regarded as a complete and error-free implementation !      * Modifications only for the purpose of this sample      *      */     [Flags]     public enum StgmConstants : uint     {         STGM_READ = 0x0,         STGM_WRITE = 0x1,         STGM_READWRITE = 0x2,         STGM_SHARE_DENY_NONE = 0x40,         STGM_SHARE_DENY_READ = 0x30,         STGM_SHARE_DENY_WRITE = 0x20,         STGM_SHARE_EXCLUSIVE = 0x10,         STGM_PRIORITY = 0x40000,         STGM_CREATE = 0x1000,         STGM_CONVERT = 0x20000,         STGM_FAILIFTHERE = 0x0,         STGM_DIRECT = 0x0,         STGM_TRANSACTED = 0x10000,         STGM_NOSCRATCH = 0x100000,         STGM_NOSNAPSHOT = 0x200000,         STGM_SIMPLE = 0x8000000,         STGM_DIRECT_SWMR = 0x400000,         STGM_DELETEONRELEASE = 0x4000000     }     public enum StgcConstants : uint     {         STGC_DEFAULT = 0,         STGC_OVERWRITE = 1,         STGC_ONLYIFCURRENT = 2,         STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE = 4,         STGC_CONSOLIDATE = 8     }     [ComImport]     [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]     [Guid("00000109-0000-0000-C000-000000000046")]     public interface IPersistStream     {         [PreserveSig]         int GetClassID(out Guid pClassID);         [PreserveSig()]         int IsDirty();         [PreserveSig]         int Load([In, MarshalAs(UnmanagedType.Interface)] IStream pStm);         [PreserveSig]         int Save([In, MarshalAs(UnmanagedType.Interface)] IStream pStm, [In, MarshalAs(UnmanagedType.Bool)] bool fClearDirty);         [PreserveSig]         int GetSizeMax([Out] out UInt64 pcbSize);     }     [StructLayout(LayoutKind.Sequential)]     public struct FILETIME     {         public uint DateTimeLow;         public uint DateTimeHigh;     }     public struct STATSTG     {         [MarshalAs(UnmanagedType.LPTStr)]         public string pwcsName;         public int type;         public long cbSize;         public FILETIME mtime;         public FILETIME ctime;         public FILETIME atime;         public int grfMode;         public int grfLocksSupported;         public Guid clsid;         public int grfStateBits;         public int reserved;     }     [ComImport]     [Guid("0000000d-0000-0000-C000-000000000046")]     [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]     public interface IEnumSTATSTG     {         // The user needs to allocate an STATSTG array whose size is celt.         [PreserveSig]         uint         Next(         uint celt,         [MarshalAs(UnmanagedType.LPArray), Out]     STATSTG[] rgelt,         out uint pceltFetched         );         void Skip(uint celt);         void Reset();         [return: MarshalAs(UnmanagedType.Interface)]         IEnumSTATSTG Clone();     }     [ComImport]     [Guid("0000000b-0000-0000-C000-000000000046")]     [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]     interface IStorage     {         [PreserveSig]         int CreateStream(             /* [string][in] */ string pwcsName,             /* [in] */ StgmConstants grfMode,             /* [in] */ uint reserved1,             /* [in] */ uint reserved2,             /* [out] */ out IStream ppstm);         [PreserveSig]         int OpenStream(             /* [string][in] */ string pwcsName,             /* [unique][in] */ IntPtr reserved1,             /* [in] */ uint grfMode,             /* [in] */ uint reserved2,             /* [out] */ out IStream ppstm);         [PreserveSig]         int CreateStorage(             /* [string][in] */ string pwcsName,             /* [in] */ uint grfMode,             /* [in] */ uint reserved1,             /* [in] */ uint reserved2,             /* [out] */ out IStorage ppstg);         [PreserveSig]         int OpenStorage(             /* [string][unique][in] */ string pwcsName,             /* [unique][in] */ IStorage pstgPriority,             /* [in] */ uint grfMode,             /* [unique][in] */ IntPtr snbExclude,             /* [in] */ uint reserved,             /* [out] */ out IStorage ppstg);         [PreserveSig]         int CopyTo(             /* [in] */ uint ciidExclude,             /* [size_is][unique][in] */ Guid rgiidExclude, // should this be an array?             /* [unique][in] */ IntPtr snbExclude,             /* [unique][in] */ IStorage pstgDest);         [PreserveSig]         int MoveElementTo(             /* [string][in] */ string pwcsName,             /* [unique][in] */ IStorage pstgDest,             /* [string][in] */ string pwcsNewName,             /* [in] */ uint grfFlags);         [PreserveSig]         int Commit(             /* [in] */ StgcConstants grfCommitFlags);         [PreserveSig]         int Revert();         [PreserveSig]         int EnumElements(             /* [in] */ uint reserved1,             /* [size_is][unique][in] */ IntPtr reserved2,             /* [in] */ uint reserved3,             /* [out] */ out IEnumSTATSTG ppenum);         [PreserveSig]         int DestroyElement(             /* [string][in] */ string pwcsName);         [PreserveSig]         int RenameElement(             /* [string][in] */ string pwcsOldName,             /* [string][in] */ string pwcsNewName);         [PreserveSig]         int SetElementTimes(             /* [string][unique][in] */ string pwcsName,             /* [unique][in] */ FILETIME pctime,             /* [unique][in] */ FILETIME patime,             /* [unique][in] */ FILETIME pmtime);         [PreserveSig]         int SetClass(             /* [in] */ Guid clsid);         [PreserveSig]         int SetStateBits(             /* [in] */ uint grfStateBits,             /* [in] */ uint grfMask);         [PreserveSig]         int Stat(             /* [out] */ out STATSTG pstatstg,             /* [in] */ uint grfStatFlag);     }

and how could be used

                  using (SaveFileDialog sd = new SaveFileDialog())                 {                     sd.Filter = "Graph Filter (*.grf)|*.grf|All Files (*.*)|*.*";                     if (sd.ShowDialog() == DialogResult.OK)                     {                         SaveGraph sg = new SaveGraph();                         sg.SaveGraphFile(gb, sd.FileName);                     }                 }

In the case of hand-built filter in GraphEdit  (working well)

and what we obtained using the code

[blastlab]

Windows 8.1 with BLE - just for fun

I decided to test the capabilities of Windows 8.1 in terms of , ease application development based on BLE. I decided to recreate a basic demo of what we had. Simply demo which responds to pressing the button.

As a test platform for, Windows 8.1 was used on a desktop computer with the CSR BLE adapter (based on chipset csr8510)

At the beginning device should be paired in the system (PC Settings) .

When paired, the service is visible in Device Manager,

where you can get more details about the device

and in the section "Bus relations" ( in my case) details on available services could be obtained

Here our service appears as "135b9094-b628-4749-bdc8-1ffc32a9235b"

From Visual Studio (project Windows Store) services  should be added ( in case they are not detected by the system , such as temperature service ) in Package.appxmanifest file .

  <Capabilities>     <Capability Name="internetClient" />     <m2:DeviceCapability Name="bluetooth.genericAttributeProfile">       <m2:Device Id="any">         <m2:Function Type="serviceId:135b9094-b628-4749-bdc8-1ffc32a9235b"/>       </m2:Device>     </m2:DeviceCapability>   </Capabilities>

Code for Windows 8.1 is very easy to run with basic functionality (like here, response to notifications by pressing a button ), literally consists of a few lines of code

        void buttonPressed(GattCharacteristic sender, GattValueChangedEventArgs eventArgs)         {             //read one byte, in this case number represent the number of button presses             byte pc = Windows.Storage.Streams.DataReader.FromBuffer(eventArgs.CharacteristicValue).ReadByte();             //update text box from other thread             this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>             {                 lbl.Text = String.Format("Button pressed {0}", pc);             }).AsTask().Wait(); ;                      }         GattDeviceService service = null;         private async void Button_Click(object sender, RoutedEventArgs e)         {             var dev = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(new Guid("135b9094-b628-4749-bdc8-1ffc32a9235b")));             //lookup for our service             foreach (var d in dev)             {                                  devlist.Items.Add(d.Name);                 if (d.Name == "Blast Lab Bracelet")                 {                     service = await GattDeviceService.FromIdAsync(d.Id);                 }             }             if (service != null)             {                 var chara = service.GetCharacteristics(new Guid("1e0e03d7-a996-42c8-8728-379dc90a7238"));                 chara[0].ValueChanged += buttonPressed;                 await chara[0].WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);             }                      }

and this demo run as we wont:

Compared with android I have to admit that it is much easier, but I'm still quite skeptical set. This solution (officially) can be used only in projects Windows Store, so if you decide to create a console application (eg. test, tool), is much more complex in terms of the configuration (own project configuration). Probably in larger project not acceptable.

[blastlab]

BT4 Module reflow

Finally BLE113 package is reflow, manually it is not so easy. But core of our prototype of beacon now working.

[blastlab]

BlastAPhoto bluetooth device connected to Google Glass

Blast Lab (Gdynia, Poland) is a hardware house so recently we thought about making some hardware and software hacks for Google Glass. Not more than a week took us hacking the Glass Development Kit and Mirror API and getting to know how the firmware exactly works.

Google Glass

BlastAPhoto hardware device for Glass

Today we announced our recent Google Glass external hardware hack. It's a photo trigger Bluetooth device paired directly with Google Glass (without smartphone). We called it BlastAPhoto.

BlastAPhoto Bluetooth device connected directly to Google Glass 

Problem - Google Glass usability 

Using Glass showed us that taking a picture using voice is a big problem. Imagine that you have 2-3 people in the room who are wearing Glass. They all say at once “OK Glass take a picture”. Our tests that we made at Blast Lab showed it can led to taking pictures on every Glass device. So we thought how we can omit this problem and speed up taking pictures.

Solution - Bluetooth remote Glass camera trigger

You can easily click our external device's button and instantly you have a picture taken on your Google Glass. No matter where you are in the interface or what you are doing on Glass if you press the button it will instantly snap a photo. We are finishing another additional action for Glass which will be share. Imagine you click to take a picture and another click let's you share it on Google+. Consider that you are walking around the city and just clicking and Glass is making photos and sharing.

To sum up making pictures never been easier grab our button in hand, click and take pictures with Glass camera.

How does it work from developer's perspective ?

Below we present you a scheme of how it actually works. You turn on Glass and during the booting of Glass Android system our background service app is also starting. Glass app automatically pairs our device with Glass via Bluetooth. When the device is connected you can at any time of using Glass click a button and instantly the photo in Google Glass is taken and stored. 

Application workflow

In our video you can see exactly how it works.

http://www.youtube.com/watch?v=dO3aJEM-AuU

SDK tweaks and team's Bluetooth background

Our team of developers Bartosz Reichel (PhD, CTO) and Arkadiusz Banas have many ideas on SDK tweaks that could be done especially in hardware to Glass connections. We have big experience in hacking Bluetooth 4 BLE and all the chipset tested and team did reverse engineering on many existing apps based on this which are on the Google Play (see our blog post). We prepared our own SDK which supports Bluetooth 4 BLE on Samsung Android devices. Around Bluetooth 4 we built several different hardware prototypes (e.g. panic button) which we paired with Samsung Android phones. The product design team Waclaw Klemp (http://www.coroflot.com/waclaw/) and Lukasz Miadowicz (CEO) is working on the best usability of Glass and products to it  as well as the design for our next hardware product for Google Glass.

How long did it take to build BlastAPhoto ?

It took us one week of hacking Glass Development Kit (GDK) and Mirror API, preparing the hardware and making a Glass software which we run on Glass.

How we approach product development and reverse engineering of electronics, software and design?

We are always divided in two collaborative teams. First team deals with hacking, making Android software and electronics (Bartosz Reichel PhD Eng CTO and Arkadiusz Banas Android developer). Other team works on usability tweaks and additional future design of our device (designer Waclaw Klemp and CEO Lukasz Miadowicz).

Hacker team 

Bartosz Reichel, CTO, PhD Eng, hardware & software hacker

Arkadiusz Banas, Android Developer & Software hacker

Press Kit: [Download]

[blastlab]

Support for Bluetooth 4.0 BLE SMART in Samsung Galaxy Android smartphones

Blast Lab Ltd. did a tremendous job in developing hardware based on Bluetooth v4.0 (Bluetooth Low Energy BLE) paired with Samsung Galaxy S3 smartphone. After fitbit and MYO we are one of the first developers who paired hardware (BT4) with Samsung Android devices. Our blog post is about potential of this technology and problems that this technology faces. 

The new technology that is Bluetooth v4.0 (especially Low Energy) allows to use it in many interesting projects. Unfortunately, in this case, Android has great gap (Android needs to get serious about Bluetooth Low Energy).

Then what to do if we need to connect with BT smart device on Android ?

Some manufactures provide own solution (like Motorola) or there is open SDK like “Open Bluetooth Low Energy API“ known better as Broadcom BLE SDK  (but now 2013.04.20 page is unavaiable). These solution work better or worse.

For example Motorola solution was rebuild and adopted to our device in about 2 hours. Of course not everything on page were clear and well documented but we could download jar with libraries for BT4 device !

Great, we could build application on HTC, Motorola but what about Samsung ? Now very popular (and generally really good) Samsung Galaxy S3 phone it also supports BT4 also has Bluetooth SMART logo !

On Samsung pages there is no information about how to use theirs library (which we could see with adb at com.samsung.bluetoothle). Without any documentation working with Samsung classes like BluetoothLEClientProfile it's more like guesswork than programming. But it's possible to build working application (but for the first time this took much more then for libraries with documentaion).

Now there is available new Samsung API (beta version) [http://developer.samsung.com/ble] which is really beta (many links in documentation like this one):

This api is unfortunately only for Android 2.2. What to do with “old” Samsung Galaxy S3 ? The only solution is to use method described later or wait till Samsung create updates for Samsung Galaxy S3 phone. 

How it look like in competitive Microsoft Windows Phone or Apple iOS ?

Microsoft is still dormant this  will make again: developers choose another platform, that was really strange becaus new Nokia have BT4 certificate [2] also HTC. Unfortunately Windows offer us only Bluetooth stack 3.1.

It is surprising that the Apple platform has the most refined implementation of BT4 stack. Writing applications for this system using BT4 is the simplest and fastest!

In conclusion, if Google does not sort out issues related to BT4 could stop the development of this technology. But watching what happens in the network, you can feel [http://developer.bluetooth.org/Pages/Bluetooth-Android-Developers.aspx], [http://www.ibtimes.com/android-43-release-date-june-10-white-nexus-4-or-july-new-nexus-7-1267103], [http://www.gottabemobile.com/2013/05/15/android-4-3-release/] that Google (perhaps along with Broadcom) will do something. It would be nice to Google teamed up with companies like HTC, Motorola, Samsung to properly support this devices.

I believe that is already done, because if we look for description of Samsung Bluetooth package com.samsung.ble and compare it with documentation for Open Bluetooth Low Energy API with package com.broadcom.bt.le.api we could find a lot of similarities.

Blast Lab is creating devices based on Bluetooth 4 BLE SMART on demand. If you are interested just contact us: [email protected], Twitter: @blastlabltd

[blastlab]

Starting a Blast Lab blog

Blast Lab Ltd. is a R&D company focused on building hardware and software products. We are mainly interested in connected devices, NFC hardware solutions, internet of things, mobile application development, Bluetooth v4.0 BLE, EEG, Augmented Reality. 

Our fields of interests are:

connected devices - hardware solutions connected through Bluetooth v.4.0 Low Energy (BLE) technology/WiFi with mobile apps on smartphones.

internet of things - electronic/hardware devices gathering data (sensors) and cloud software for further data analyse.

native mobile applications development - we are mainly interested in Android platform and building fast and highly optimised applications using NDK / C / C++ and Qt Framework

NFC - building and prototyping devices provided with mobile apps.

M2M communication / intelligent house - building solutions and sensors connected with WiFi. Mobile controlled locks, thermostats, gas sensors, current sensors.

Life-style devices and fitness devices (wearable computers)- building hardware solutions for health combined with smartphone.

Cloud computing (Big data) - database optimisation, mathematical modeling, statistics, business rules, fast image comparison.

Augmented Reality