Published November 4, 2019 © GPL3+

IoT Robot Using Bluetooth Between Raspberry Pi and Micro:bit

IoT Community Garden Part 2: IoT Robot using Bluetooth communication between Raspberry Pi and Microbit, controlled over Telegram

AdvancedFull instructions provided3 hours3,246

IoT Robot Using Bluetooth Between Raspberry Pi and Micro:bit

Things used in this project

Hardware components

DFRobot Micro Maqueen

BBC micro:bit board

Raspberry Pi 3 Model B

Software apps and online services

Telegram App

Story

IoT Garden Robot

The Story

The original article can be found here:

https://zenofall.com/iot-robot-using-bluetooth-communication-between-raspberry-pi-and-microbit/

First and foremost, I would like to thank our readers for the overwhelming response shown for my previous article regarding IoT Community Garden project. Second I would like to thank Barry Byford (ukbaz) for amazing Python bluezero library.

A day after I wrote the first IoT Community Garden article and posted it on hackster, I had about 100 new people join the telegram group t.me/iotgarden – to help monitor the garden, take ndvi pics and water the plants. For anyone who has not read the IoT community garden project, I would highly recommend you read that article first before reading this one.

But I soon realized that after the initial novelty of the IoT garden wore off, lot of the visitors began to leave – frankly there is not really much to do because of the embedded limits associated with preventing over watering, and frequent flipping of the lights – thus the most common activity left to do under user control with little or no limitations is taking pictures of the plants, and visitors would soon get bored of doing this as well.

So I decided to add a robot for entertainment purposes – this robot can be started and stopped remotely by any user and randomly runs for 1min.

On most days you can control this robot by joining our Telegram group: https://t.me/iotgarden

and type: /start

A button menu will pop up and you can click the button which says “StrtRobotRoy”. Wait for about 1min and a clip of the robot randomly roaming around in its garden box will be sent back on the chat group, this will be the video of the run that you kicked off. (sorry I don’t have a way to make this fully live yet) – It will be similar to the video below.

The Microbit Robot

The robot I chose for my project is called micro:Maqueen created by DF Robot and uses a BBC Micro:Bit chip as controller. A few things I like about the Maqueen robot platform is the ease of assembly and ease of programming using Microsoft Makecode interface – which is a browser based block coding language developed to introduce kids and young adults to programming/logic. Another great thing I like about Maqueen is the price, it is fairly cheap and makes for a great gift, especially with the holidays being just around the corner. Click hereto see the latest price from the vendor or click the picture above.

Along with the above mentioned points the Maqueen is a very well made, sturdy robot – which I have been using for over 6months now, and that too mainly outside in the balcony – exposed to elements of nature and it is going strong. As I mentioned before Maqueen uses BBC micro:bit as a controller. MicroBit in itself is an amazing micro controller with on board bluetooth services, which we will be using for this project. Along with bluetooth microbit also has a bunch of other features like a bank of LEDs to display text or symbols, accelerometer, compass, light and temperature sensor, etc.

The compiled code that runs on the microbit (robot end) is written/designed using Microsoft makecode directly in the browser. It is amazing that you can call complex services such as bluetooth and event handlers using the make code interface. It did take me a while to understand how the bluetooth and event service handlers should be used so as to not cause a runtime error, but I finally figured it out.

All you have to do after you have arranged the logical boxes and told the robot what to do is download the hex file and flash it onto your microbit by connecting the microbit to your computer via USB and simply dragging and dropping the code into the folder. The code I am using is published below, feel free to experiment and change the code.

https://makecode.microbit.org/—codeembed#pub:_PiWWrm4qYW0E

The Bluetooth Interface with Raspberry Pi

To me the most interesting and challenging part of the project was the programming the bluetooth communication between Raspberry Pi and MicroBit. While doing my research I came across this amazing python library called blue zero written by written by Barry Byford which made life much easier for me. Barry and I exchanged few emails discussing code and finally he made an update to his library which ended up working perfectly for me. First install the python bluetooth library from GitHub, make sure you pull the event_service branch, which is currently experimental and not merged into the main branch. I have provided a direct link below for download:

https://github.com/ukBaz/python-bluezero/archive/event_service.zip

Make sure you install this library using “sudo” i.e. root access, because being able to use bluetooth requires root access.

Unzip the folder above into any directory on your Pi, browse into it (CD) and then type:

sudo python3 setup.py install

Next step will be to configure bluetooth interface on Raspberry Pi.To start with the Bluetooth interface on Raspberry Pi, type the following commands:

sudo hciconfig hci0 up
systemctl status bluetooth
sudo systemctl start bluetooth

Read the pairing instructions here to pair with Microbit:

https://ukbaz.github.io/howto/ubit_workshop.html

Now you are pretty much done – if you follow the instructions above, you should be able to pair and connect Raspberry Pi to the Microbit.You can now update the bluetooth adapter information, based on your bluetooth adapter (device) addresses, in the python code file below and test if your microbic responds.Next you can download the latest version of IoT garden project code – which supports the robot from here and start playing around with it yourself.

The code

Finally what you all have been waiting for, my actual Community IoT Garden bot code.

There are four files in the zip below, keep them all in same folder while running:

BluetoothMicrobitController.py – this is a test file which will help you test interface between Raspberry Pi and Microbit
zenIoTBot_v3_1a.py – this is the main file which you will run, you will have to use your own telegram token and darksky key
NDVI.py – this helps you do NDVI pics
iotcontroller.py – this is where most of the logic is written.

To learn more about the code visit my previous article: IoT Community Garden.

To run the code on Raspberry Pi, put all three (2, 3, 4) files in one folder open terminal and type:

sudo python3 zenIoTBot_v3_1a.py &

Disclaimer: The python source code below is provided by Zen Of All LLC for free upon registration, the users (downloaders) of the code are free to modify it as they see fit. Zen Of All LLC assumes no legal responsibility or liability towards the code, its maintenance, usage or any modifications by the users (downloaders).

In English: I wrote this code very fast for testing my proof of concept idea – feel free to read it carefully and edit as per your own needs, I am not responsible if something breaks.

You will need to create a login for this website to download the code.

The code can be found at the original article link:

https://zenofall.com/iot-robot-using-bluetooth-communication-between-raspberry-pi-and-microbit/

Main Controller

# -*- coding: utf-8 -*-
"""
Created on Sat Apr  7 13:26:28 2018

@author: zenofall (zenofall.com)
"""

import threading
import os
import time


from iotcontrol import iotcontrol
from telegram import InlineKeyboardButton, InlineKeyboardMarkup

from telegram.ext import Updater
from telegram.ext import CommandHandler , CallbackQueryHandler
from telegram.ext import MessageHandler, Filters
import logging
##############################################################################################
darkskyKey = 'DARKSKYKEY'
updater = Updater(token='TelegramToken') #Insert bot token
#required by bot to execute functions see example: https://python-telegram-bot.org/
control = iotcontrol(1234567,darkskyKey,33.8463634,-84.373057) #admin id : find this by going to web-api of telegram: https://api.telegram.org/bot<TOKEN>/getUpdates
# 1234567 is example admin id : find yours by going to web-api of telegram: https://api.telegram.org/bot<TOKEN>/getUpdates
#<TOKEN> is telegram token during bot creation
#read: https://zenofall.com/raspberry-pi-telegram-home-automation/
#replace: 33.8463634,-84.373057 by latitude longitude of your location from google maps
#we use adminId for special privileges on the bot

dispatcher = updater.dispatcher 
#bot examples: https://github.com/python-telegram-bot/python-telegram-bot/tree/master/examples

#logging is always good

#define logging format and file location



####################Bot User Functions ##############################

def start(bot,update): #display menu
    """ BotFunction: First function using which users are supposed to interact with this bot"""
   

    
    control.autoAdd(bot,update)
    
    
    keyboard = [[InlineKeyboardButton("Instructions", callback_data='5'), 
                 InlineKeyboardButton("Status", callback_data='4')],
                 [InlineKeyboardButton("Take Pic", callback_data='1'),
                 InlineKeyboardButton("NDVI Pic", callback_data='8')],
                 [InlineKeyboardButton("Video", callback_data='9'),
                 InlineKeyboardButton("Ligts on/off", callback_data='3')],
                 [InlineKeyboardButton("Local Weather", callback_data='7'),
                 InlineKeyboardButton("Water Plants", callback_data='2')],
                 [InlineKeyboardButton("StrtRobotRoy", callback_data='10'),
                 InlineKeyboardButton("StpRoy", callback_data='11')],
                
                
                [InlineKeyboardButton("Tutorial & Code", callback_data='6')]
                ]
    
    message="Hello {} (telegram_id:{}).\nPlease read: Instructions first.\nType& send:/start again to pull up menu at any time.\n*Disclaimer: Bot logs all user commands. \nPlease Choose: \n".format(update.message.from_user.first_name,update.message.from_user.id)
    reply_markup = InlineKeyboardMarkup(keyboard,resize_keyboard=True)

    bot.send_message(chat_id=update.message.chat_id,text=message, reply_markup=reply_markup)
            

def button(bot,update):
    """ BotFunction: Function that implements the button callbacks"""
    query = update.callback_query
    bot.answer_callback_query(callback_query_id=query.id, text="Choice registered,processing request..")
    
        
    if(query.data=='1'):
         
        
        #control.sendPic(bot,update,False)
        t=threading.Thread(target=control.sendPic,args=(bot,update,False))
        t.setDaemon(True)
        t.start()

    if(query.data=='8'):
        
        
        t=threading.Thread(target=control.sendPic,args=(bot,update,True))
        t.setDaemon(True)
        t.start()

    if(query.data=='9'):
        
      
        t=threading.Thread(target=control.recordVideo,args=(bot,update))
        t.setDaemon(True)
        t.start()
        

    if(query.data=='2'):
        
        
        t=threading.Thread(target=control.recordVideo,args=(bot,update))
        t.setDaemon(True)
        t.start()
        time.sleep(5)
        control.water(bot,update)
    
    if(query.data=='3'):
        
        t=threading.Thread(target=control.recordVideo,args=(bot,update))
        t.setDaemon(True)
        t.start()
        time.sleep(5)
        
        control.light(bot,update)
         
    if(query.data=='7'):
        
        control.weather(bot,update)

    if(query.data=='4'):
    
     control.status(bot,update)

    if(query.data=='5'):
        control.instructions(bot,update)

    
    if(query.data=='6'):
        control.tutorial(bot,update)
        
    if(query.data=='10'):
        
        control.runRobot(bot,update,True)
    if(query.data=='11'):
        control.runRobot(bot,update,False)

############# Admin only program functions####################
            

def unknown(bot, update):
    """ Unkwown command handler"""
    logging.info('/unknown,{},{}'.format(update.message.from_user.first_name,update.message.from_user.id))
    bot.send_message(chat_id=update.message.chat_id, text="Sorry Command Not Recognized! Type: /start for all user actions.")            

def shutdown():
    
    updater.stop()
    updater.is_idle=False

def stop(bot, update): #hardcoded for security only i can issue this command
    """ 
    Admin Command: stop the bot
    Usage:
        /stop
        
    """
    #global adminId
    logging.info('/stop,{},{}'.format(update.message.from_user.first_name,update.message.from_user.id))
    if(update.message.from_user.id==control.getAdminId()):
        bot.send_message(chat_id=update.message.chat_id, text="Stopping Server!")    
        threading.Thread(target=shutdown).start()
    else:
        bot.send_message(chat_id=update.message.chat_id, text="ERROR: Unauthorized User!")

def addIoTUser(bot,update,args):
    """ 
    Admin Command: add users manually
    Usage:
        /add 12345 324567 8726251
        
        The numbers are ids of users
        
    """
    control.addIoTUser(bot,update,args)

        
        
def removeIoTUser(bot,update,args):
    """ 
    Admin Command: remove users manually
    Usage:
        /rm all
        /rm 123445
    """
    control.removeIoTUser(bot,update,args)

def banIoTUser(bot,update,args):
    """
          Admin Command: ban user
          /ban status
          /ban add 12345
          /ban rm 12345
          
    """
    
    control.banIoTUser(bot,update,args)
        

def fetchIoTUserList(bot,update):
    
    """ 
    Admin Command: add users manually
    Usage:
        /fetch
        
    """
    control.fetchIoTUserList(bot,update)

                    

def disable(bot,update,args):
    
    """ 
    Admin Command: disable functions in button menu
    Usage:
        /disable 1  (for pic)
        /disable 2  (for water)
        /disable 3  (for light)
        /disable 4  (for video)
        /disable all (disable all)
        
    """
    control.disable(bot,update,args)

    

def setAwb(bot,update, args):
    
    """
    Admin function: set white balance
    Usage:
        /set 1.0 1.3 (red,blue)
    
    """
    control.setAwb(bot,update,args)

            
def setExp(bot,update, args):
    
    """
    Admin function: set white balance
    Usage:
        /setExp auto [auto, sports, night]
    https://picamera.readthedocs.io/en/release-1.10/api_camera.html?highlight=exposure_mode#picamera.camera.PiCamera.exposure_mode
    """
    control.setExp(bot,update,args)


def setLimit(bot,update,args):
    
    """
    Admin function: set time limits
    Usage:
        /setLimit pic 2.0
        /setLimit water 5.0
         
    """
    control.setLimit(bot,update,args)
   
                     
        
#def clear(bot,update,chat_data):
#    chat_data.clear()

    
       
    
####____global variables____#########
 


#Kill ServoBlaster - interferes with GPIO #something specific to me
###comment this out if you dont have servo blaster
try:
    os.system("sudo killall servod")      
except Exception as e:
    print(e)
    pass
############ #comment ends
    
#####____HANDLERS_____#######
#bot examples: https://github.com/python-telegram-bot/python-telegram-bot/tree/master/examples
start_handler = CommandHandler('start', start)
stop_handler = CommandHandler('stop', stop)
#menu_handler = CommandHandler('menu', menu)
addHandler = CommandHandler('add',addIoTUser, pass_args=True)
removeHandler = CommandHandler('rm',removeIoTUser,pass_args=True)
banHandler = CommandHandler('ban',banIoTUser,pass_args=True)
fetchHandler = CommandHandler('fetch',fetchIoTUserList)
disable_Handler = CommandHandler('disable',disable,pass_args=True)
awbHandler = CommandHandler('setawb',setAwb,pass_args=True)
expModeHandler = CommandHandler('setexp',setExp,pass_args=True)
setLimitHandler = CommandHandler('setLimit',setLimit,pass_args=True)
#clearHandler = CommandHandler('clear',clear,pass_chat_data=True)
unknown_handler= MessageHandler(Filters.command, unknown)

#####____DISPATCHERS_____#######
dispatcher.add_handler(start_handler)
dispatcher.add_handler(stop_handler)
#dispatcher.add_handler(menu_handler)
dispatcher.add_handler(addHandler)
dispatcher.add_handler(removeHandler)
dispatcher.add_handler(banHandler)
dispatcher.add_handler(fetchHandler)
dispatcher.add_handler(disable_Handler)
dispatcher.add_handler(awbHandler)
dispatcher.add_handler(expModeHandler)
dispatcher.add_handler(setLimitHandler)
dispatcher.add_handler(CallbackQueryHandler(button))

#dispatcher.add_handler(clearHandler)
dispatcher.add_handler(unknown_handler) #Always keep unkown handler last else commands not recognized
#start the bot client - poll for server messages
updater.start_polling()
updater.idle()