The BeeInformedTeam:

Published November 3, 2017 © MIT

LittleBee: Acoustic Sensor For Measuring Bee Hissing Level

Have you noted the main cause of Bee mortality is associated with death caused by its attack? LittleBee senses and how Bees are aggressive!

IntermediateFull instructions provided8 hours1,596

$100

ST SensorTile: IoT Sensing Magic!

LittleBee: Acoustic Sensor For Measuring Bee Hissing Level

Things used in this project

Hardware components

STMicroelectronics STEVAL-STLKT01V1

STMicroelectronics STM32 Nucleo-64 Board

Android device

Software apps and online services

Android Studio

Atollic TrueSTUDIO

Hand tools and fabrication machines

Soldering iron (generic)

Story

Hello everyone, here I am again, but this time with a complete project entry to SensorTile contest! Ohaaaay!

But as usual, due to Brazilian logistics to deliver a simple hardware in my home, again it arrived to me with only 5 days remaining to the contest's deadline.

So, what I've built here? Simple my goal is to provide a sensor node which helps the Beekeepers to perform his Bee culture tasks more safe, more than that I want to reduce Bee mortality which basically impacts in two points:

Reducing mortality means more Bees working on flower pollination, so more fruits and positive impact in food supply for everyone;

Helps the beekeepers to avoid losing his beehives due to high Bee mortality and keeping the honey extraction productivity stable or maximize it.

The result of the work? Well this will you get if you read and perform the steps described below, don't worry! The project is not over complex! And I'm certain you will have a lot of fun with this sensor:

LittleBee showcasing!

So, how it works?

Before entering in details of this project, we need to understand the fundamentals of monitoring sound of Bees, the first aspect, the Bees perform different sound emission, with different means, the interest for us is the Hissing sound, which basically translates it's aggressiveness level.

According to some references (placed in the end) the hissing level is placed around the 3K audible band, in some cases with +- 200Hz of bandwidth. So the idea, monitor the hissing and tell to BeeKeeper through some UI, or a Android App how aggressive that Beehive currently is. Where the SensorTile cames into play the combination of low power microphone, a Cortex M4F CPU and a easy to use BlueNRG module performed the trick like a charm!

The signal flow is simple, the SensorTile microphone outputs the audio captured, through a PDM mechanism, the on board MCU, capture it and send to DFSDM, which is a kind of sigma-delta demodulator which extracts the RAW 16-bit PCM formatted audio signal, with this samples set the firmware send the buffer to a real Fast-Fourier-Transform block followed by a magnitude computing block, this can be possible with the hardware enabled float point unit of the Microcontroller (a popular STM32L4 family), with the magnitude a simple search on 3KHz frequency range is made and RMS is obtained, this is the continuous behavior of the called BeeDSP firmware module.

The communication module uses the Bluetooth Low Energy to transmit the measured result, to perform it, the BlueNRG ACI stack is used to setup the BLE and add a service called Bee service which has a 4 byte sized characteristic, which notify the peer device (a Android Phone) about a new hissing level measured.

The phone application, scans for a LittleBee device, and only connects to LittleBee devices, after to discover a available device it immediately will accept notifications on Bee service, then takes the read values and plot on a graph created with Graph View widget. See some pictures of the system running:

Sensor performing advertising

App splash screen

Bluetooth sensor scanning!

Whow! The sensor is found, let's get some data!

Oh yeah! Some data is arriving!

The application uses a real time chart which is updated periodically (which a 100ms refresh rate), the purpose of the UI is to have the primary monitoring of hissing level, so no custom UI was provided, of course the source code of the app is open and free to use as own!

Cool! Help me to build one!?

So, now is the time to instruct how you can deploy this powerful sensor intended (but not limited to) Bee environments. The first instruction, is to get the both development enviroments, the attolic true studio to develop the firmware, it was chosen because it is free and is a professional grade and stable IDE to program the devices. The android studio was selected for obvious reasons to develop the mobile app.

Opening the True Studio you will see a screen like this below:

True studio workspace

The first task to deploy the firmware component is to obtain the source code, you can find it on my github, the project is complete with dependences resolved in relative path, so you only need to navigate the True Studio then File->Import, in the popup select the: Existing projects on workspace, untick the option copy the project on workspace, the find the root project folder where you downloaded from Github.

Now you're asking yourself: "Hey, whats is the purpose of the Núcleo Board on the components list?"

The short anwser, have you noted the SensorTile kit does not come with a flasher or debugger? Yes, it doesn't! You need a external tool to flash the firmware, another option is to use the USB port located on expansion audio board of the kit and flash firmware through DFU tools, but it seems a complicated and unecessary step since the Nucleo boards are extremely cheap and easy to find. So pick one, connects it to USB, don't worry about the debug settings this was already configured on project settings (Let's follow the KISS philosophy - Keep It Simple, Stupid!). Now go back to the SensorTile kit. As you noted, it is composed by some items, 4 are very important here:

The SensorTile itself (Really, Felipe? XD );

The battery expansion cradle;

The plastic case (I'm serious the full assembled sensor becomes very charming in the case);

The battery, we don't want wires.

We now will assemble the only hardware demanding step, in all you will have something like this:

Full assembled sensor node, cute, isn't?

So, bring the soldering Iron and the:

SensorTile

Note it's edges, this is a castellation like pads, it is very simple to solder, bring the expansion battery cradle below:

Note the header on the edges, this one is used to program or debug the firmware through microcontroller's SWD port, this is another reason that I indicated the NucleoBoards, it has a pin compatible header for external devices, this will eases the firmware deploying!

Now with a soldering iron, and some soldering, carefully solder the castellation pads on cradle pads, WARNING! Take care with the SensorTile position, make sure the pin 1 of the cradle matches with the pin 1 of the sensor, otherwise the things will get hot!

After performing the solder will you get the following:

Check carefully the soldering to find open and short circuits, make use of a multimeter using the lowest resistance measurement range to help you. Now just pick the battery and plug it on the connector, and in the last step pick the plastic case and put the sensor board with battery into it, use a screw to close the plastic case.

This is the only hardware step required now we will perform the deploy, so pick two USB cable, one mini to Nucleo board and a micro one to SensorTile board, also pick the programming cable:

Connect it to sensor board.

Then connect all the USB and the programming cable on Nucleo external debuggers, WARNING! Don't forget to open the CN2 jumper, it will allow to use the STLINK debugger with external targets. The connections will be like this:

Mind the pin 1 of the sensor node, it is marked as a squared pad on bottom of header connector! match it with the pin 1 of the Nucleo board, then turn-on the on-off switch. Go back to True Studio, with the project imported, just hit CTRL+B to build the workspace, you will see a couple of warnings, don't worry about them, it related to cmsis SIMD functions which is not used, only the FFT and magnitude was used from CMSIS DSP Lib to perform the calculations. Upon a successful build, then hit F11 to debug and download the firmware, now let's celebrate, the firmware seems to be running, if you want to see BLE traffic just obatain some BLE scan tool app, you will be able to connect to LittleBee sensor!

For the application part, the steps are even simpler, first obtain the source code here on my github, after open the Android Studio, use the import option below and search where project was downloaded:

And that's it the project will be in the workspace, so just connect you Android device, go to Build->Rebuild project. Wait a bit, it seems a successful build as same the firmware, now deploy the application to device using Run->Run App, this will download the application using the Android Debug Bridge, for mobile developers very known as ADB and will start immediately.

...and that's it! Your LittleBee is ready to use! So go to a apiary, leave the sensor and start to explore the Bee emitted sound and it means. As a hacking suggestion you can go on firmware and modify the frequency bin data picks to another value and will sendo to App another type of sound emitted! Just go back on firmware open the file bee_dsp.c , then go to line 70 and select a new index each index corresponds to frequency in steps of 92Hz.

Some conclusions

This project was submitted originally to ST SensorTile contest, my main challenge in this project was to put my hands on hardware on time of contest's deadline, but I only received it with some days remaining, the solution was to keep the scope simpler and show a good deliver ready to be a commercial or even a open source mass production device. The application has a simple and intuitive interface and it is scalable to be integrated on cloud! The firmware in other hand is even more powerful, today only a simple searching on frequency bins is performed, but the current spectrum is always retained on RAM to perform more complex analysis, as a future improvements, we want to add the swarm audio, which indicates how many work the Bees are doing on the beehive. I hope you enjoyed reading this or reproducing it, contributions are always welcome, and we released the stuff of project under MIT contents to incentive all the BeeKeepers to install this system and help to perform Bee culture a more sustainable activity!

/*
 *  @file 	lilbee.c
 *  @brief 	littlebee firmware application entry point
 *
 */

#include "lilbee.h"


/** internal functions */



/**
 * 	@fn sysclk_config()
 *  @brief setup processor clock units
 *
 *  @param
 *  @return
 *
 *
 */
static void sysclk_config(void)
{
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};

  __HAL_RCC_PWR_CLK_ENABLE();
  HAL_PWR_EnableBkUpAccess();

  /* Enable the LSE Oscilator */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK){
    while(1);
  }

  /* Enable the CSS interrupt in case LSE signal is corrupted or not present */
  HAL_RCCEx_DisableLSECSS();

  /* Enable MSI Oscillator and activate PLL with MSI as source */
  RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_MSI;
  RCC_OscInitStruct.MSIState            = RCC_MSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.MSIClockRange       = RCC_MSIRANGE_11;
  RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource       = RCC_PLLSOURCE_MSI;
  RCC_OscInitStruct.PLL.PLLM            = 6;
  RCC_OscInitStruct.PLL.PLLN            = 40;
  RCC_OscInitStruct.PLL.PLLP            = 7;
  RCC_OscInitStruct.PLL.PLLQ            = 4;
  RCC_OscInitStruct.PLL.PLLR            = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK){
    while(1);
  }

  /* Enable MSI Auto-calibration through LSE */
  HAL_RCCEx_EnableMSIPLLMode();

  /* Select MSI output as USB clock source */
  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USB;
  PeriphClkInitStruct.UsbClockSelection = RCC_USBCLKSOURCE_MSI;
  HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);

  /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
  clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK){
    while(1);
  }
}

/** Public functions */


/**
 * 	@fn main()
 *  @brief application entrypoint and aloop
 *
 *  @param
 *  @return
 */
int main(void)
{
	sysclk_config();
	HAL_Init();

	BSP_LED_Init(LED1);

	/* inits the sub applications */
	bee_dsp_init(AUDIO_SAMPLE_FREQ);
	audio_acq_init();
	bee_ble_init();

	/* start the analysis*/
	audio_start_capture();

	for(;;){
		system_event_t ev = event_queue_get();

		audio_handler(ev);
		bee_dsp_handler(ev);
		bee_ble_handler(ev);

		if(event_queue_peek() == k_noevent) {
			/* No event pending, sleep the cpu */
			__WFI();
		}

		BSP_LED_Toggle(LED1);
	}
}

/*
 *  @file 	lilbee.c
 *  @brief 	littlebee firmware application entry point
 *
 */

#include "lilbee.h"


/** internal functions */



/**
 * 	@fn sysclk_config()
 *  @brief setup processor clock units
 *
 *  @param
 *  @return
 *
 *
 */
static void sysclk_config(void)
{
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};

  __HAL_RCC_PWR_CLK_ENABLE();
  HAL_PWR_EnableBkUpAccess();

  /* Enable the LSE Oscilator */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK){
    while(1);
  }

  /* Enable the CSS interrupt in case LSE signal is corrupted or not present */
  HAL_RCCEx_DisableLSECSS();

  /* Enable MSI Oscillator and activate PLL with MSI as source */
  RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_MSI;
  RCC_OscInitStruct.MSIState            = RCC_MSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.MSIClockRange       = RCC_MSIRANGE_11;
  RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource       = RCC_PLLSOURCE_MSI;
  RCC_OscInitStruct.PLL.PLLM            = 6;
  RCC_OscInitStruct.PLL.PLLN            = 40;
  RCC_OscInitStruct.PLL.PLLP            = 7;
  RCC_OscInitStruct.PLL.PLLQ            = 4;
  RCC_OscInitStruct.PLL.PLLR            = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK){
    while(1);
  }

  /* Enable MSI Auto-calibration through LSE */
  HAL_RCCEx_EnableMSIPLLMode();

  /* Select MSI output as USB clock source */
  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USB;
  PeriphClkInitStruct.UsbClockSelection = RCC_USBCLKSOURCE_MSI;
  HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);

  /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
  clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK){
    while(1);
  }
}

/** Public functions */


/**
 * 	@fn main()
 *  @brief application entrypoint and aloop
 *
 *  @param
 *  @return
 */
int main(void)
{
	sysclk_config();
	HAL_Init();

	BSP_LED_Init(LED1);

	/* inits the sub applications */
	bee_dsp_init(AUDIO_SAMPLE_FREQ);
	audio_acq_init();
	bee_ble_init();

	/* start the analysis*/
	audio_start_capture();

	for(;;){
		system_event_t ev = event_queue_get();

		audio_handler(ev);
		bee_dsp_handler(ev);
		bee_ble_handler(ev);

		if(event_queue_peek() == k_noevent) {
			/* No event pending, sleep the cpu */
			__WFI();
		}

		BSP_LED_Toggle(LED1);
	}
}

/*
 *  @file bee_dsp.c
 *  @brief module responsible to perform some DSP on the acquired audio
 */

#include "lilbee.h"


/** internal variables */
static uint32_t sample = 0;
static bee_spectra_t spectra = {0};
static float aggro_level = 0;

static bool dsp_lock = false;
static float dsp_float_buffer[1056];
extern const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len512;

/** internal functions */

/**
 * 	@fn on_dsp_audio()
 *  @brief
 *
 *  @param
 *  @return
 */
static void on_dsp_audio(void)
{
	dsp_lock = true;

	/* gets the audio frame we will about to process */
	audio_frame_t *audio_block = audio_get_current_frame();

	/* no audio available or corrupted */
	if(audio_block == NULL)
		goto on_dsp_audio_exit;


	/* convert audio samples to float value */
	for(uint32_t i = 0; i < audio_block->size; i+=16) {
		/* unroll loop for performance */
		dsp_float_buffer[i] = (float)audio_block->audio_buffer[i]/32768.0f - 1.0f;
		dsp_float_buffer[i+1] = (float)audio_block->audio_buffer[i+1]/32768.0f - 1.0f;
		dsp_float_buffer[i+2] = (float)audio_block->audio_buffer[i+2]/32768.0f - 1.0f;
		dsp_float_buffer[i+3] = (float)audio_block->audio_buffer[i+3]/32768.0f - 1.0f;
		dsp_float_buffer[i+4] = (float)audio_block->audio_buffer[i+4]/32768.0f - 1.0f;
		dsp_float_buffer[i+5] = (float)audio_block->audio_buffer[i+5]/32768.0f - 1.0f;
		dsp_float_buffer[i+6] = (float)audio_block->audio_buffer[i+6]/32768.0f - 1.0f;
		dsp_float_buffer[i+7] = (float)audio_block->audio_buffer[i+7]/32768.0f- 1.0f;
		dsp_float_buffer[i+8] = (float)audio_block->audio_buffer[i+8]/32768.0f - 1.0f;
		dsp_float_buffer[i+9] = (float)audio_block->audio_buffer[i+9]/32768.0f - 1.0f;
		dsp_float_buffer[i+10] = (float)audio_block->audio_buffer[i+10]/32768.0f - 1.0f ;
		dsp_float_buffer[i+11] = (float)audio_block->audio_buffer[i+11]/32768.0f - 1.0f;
		dsp_float_buffer[i+12] = (float)audio_block->audio_buffer[i+12]/32768.0f - 1.0f;
		dsp_float_buffer[i+13] = (float)audio_block->audio_buffer[i+13]/32768.0f - 1.0f;
		dsp_float_buffer[i+14] = (float)audio_block->audio_buffer[i+14]/32768.0f - 1.0f;
		dsp_float_buffer[i+15] = (float)audio_block->audio_buffer[i+15]/32768.0f - 1.0f;
	}



	/* prepare to compute the FFT */
	arm_rfft_fast_f32(&arm_rfft_fast_sR_f32_len512, dsp_float_buffer, &spectra.raw[0], 0);
	arm_cmplx_mag_f32(&spectra.raw[0], &spectra.raw[0], DSP_FFT_POINTS);


	spectra.spectral_points = DSP_FFT_POINTS;
	spectra.spectral_sample_rate = AUDIO_SAMPLE_FREQ;
	/* estimente the aggro level searching the hissing frequency interval */
	aggro_level = spectra.raw[32];

on_dsp_audio_exit:
	/* broadcast the dsp end of processing */
	event_queue_put(k_dsp_endprocess);
}


/**
 * 	@fn on_dsp_endproc()
 *  @brief
 *
 *  @param
 *  @return
 */
static void on_dsp_endproc(void)
{
	dsp_lock = false;

	/* broadcast a new processed aggro level */
	audio_start_capture();
	event_queue_put(k_aggresivity_available);
}



/** public functions */

void bee_dsp_init(uint32_t dsp_sample)
{
	sample = dsp_sample;
}


uint32_t bee_dsp_get_sample_rate(void)
{
	return(sample);
}

float bee_dsp_get_aggro_level(void)
{

	return(aggro_level);
}

bee_retcode_t bee_dsp_get_spectra(bee_spectra_t *raw)
{
	bee_ble_retcode_t ret = k_bee_err;

	if(!dsp_lock && raw) {

		dsp_lock = true;
		__disable_irq();
		memcpy(raw, &spectra, sizeof(spectra));
		__enable_irq();
		dsp_lock = false;

		ret = k_bee_ret_ok;
	}

	return(ret);
}

void bee_dsp_handler(system_event_t ev)
{
	switch(ev) {
	case k_dsp_incoming_audio_available:
		on_dsp_audio();
		break;

	case k_dsp_endprocess:
		on_dsp_endproc();
		break;
	}
}

package com.project.hackathon.motorola.bluetoothexample;

import android.content.Context;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.os.Handler;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.bluetooth.*;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;
import android.util.Log;
import android.content.BroadcastReceiver;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Set;
import java.util.UUID;
import java.util.List;
import java.lang.Object;

public class bleActivity extends AppCompatActivity {

    BluetoothAdapter mBluetoothAdapter;
    BluetoothGatt    mGatt;
    BluetoothGattCharacteristic mBeeChar;
    public static float aggroLevel;


    private static final int REQUEST_ENABLE_BT = 1;
    private static final long SCAN_PERIOD = 10000;
    private static final String BLE_TAG = "BEE_BLE_LOG";
    Context mCtx;

    private boolean mScanning;
    private Handler mHandler;
    private int bleStatus;


    private UUID myUUID;
    private final String BEE_BLESERVICE_UUID =
            "00000000-000F-11E1-9AB4-0002A5D5C51B";

    private final String BEE_BLESERVICE_CHAR =
            "00000002-000F-11E1-AC36-0002A5D5C51B";


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_ble);


        mCtx = this;
        mHandler = new Handler();

        // obtaints the ble adapter
        final BluetoothManager bluetoothManager =
                (BluetoothManager) getSystemService(mCtx.BLUETOOTH_SERVICE);
        mBluetoothAdapter = bluetoothManager.getAdapter();


    }

    @Override
    protected void onStart() {
        super.onStart();

        if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
            Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
        }

        scanLeDevice(true);
    }


    //BLE scan callback
    private BluetoothAdapter.LeScanCallback mLeScanCallback =
            new BluetoothAdapter.LeScanCallback() {
                @Override
                public void onLeScan(final BluetoothDevice device, int rssi,
                                     byte[] scanRecord) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Log.d(BLE_TAG, "Device found is:" + device.getAddress());
                            Log.d(BLE_TAG, "Device found is:" + device.getName());

                            if(bleStatus != BluetoothProfile.STATE_CONNECTED) {

                                TextView tv = (TextView) findViewById(R.id.bleScanStatus);


                                // if device is a littleBee gather this device
                                if(new String("LB").equals(device.getName())) {

                                    tv.setText("LitteBee found! Connecting to it! ");

                                    // gets the device instance and connect to it
                                    mGatt = device.connectGatt(mCtx, true, mGattCallback);
                                }

                            }
                        }
                    });
                }
            };



    private final BluetoothGattCallback mGattCallback =
            new BluetoothGattCallback() {
                @Override
                public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
                    super.onConnectionStateChange(gatt, status, newState);

                    bleStatus = newState;

                    if(newState == BluetoothProfile.STATE_DISCONNECTED){
                        Log.d(BLE_TAG, "LittleBee was disconected! restarting the advertisement");
                        scanLeDevice(true);


                    } else if(newState == BluetoothProfile.STATE_CONNECTED) {
                        Log.d(BLE_TAG, "LittleBee is connected! ");
                        TextView tv = (TextView) findViewById(R.id.bleScanStatus);

                        //aftert connection, disable the scanning
                        scanLeDevice(false);

                        // discover services then start the graph activity
                        gatt.discoverServices();

                        Intent it = new Intent(bleActivity.this, MainActivity.class);
                        startActivity(it);

                    }

                }

                @Override
                public void onServicesDiscovered(BluetoothGatt gatt, int status){
                    super.onServicesDiscovered(gatt, status);

                    if (status == BluetoothGatt.GATT_SUCCESS) {

                        Log.d(BLE_TAG, "Discovered database! ");
                        List <BluetoothGattService> services = gatt.getServices();
                        myUUID = UUID.fromString(BEE_BLESERVICE_UUID);

                        //Iterate through characteristics to find the desired one
                        for(BluetoothGattService service: services) {

                            if(service.getUuid().equals(myUUID)) {
                                myUUID = UUID.fromString(BEE_BLESERVICE_CHAR);
                                mBeeChar = service.getCharacteristic(myUUID);

                                // Set notification properties:
                                gatt.setCharacteristicNotification(mBeeChar, true);

                                for(BluetoothGattDescriptor desc : mBeeChar.getDescriptors()) {

                                    desc.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
                                    gatt.writeDescriptor(desc);
                                }

                                break;
                            }
                        }


                    } else {

                        Log.d(BLE_TAG, "Failed to services discovered, status " +  status);

                    }
                }

                @Override
                public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
                    super.onCharacteristicChanged(gatt, characteristic);

                    Log.d(BLE_TAG, "Characteristic update from device " + characteristic.getFloatValue(BluetoothGattCharacteristic.FORMAT_FLOAT,0));

                    int tmp = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT32,0);
                    aggroLevel = Float.intBitsToFloat(tmp);
                }
            };


    private void scanLeDevice(final boolean enable) {

        TextView tv = (TextView) findViewById(R.id.bleScanStatus);

        if (enable) {
            // Stops scanning after a pre-defined scan period.
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    mScanning = false;
                    mBluetoothAdapter.stopLeScan(mLeScanCallback);
                }
            }, SCAN_PERIOD);

            tv.setText("Finding LittleBee Device...");

            mScanning = true;
            mBluetoothAdapter.startLeScan(mLeScanCallback);
        } else {
            mScanning = false;
            mBluetoothAdapter.stopLeScan(mLeScanCallback);
        }
    }

}

package com.project.hackathon.motorola.bluetoothexample;

import android.Manifest;
import android.graphics.Color;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.os.Handler;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

import com.jjoe64.graphview.GraphView;
import com.jjoe64.graphview.Viewport;
import com.jjoe64.graphview.series.DataPoint;
import com.jjoe64.graphview.series.LineGraphSeries;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Set;
import java.util.UUID;


public class MainActivity extends AppCompatActivity {


    LineGraphSeries<DataPoint> mSeries ;
    GraphView mBeeGraph;
    private Handler  mGraphHandler;
    private Runnable mGraphTimer;
    private Viewport mVp;
    private int xpos;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mBeeGraph = (GraphView)findViewById(R.id.graph);
        mGraphHandler = new Handler();

        mSeries =  new LineGraphSeries<>();
        mSeries.setTitle("Bee Hissing Level");
        mSeries.setBackgroundColor(Color.GRAY);

        mBeeGraph.addSeries(mSeries);

        mVp= mBeeGraph.getViewport();
        mVp.setXAxisBoundsManual(true);
        mVp.setMinX(0);
        mVp.setMaxX(1000);
        mVp.setMinY(-2);
        mVp.setMaxY(2);


        xpos = 0;
    }


    @Override
    protected void onStart() {
        super.onStart();

    }


    @Override
    protected void onResume() {
        super.onResume();

        mGraphTimer = new Runnable() {
            @Override
            public void run() {

                xpos++;
                mSeries.appendData(new DataPoint(xpos, bleActivity.aggroLevel), true, 1000);
                mGraphHandler.postDelayed(this, 100);
            }
        };

        mGraphHandler.postDelayed(mGraphTimer, 100);
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
    }

}

Credits

Felipe Neves

2 projects • 14 followers

Passionate embedded systems engineer, lead developer for smart wearable devices, spends his free time making amazing and shareable projects.

Comments

Awards

$100

ST SensorTile: IoT Sensing Magic!

LittleBee: Acoustic Sensor For Measuring Bee Hissing Level

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

So, how it works?

Cool! Help me to build one!?

Some conclusions

Code

LittleBee firmware main application loop.

LittleBee firmware main application loop.

Bee DSP module.

Android app BLE activity

Android app main activity

littlebee

LilBee

Credits

Felipe Neves

Comments

Awards

Embed the widget on your own site

LittleBee: Acoustic Sensor For Measuring Bee Hissing Level

LittleBee: Acoustic Sensor For Measuring Bee Hissing Level

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

So, how it works?

Cool! Help me to build one!?

Some conclusions

Code

LittleBee firmware main application loop.

LittleBee firmware main application loop.

Bee DSP module.

Android app BLE activity

Android app main activity

littlebee

LilBee

Credits

Felipe Neves

Comments

Awards

Related channels and tags