Arduino Bike Alarm Meets Android App Via Bluetooth

by RestlessPedals in Circuits > Arduino

61 Views, 2 Favorites, 0 Comments

Arduino Bike Alarm Meets Android App Via Bluetooth

instructables.png

I created this Arduino-based bike alarm for my cycling trips to keep my bike secure overnight while camping. It provides peace of mind by alerting me on my phone if any movement is detected.

An older version of the Arduino alarm only had a buzzer and that made it difficult to hear it. Since I added the Android app to the project, it is much better. I can start/stop the detection from my phone, control the settings, get alerts if the battery on Arduino runs low or if communication is lost.

The instructions in this article are for the Arduino bike alarm. The Android app is available for download here.

Supplies

Arduino board

Preferably you should use Pro mini 3.3V, but you could really use any compatible board with few mentions.

3.3V vs 5V: 3.3V consumes less power which improves battery life. If you use 5V, you should use a voltage divider on the BLE module's RX, since it is not 5V tolerant.

Interrupt pins: If you use a different board, make sure to use interrupt capable pins for the ball switch and BLE module's TX. To conserve power, the board will enter sleep mode, and these two inputs must trigger the watchdog to ensure it detects all alarms and Bluetooth communications.

Ball switch: I used and recommend the SW-420, as it is highly sensitive and the code is designed to handle multiple rapid triggers. If you choose a different sensor, you may need to adjust the code accordingly. An active sensor, such as an accelerometer, is not an option for this low-power setup.

Bluetooth LE module: Tested with an HM-10 module, but could potentially work with any LE module that has the service UUID 0xFFF0, characteristic 0xFFF1 and supports notifications. Let me know in the comments if you've used different hardware.


Components

  1. Arduino Pro Mini 3.3V
  2. HM-10 BLE 4.0 Bluetooth module or compatible (Android app is hard linked to characteristics of this model - FFE0/FFE1)
  3. Buzzer
  4. SW-420 ball switch
  5. Mini DC-DC boost converter to 5V or similar
  6. resistors (1x~220Ω for buzzer, 1x~10kΩ and 2xlarge (100kΩ - 1MΩ) for reading the battery level)
  7. 3.7V battery

Wiring

Screenshot_20250324_165750.png

Follow the diagram to connect the wires. You may use different pins, if you update the code accordingly, but make sure the ball switch and BLE module's TX are connected to interrupt capable pins. This is important, so the Arduino board will wake from sleep when an alarm occurred or a command from the app is sent.

Resistors R3 and R4 should be large to avoid unnecessary battery drain. I have used 1MΩ resistors. Resistor R2 should be much lower than R3/R4, around 10 KΩ is fine. If you don't have resistors, you can build the project without, but you won't receive low battery alerts on your phone. R1 is also optional, but recommended.

Communication Codes Explained

One byte commands are used to communicate with the Android app. Some are ingress (e.g. mute command coming from Android), others are egress (e.g. alarm sent to Android). Ingress commands also have acknowledgment responses, to inform Android that the command was received and executed.

Ingress:

  1. CMD_START and CMD_STOP to start/stop detection
  2. CMD_PING to test connection. Android expects to receive CMD_PONG
  3. CMD_BEEP simulate an alarm on Arduino without sending CMD_ALARM to Android
  4. CMD_READ_CONFIG send to Android the current configuration (sensibility, duration, etc)
  5. CMD_SAVE_CONFIG persist config variables (sensibility, duration, etc) on Arduino
  6. CMD_MUTE_ON, CMD_MUTE_OFF mute buzzer (not the Android alarm)
  7. CMD_BEACON_ON, CMD_BEACON_OFF toggle the use of beacon signals
  8. CMD_DURATION to configure the alarm (buzzer) duration
  9. CMD_LOW, CMD_MED, CMD_HIGH to configure the alarm trigger sensitivity

Egress:

  1. CMD_PONG response to CMD_PING
  2. CMD_BEACON send beacon signal to let the Android app know the system is functional
  3. CMD_ALARM when movement is detected
  4. CMD_LOW_BATTERY when device battery is low
  5. response to any ingress command, calculated as ingress_command - 8
// ingress commands
#define CMD_START 0xFF // start movement detection
#define CMD_STOP 0xFE // stop movement detection
#define CMD_PING 0xFC // test connection
#define CMD_BEEP 0xFB // ring alarm
#define CMD_LOW 0xED // sensitivity
#define CMD_MED 0xEE // sensitivity
#define CMD_HIGH 0xEF // sensitivity
#define CMD_SAVE_CONFIG 0xAA // saves config variables (sensibility, duration, etc)
#define CMD_MUTE_ON 0xAB // mute the alarm
#define CMD_MUTE_OFF 0xAC
#define CMD_READ_CONFIG 0xAD // send to android app the current configuration (sensibility, duration, etc)
#define CMD_BEACON_ON 0xEB // send beacon at regular intervals
#define CMD_BEACON_OFF 0xEC
#define CMD_DURATION 0xB8 //0xB8 - 0xBF alarm duration

// egress commands
#define CMD_PONG 0xFD // response to CMD_PING
#define CMD_BEACON 0xEA // send beacon signal to let the android app know the system is functional
#define CMD_ALARM 0xFA
#define CMD_LOW_BATTERY 0xDC
// Also, ACK signal for ingress commands, as CMD - 8

Programming Arduino

We will use LowPower.h library to put the device to sleep and extend battery life. The library EEPROM.h is used to persist the selected configuration. Finally, we will connect to the Bluetooth module using SoftwareSerial.h.

#include <SoftwareSerial.h>
#include <LowPower.h>
#include <EEPROM.h>


First, we configure the pins. Here you can edit if you are using different wiring connections.

#define BLE_TX 3 // HM-10 TX pin connected to Arduino pin 3
#define BLE_RX 9 // HM-10 RX pin connected to Arduino interrupt pin 9
#define BUZZER_PIN 6
#define SENSOR_PIN 2 // ball sensor on interrupt pin
#define BATTERY_PIN A0 // measure battery level


Here you can change the ratio between sensitivity levels. They are relative to each other, so the numbers don't really matter, but it is best to leave HIGH_SENS_FACTOR as 1 and customize the other accordingly.

// customize low, med and high sensibility levels
#define LOW_SENS_FACTOR 5
#define MED_SENS_FACTOR 3
#define HIGH_SENS_FACTOR 1


You may want to tweak the low battery threshold here, according to your battery voltage.

// For a 3.7V battery, 3.2V would be low voltage. Since the voltage divider
// has equal resistors, the voltage read is half, so 1.6V
#define LOW_BATTERY_THRESHOLD 1.6 // for the 3.3V model


Define config variables.

// config vars
boolean sendBeacon = false;
boolean isDetectionActive = true;
boolean isMuted = false;
unsigned short int alarmDuration = 1500;
unsigned char sensitivity = 1;

// write buffer
String buffer;


To store the configuration in memory, we need to define memory addresses for each variable. Beacon and muted are boolean variables, so they fit in one byte, thus the memory address of ADDR_MUTED is just 1 byte more than ADDR_BEACON. Sensitivity is a unsigned char, thus it can also be stored on one byte. Duration is short int, so it is stored on 2 bytes, memory address 0x3 - 0x4.

// Addresses in EEPROM to store variables
#define ADDR_BEACON 0
#define ADDR_MUTED 1
#define ADDR_SENSITIVITY 2
#define ADDR_DURATION 3


Flags are used to disable the watchdog's response during normal operations, such as processing a command or alarm, to prevent it from continuously triggering.

// interrupt flags
volatile bool alarmInterrupt = false;
volatile bool rxInterrupt = false;

// ball sensor is very sensitive, on a slight move it could trigger tens of times
// The number of interrupts is directly linked to the alarm sensibility level
volatile unsigned long ballMovement = 0;


Define callback functions to handle interrupts. The ballMovement counter is what determines the sensitivity. Alarms will not trigger unless this variable is within an expected range.

// interrupt ISR
void wakeUpOnRX() {
rxInterrupt = true;
}

// interrupt ISR
void detectAlarm() {
ballMovement += 1;
alarmInterrupt = true;
}


Setting up the pins, interrupts and loading the config from EEPROM.

void setup() {
pinMode(LED_BUILTIN, OUTPUT);
pinMode(SENSOR_PIN, INPUT_PULLUP); // Watchdog pin to wake up on movement
pinMode(BLE_TX, INPUT_PULLUP); // Watchdog pin to wake up on BLE comms
pinMode(BATTERY_PIN, INPUT); // battery level
pinMode(BLE_RX, OUTPUT); // BLE comms
pinMode(BUZZER_PIN, OUTPUT); // piezzo buzzer
digitalWrite(BUZZER_PIN, HIGH);
attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), detectAlarm, FALLING);
attachInterrupt(digitalPinToInterrupt(BLE_TX), wakeUpOnRX, FALLING);

buffer = "";
Serial.begin(9600); // Initialize Serial Monitor
BLE.begin(9600); // Initialize BLE communication

// load config vars
EEPROM.get(ADDR_BEACON, sendBeacon);
EEPROM.get(ADDR_MUTED, isMuted);
EEPROM.get(ADDR_SENSITIVITY, sensitivity);
EEPROM.get(ADDR_DURATION, alarmDuration);

validateEEPROMvars(); // if values from EEPROM are invalid, init with default

Serial.println("Starting..");
delay(200);
}


Parse incoming commands, execute and send ACK signals back to Android. The response codes and other egress commands are placed in a buffer and sent in one operation to prevent overwriting before Android has had a chance to read from Bluetooth.

void readIncoming() {
delay(500); // Allow buffer to fill, if BLE data is incoming
while (BLE.available()) {
byte command = BLE.read();
byte response = runCommand(command);

// send ACK signal back to the android app
if (response != 0x00) {
// confirm on Arduino side (blink builtin led)
digitalWrite(LED_BUILTIN, HIGH);
delay(400);
digitalWrite(LED_BUILTIN, LOW);

buffer += (char)response;
Serial.print("CMD: "); Serial.println(command, HEX);
}
}
}


This function sounds the buzzer in case of an alarm, or a test from Android, only if the buzzer isn't muted.

// ring alarm
void beep() {
if (isMuted) {
delay(alarmDuration);
return;
}
digitalWrite(BUZZER_PIN, LOW);
delay(alarmDuration);
digitalWrite(BUZZER_PIN, HIGH);
}


Executing the code for the first time will surely read gibberish from the EEPROM config storage. If this is the case, validateEEPROMvars() will initialize config values with defaults.

// if values read from EEPROM are not valid, initialize with default
void validateEEPROMvars() {
bool initVars = false;
if (sendBeacon != 0 && sendBeacon != 1) initVars = true;
if (isMuted != 0 && isMuted != 1) initVars = true;
if (sensitivity > 255) initVars = true;
if (alarmDuration % 250 != 0) initVars = true;

if (initVars) {
sendBeacon = false;
isMuted = false;
sensitivity = 1;
alarmDuration = 1500;
runSaveConfig();
}
}

void runSaveConfig() {
EEPROM.put(ADDR_BEACON, sendBeacon);
EEPROM.put(ADDR_MUTED, isMuted);
EEPROM.put(ADDR_SENSITIVITY, sensitivity);
EEPROM.put(ADDR_DURATION, alarmDuration);
Serial.println("Saved Config");
}


A special encoding was employed to send the config variables to Android in only 2 bytes.

The first encoded byte starts with 0x5- and carries muted and duration. Since duration takes values in the range 0-7, it fits on 3 bits (000 - 111). The fourth bit is the boolean (0 or 1) muted variable. Since a byte is made of 8 bits, the first 4 are the signature (5 in this case) and the other 4 carry the payload. So, an example for sensitivity = 2 (binary 10) and muted on (1), would make the encoded byte 0x56 (0101 for 5, 0110 for payload).

The second encoded byte starts with 0x6 and carries detection status, beacon status and sensitivity.

The Android app knows these bytes are special because no other commands start with 5 or 6.

byte getCurrentConfig() {
unsigned short int sensitivityEncoded;
if (sensitivity == LOW_SENS_FACTOR) sensitivityEncoded = 0;
if (sensitivity == MED_SENS_FACTOR) sensitivityEncoded = 1;
if (sensitivity == HIGH_SENS_FACTOR) sensitivityEncoded = 2;
unsigned short int durationEncoded = (alarmDuration / 250 - 1) % 8; // ensure durationEncoded takes only 3 bits
byte encodedByte1 = (5 << 4) | (isMuted << 3) | durationEncoded;
byte encodedByte2 = (6 << 4) | (isDetectionActive << 3) | (sendBeacon << 2) | sensitivityEncoded;

buffer += (char)encodedByte1;
buffer += (char)encodedByte2;
}

To explain how the bit encoding works, let's look at the first byte. The operator << is the bitwise shift left operator. The right operand represents how many bits to shift to the left. The number 5 (101 in binary) shifted left by 4, becomes 1010000 in binary. This clears out the last 4 bits for the payload.

encodedByte1 = (5 << 4) | (isMuted << 3) | durationEncoded

Duration is at most 7 (111 in binary), thus it is stored on 3 bits. This is why isMuted is shifted left by 3.

The | operator is the bitwise OR and preserves bits set to 1 in all the operands. Since 0 | 1 = 1 | 0 = 1 | 1 = 1,

1010000 | 1101 = 1011101.


When the time is right, the response(s) are sent to Android using SoftwareSerial write().

void sendBuffer() {
if (buffer.length() > 0) {
Serial.println(buffer.length());
BLE.write(buffer.c_str(), buffer.length());
buffer = ""; // Clear buffer after sending
BLE.flush();
delay(300);
}
}


The ingress commands are parsed and executed here and the ACK response is returned to signal that the command was executed.

byte runCommand(byte cmd) {
byte reponse = cmd - 8;
if (cmd >= CMD_DURATION && cmd <= CMD_DURATION + 7) {
alarmDuration = (cmd - CMD_DURATION + 1) * 250;
return reponse;
}
switch (cmd) {
case CMD_START: isDetectionActive = true; break;
case CMD_STOP: isDetectionActive = false; break;
case CMD_LOW: sensitivity = LOW_SENS_FACTOR; break;
case CMD_MED: sensitivity = MED_SENS_FACTOR; break;
case CMD_HIGH: sensitivity = HIGH_SENS_FACTOR; break;
case CMD_PING: buffer += (char)CMD_PONG; break;
case CMD_SAVE_CONFIG: runSaveConfig(); break;
case CMD_READ_CONFIG: getCurrentConfig(); break;
case CMD_BEEP: beep(); break;
case CMD_MUTE_ON: isMuted = true; break;
case CMD_MUTE_OFF: isMuted = false; break;
case CMD_BEACON_ON: sendBeacon = true; break;
case CMD_BEACON_OFF: sendBeacon = false; break;
default: reponse = 0x00; // No response for unknown commands
}

return reponse;
}


Next, we will look at the main loop. Treat the following code as part of loop() function.


Read battery level and report to Android when the level is below the low level threshold.

// read battery level
int adcValue = analogRead(BATTERY_PIN);
float voltage = (adcValue / 1023.0) * 3.3; // for 3.3V arduino
Serial.print(voltage);
Serial.println(" V");
delay(100);

// send low battery signal
if (voltage < LOW_BATTERY_THRESHOLD){
Serial.println("Low battery");
buffer += (char)CMD_LOW_BATTERY;
}


Read incoming commands, if any. BLE.available() will signal if new messages were received.

// read for incoming commands before sending signals back (low battery, beacon, alarm)
if (BLE.available() || rxInterrupt) {
readIncoming();
delay(100);
rxInterrupt = false;
}


Handle alarm detection.

// detect alarms
if (alarmInterrupt && isDetectionActive) {
// sensitivity * 5 determines how sensitive the movement detection is
if (sensitivity * 5 < ballMovement) {
Serial.println("ALARM!");
buffer += (char)CMD_ALARM;
beep();
}
ballMovement = 0;
alarmInterrupt = false;
}

if (!isDetectionActive)
ballMovement = 0;


If beacons are on, send beacon to Android. Beacons are signals that are sent regularly, even in the absence of other events, so the listening party is sure that the system is still operational.

if (sendBeacon){
buffer += (char)CMD_BEACON;
}


Finally, send to Android whatever is in the buffer and sleep to save power.

sendBuffer();

// low power sleep saves battery
LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);

Downloads

bikeangel.ino

The App or the Challenge

F3QU2SRM8N2UP03.jpg
Screenshot_20250321_191852_BikeAngel.jpg
Screenshot_20250321_191932_BikeAngel.jpg

Once your Arduino project is done, get the Android app to enjoy the benefits of your hard work. The app runs a foreground service that will monitor the connection to the Arduino device and notify on alarms, low battery or connection loss. It allows the user to remotely control the Arduino, start/stop the alarm detection, configure sensitivity or preferred ringtone, mute the alarm sound on either Arduino or Android without an impact on the actual notification.


If you don't want to use the app, I challenge you to make another Arduino project using similar hardware and change the code to allow communication between the two devices. You'll need to add a button for start/stop and optionally for beacon on/off and for mute on/off. The challenge is writing the code. The current ingress commands will become egress on the second device.


If you've made this project, write a comment to let me know useful did you find it.