IoT-1-Making LED light Switch ON and OFF Using “AT-09 BLE Module”, Arduino Uno & iPhone SE

Hello every one :). Hope you are doing good. We will discuss about communication over BLE between iPhoneSE and Arduino. We will control LED switch ON and OFF from iPhone over bluetooth.

Attached is the video of final output:


You should first read Bluetooth & Bluetooth fundamentalsdiscovering peripheralsconnecting peripherals for building strong fundamentals on BLE.


  • Download and install latest Arduino IDE from here. At the time of writing this blog it’s version is 1.8.5.
  • You must have latest version of XCode. At the time of writing this blog it is 9.3.1


  • I ordered AT-09 ble module (v4.0) from amazon.

    • iPhoneSE with iOS v11.3.
    • I ordered Arduino Uno kit from RoboIndia. Some other Arduino uno hardware which CAN work are:


Please support me by comment, like and share my face book page.


After successful installation of Arduino IDE launch it.

In editor window copy paste below code:

Let’s see what this code is doing:

The setup() function is called when a sketch starts. Use it to initialize variables, pin modes, start using libraries, etc. The setup() function will only run once, after each powerup or reset of the Arduino board.

The serial.begin()function sets the data rate in bits per second (baud) for serial data transmission. For communicating with the computer, use one of these rates: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, or 115200. The rate specifies how fast data is sent over a serial line.

The pinMode(pinNumber, OUTPUT)function can be used to decide at what pin number you want the output.

After creating a setup() function, which initializes and sets the initial values, theloop() function does precisely what its name suggests, and loops consecutively, allowing your program to change and respond. Use it to actively control the Arduino board.

Get the number of bytes (characters) available for reading, that’s what Serial.available() for.  This function check if there is some data available: function reads data received (“a” or “d”) from iPhone device in our case.

We use switch case to determine if data is “a” or  “d”.

digitalWrite(pinNumber, HIGH/LOW)function make our LED light ON or OFF on pin number 13.

All Set! Let’s upload code on Arduino Hardware.

Connect mac and Arduino with USB.

Make sure you have choose “Board:Arduino/Genuino Uno” and port “usbmodem1421Arduino/Genuino Uno”. Over all set up should look like this:

After uploading the code it’s time to setup circuit.

So the connections are as below:

Setting up BLE module

Connect RXD of A-9 BLE module -> TX of Arduino board.

Connect TXD of A-9 BLE module -> RX of Arduino board.

Connect VCC of A-9 BLE module -> 5V of Arduino board.

Connect GND of A-9 BLE module -> GND of Arduino board.

Setting up LED

Connect small leg of RED LED -> GND of Arduino board.

Connect big leg of RED LED -> Pin 13 of Arduino board.

Have a look at below circuit diagram:

Circuit Diagram

Yeah we have successfully set up our circuit. We are almost done setup for Arduino software and  and hardware.

Please support me by comment, like and share my face book page.

We are done half part till now. Let’s understand basic concept from iOS point of view and write some code.

Connection between BLE devices

I have used XCode v9.3.1, swift v4.3.1, iPhone iOS v11.3.1. If you are from non iOS background, then it might be difficult to understand code, but approach and logic is easy to understand. Some technical points:

Central : Our iOS device is central. It discovers services (which includes characteristics).

Peripheral : AT-09 BLE module is peripheral. We will use characteristics “FFE1” to write data “ON” and “OFF”.

CoreBluetooth Framework : In iOS this framework provides required classes and delegate methods to handle events like:

Discovering peripherals

Connecting peripherals

Discovering services

Discovering characteristics etc.

See below diagram how does BLE device connects to each other:

  • Bluetooth Central: This is the node that is trying to connect to a data source. Think of this as the client.
  • Bluetooth Peripheral: This is the node that is providing the primary data source. Think of this as the server.
  • Characteristic: A characteristic can be considered a variable. Characteristics are defined attribute types that contain a single logical value.
  • Service: A group of characteristics live under a “Service”. Services are collections of characteristics and relationships to other services that encapsulate the behavior of part of a device. Service are collection of data and associated behaviors describing a specific function or feature of a peripheral. For example, a heart rate sensor has a Heart Rate service. A peripheral can have more than one service.
  • Descriptors are defined attributes that describe a characteristic value.
  • Each service and characteristic is represented by a UUID which can be either a 16-bit or a 128-bit value.
  • Central’ Job
    • Scanning for peripherals
    • Connecting to a peripheral
    • Disconnecting from a peripheral
    • Discovering services
    • Discovering characteristics of a service
    • Subscribing to a characteristic
    • Receiving data from a characteristic
  • Peripheral’s Job
    • Advertising a service and characteristic
    • Adding service and characteristic to the PeripheralManager
    • Detecting of new subscribers to a characteristics
    • Detecting of unsubscribing
    • Handling of unready state of the device.

Note : Peripheral does not connect to peripheral. and central does not connect to central.


Core Bluetooth :


The Core Bluetooth framework provides the classes needed for your apps to communicate with devices that are equipped with Bluetooth low energy wireless technology.

Do not subclass any of the classes of the Core Bluetooth framework. Overriding these classes is unsupported and results in undefined behavior.

class CBCentral

The CBCentral class represents remote central devices that have connected to an app implementing the peripheral role on a local device. That is, when you are implementing the peripheral role using the CBPeripheralManager class, centrals that connect to your local peripheral are represented as CBCentral objects. Remote centrals are identified by universally unique identifiers (UUIDs), represented by NSUUID objects.

scan for other peripherals

Central devices scan for any advertising peripherals and displays it to the user

A central typically uses the information served up by peripherals to accomplish some particular task.

  • A central is kinda like the “boss”. It wants information from a bunch of its workers in order to accomplish a particular task.

It defines logic behind the Core bluetooth communication. It is able to scan, connect and disconnect peripherals and it also consumes information available at each peripheral. The central devices are usually mobile devices or tablets.

class CBPeripheral

The CBPeripheral class represents remote peripheral devices that your app—by means of a central manager (an instance of CBCentralManager)—has discovered advertising or is currently connected to. Peripherals are identified by universally unique identifiers (UUIDs), represented by NSUUID objects. Peripherals may contain one or more services or provide useful information about their connected signal strength.

advertise information as peripheral

  • A peripheral is kinda like the “worker”. It gathers and publishes data to that is consumed by other devices/means central.

The device that has information to share eg. Heart rate or temperature etc. The information can be pushed or advertise over the air.The peripheral devices are things like Heart rate monitor, BLE enables proximity tags, etc.

The following image defines the relationship between central and peripherals:

In the above scenario iOS devices (Central) communicate with the Heart rate Monitoring system (Peripheral) to get heart rate information and shows it on a device.

How Centrals Communicate with Peripherals?

Advertising is the primary way that peripherals make their presence known via Bluetooth LE.

In addition to advertising their existence, advertising packets can contain some data, such as the peripheral’s name. It can also include some extra data related to what the peripheral collects. For example, in the case of a heart rate monitor, the packet also provides heartbeats per minute (BPM) data.

The job of a central is to scan for these advertising packets, identify any peripherals it finds relevant, and connect to individual devices for more information.

class CBService

CBService and its subclass CBMutableService represent a peripheral’s service—a collection of data and associated behaviors for accomplishing a function or feature of a device (or portions of that device). CBService objects in particular represent services of a remote peripheral device (represented by a CBPeripheral object). Services are either primary or secondary and may contain a number of characteristics or included services (references to other services).

A CBPeripheral holds services (each defined as a CBService), and each CBService holds CBCharacteristics.

The following diagram shows the hierarchy of the CBPeripheral:

Let’s code now:

Below is the user interface part:

I will discuss some critical code only here which is very important to understand:

In Below code snippet we are initializing CBCentralManager and telling that CBCentralManager object’s(which is manager)  delegate is self (means we will implement delegate methods in ViewController class). The discover peripheral method is called when we click on “Discover Devices Button”

After successfully discover below delegate method didDiscoverPeripheral will be called:

We check if peripheral name is “MLT-05”, We show this information on user interface: 

Next, we hold reference of discovered peripheral in global variable and this time set peripheral’s delegate to self:

And after discovering peripheral we stop scanning.

Overall above code looks like this:

Yeah successfully discovered 🙂 🙂 🙂

Let’s connect now:

The below method will be called when user clicks on Connect button.

The code:

will call

Let’s see it’s implementation:

isMyPeripheralConected – this is the global variable we are holding reference to.

We are setting instance of view controller (self) as delegate of peripheral.

and then let’s discover characteristics after discovered services:

peripheral.discoverCharacteristics will call delegate methoddidDiscoverCharacteristicsFor:

In above code we are holding discover characteristic “FFE1” in global variable myCharacteristic. At this stage we can write  “a” and “d” for “ON” and “OFF” respectively.

Above methods are called when we click on ON and OFF buttons on iOS app.

The below method is responsible to send “a” (click on ON) and “d” (click on OFF) as bytes to our Arduino.

Putting all code together looks like :


Mistakes/Challenges I faced:

  • I ordered HC-05 module from Amazon which iPhone does not support.
  • While uploading code to Arduino hardware make sure there is no connection to LED and BLE Module. Upload Arduino code first then setup your circuit.
  • Finding peripheral characteristic value (FFE1) to write value (“a” for “ON” & “d” for “OFF”).

Happy coding, hope you enjoyed it :).

Please support me by comment, like and share my face book page.