HC-SR04 Micro:bit Project Servo motor

Realization of a radar controlled by Micro:bit

30-10-21 2995

Radar (Radio Detection And Ranging) is a technology that uses radio waves to detect the range, speed, and angle of objects. It works by emitting a radio frequency (RF) signal and measuring the time it takes for the signal to bounce back from an object. The distance, speed, and angle of the object can be calculated by measuring the time it takes for the signal to travel to the object and back, and then using the speed of light to determine the distance.

Radar systems can be used for a wide range of applications, such as:

Air and maritime navigation: radar systems are used to detect and track ships and airplanes.
Weather forecasting: radar systems are used to detect precipitation, wind patterns and other weather conditions.
Military applications: radar systems are used to detect and track aircraft, ships, and other military targets.
Law enforcement: radar systems are used to detect and measure the speed of vehicles on the road.
Industrial and scientific applications: radar systems are used to detect and measure the distance of objects in a variety of industrial and scientific applications such as in robotics, robotics and autonomous vehicles.

Radar systems can be classified into different types based on their operating frequency, such as X-band, S-band, and L-band radar. They can also be classified into different types based on their method of operation, such as pulse radar, continuous-wave radar, and frequency-modulated radar.

Objective of this project:

The Micro:bit card can be used in combination with a radar sensor to send data to a computer. The Micro:bit card can be programmed to collect data from the radar sensor and then transmit the data to the computer via USB Serial Communication. The computer can then receive the data and process it using software.

To accomplish this, the Micro:bit card needs to be connected to a radar sensor, such as a HC-SR04 ultrasonic sensor. The sensor can be configured to emit a radio-frequency (RF) signal and measure the time it takes for the signal to bounce back from an object. The distance, speed, and angle of the object can be calculated by measuring the time it takes for the signal to travel to the object and back.

The Micro:bit card can then be programmed to send the data collected from the radar sensor to the computer. On the computer side, a software program can be used to receive the data from the Micro:bit card. The program can be written in a variety of languages such as Python.

It’s a common way to create a wireless communication between an Micro:bit card, a HC-SR04 ultrasonic sensor and a computer, it’s simple to set up and it doesn’t require a specific operating system.

In this project, we will design a project using Micro:bit card and an ultrasonic sensor for detection.

This project aims to produce a prototype radar system that detects fixed and moving objects.

Radar operation controlled by Microbit:

Components required

Microbit card

The Micro:bit is a small programmable computer that was developed by the BBC for use in education. It is about the size of a credit card and can be programmed using a variety of languages, including Python and JavaScript. The device has a built-in display, sensors, and buttons, and can be connected to other devices and the internet using Bluetooth or a USB connection. It is designed to be easy to use and is intended to teach basic programming concepts and encourage creativity and problem-solving skills.

Micro:bit GPIO card

The Micro:bit is a small programmable computer that was developed by the BBC for use in education. It has a number of built-in features such as a display, sensors, and buttons. However, the Micro:bit also has a number of General Purpose Input Output (GPIO) pins which can be used to connect to external devices.

A Micro:bit GPIO card is an add-on or expansion board that provides additional functionality to the Micro:bit by connecting to the device’s GPIO pins. These cards can provide additional sensors, displays, or other inputs and outputs, allowing the Micro:bit to interact with a wider range of external devices. Some examples of Micro:bit GPIO cards include those that provide additional inputs such as buttons or sensors, or outputs such as LEDs or motors.

HC-SR04 sensor

The HC-SR04 is a popular ultrasonic sensor that can be used to implement a basic radar system with an Micro:bit microcontroller. This sensor uses ultrasonic waves, which are sound waves with a frequency higher than the upper limit of human hearing, to measure distance.

To use the HC-SR04 sensor with an Micro:bit, it needs to be connected to the Micro:bit‘s digital pins. The sensor has four pins: Vcc, Trig, Echo and GND. The Vcc and GND pins are used to power the sensor, the Trig pin is used to trigger the sensor to send out an ultrasonic pulse, and the Echo pin is used to receive the reflected pulse.

The Micro:bit can be programmed to send a trigger signal to the Trig pin, and then measure the time it takes for the Echo pin to receive the reflected pulse. This time can be used to calculate the distance to an object.

The HC-SR04 sensor has a range of 2cm to 400cm and it’s accurate within 3mm. It can be used to detect and measure the distance of objects in a variety of applications, such as robotics, autonomous vehicles, and obstacle avoidance systems.

It’s a simple and low-cost way to add a distance measuring capability to an Micro:bit project, it’s easy to set up and it doesn’t require any additional components. However, it’s important to note that the sensor is affected by sound reflections and can give false readings, especially in noisy environments.

Servomotor

A servomotor is a type of motor that can be used to control the position of an object, such as a basic radar. To move the HC-SR04 using a servomotor, you would need to connect the servomotor to the sensor and use control signals to rotate the servomotor and move the sensor to different positions

Connecting wires

Wires are used to transmit electrical signals and power to various components such as motors, sensors, and microcontrollers. It’s important to properly route and secure the wires to prevent tangles and damage. There are several methods for doing this, including using cable ties, clamps, and wire looms. It’s also a good idea to use different colors or labeling to identify the different wires and their functions. When connecting wires in a robot, it’s important to follow proper safety procedures, such as using the correct wire stripper and connectors, and wearing protective equipment such as gloves and safety glasses.

Test plate

An electronic test plate is a type of laboratory equipment that is used to hold and organize electronic components or printed circuit boards (PCBs) during testing or analysis. It is similar to a traditional test plate, but it is designed specifically for electronic components.

Assembly:

To do the editing, we connected:

For the HC-SR04 sound sensor:

The VCC pin to the 3.3V pin of the Micro:bit
The Trig pin to the P2 pin of the Micro:bit
The ECHO pin to the P1 pin of the Micro:bit
The GND pin to the GND pin of the Micro: bit

For the servomotor:

red wire: power supply wire to be connected to the 5V terminal of the GPIO card
brown wire: wire to connect to the GND pin of the Micro:bit
Yellow: positioning signal wire connected to the P0 pin of the Micro:bit

Makecode Program:

Here is the makecode program which allows you to:

calculate the distance between the HC-SR04 sensor and the detected object
turn the servomotor
send data (servomotor position and distance) from the Micro: bit card to the computer.

Download program

Python program executed by the computer

# Python + Microbit-based Radar Plotter
#
# ** Works with any motor that outputs angular rotation
# ** and with any distance sensor (HC-SR04, VL53L0x,LIDAR)
#
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from matplotlib.widgets import Button
import serial,sys,glob
import serial.tools.list_ports as COMs
#
#
############################################
# Find Microbit ports, select one, then start communication with it
############################################
#

port1="COM19"
ser = serial.Serial(port1,baudrate=115200)
ser.flush() # clear the port
#
############################################
# Start the interactive plotting tool and
# plot 180 degrees with dummy data to start
############################################
#
fig = plt.figure(facecolor='k')
win = fig.canvas.manager.window # figure window
screen_res = win.wm_maxsize() # used for window formatting later
dpi = 150.0 # figure resolution
fig.set_dpi(dpi) # set figure resolution

# polar plot attributes and initial conditions
ax = fig.add_subplot(111,polar=True,facecolor='#006d70')
ax.set_position([-0.05,-0.05,1.1,1.05])
r_max = 100.0 # can change this based on range of sensor
ax.set_ylim([0.0,r_max]) # range of distances to show
ax.set_xlim([0.0,np.pi]) # limited by the servo span (0-180 deg)
ax.tick_params(axis='both',colors='w')
ax.grid(color='w',alpha=0.5) # grid color
ax.set_rticks(np.linspace(0.0,r_max,5)) # show 5 different distances
ax.set_thetagrids(np.linspace(0.0,180.0,10)) # show 10 angles
angles = np.arange(0,181,1) # 0 - 180 degrees
theta = angles*(np.pi/180.0) # to radians
dists = np.ones((len(angles),)) # dummy distances until real data comes in
pols, = ax.plot([],linestyle='',marker='o',markerfacecolor = 'w',
                 markeredgecolor='#EFEFEF',markeredgewidth=1.0,
                 markersize=10.0,alpha=0.9) # dots for radar points
line1, = ax.plot([],color='w',
                  linewidth=4.0) # sweeping arm plot

# figure presentation adjustments
fig.set_size_inches(0.96*(screen_res[0]/dpi),0.96*(screen_res[1]/dpi))
plot_res = fig.get_window_extent().bounds # window extent for centering
win.wm_geometry('+{0:1.0f}+{1:1.0f}'.\
                format((screen_res[0]/2.0)-(plot_res[2]/2.0),
                       (screen_res[1]/2.0)-(plot_res[3]/2.0))) # centering plot
fig.canvas.toolbar.pack_forget() # remove toolbar for clean presentation
fig.canvas.set_window_title('Microbit Radar')

fig.canvas.draw() # draw before loop
axbackground = fig.canvas.copy_from_bbox(ax.bbox) # background to keep during loop

############################################
# button event to stop program
############################################

def stop_event(event):
    global stop_bool
    stop_bool = 1
prog_stop_ax = fig.add_axes([0.85,0.025,0.125,0.05])
pstop = Button(prog_stop_ax,'Stop Program',color='#FCFCFC',hovercolor='w')
pstop.on_clicked(stop_event)
# button to close window
def close_event(event):
    global stop_bool,close_bool
    if stop_bool:
        plt.close('all')
    stop_bool = 1
    close_bool = 1
close_ax = fig.add_axes([0.025,0.025,0.125,0.05])
close_but = Button(close_ax,'Close Plot',color='#FCFCFC',hovercolor='w')
close_but.on_clicked(close_event)

fig.show()

############################################
# inifinite loop, constantly updating the
# 180deg radar with incoming Microbit data
############################################
#
start_word,stop_bool,close_bool = True,False,False
while True:
    try:
        if stop_bool: # stops program
            fig.canvas.toolbar.pack_configure() # show toolbar
            if close_bool: # closes radar window
                plt.close('all')
            break
        ser_bytes = ser.readline() # read Microbit serial data
        decoded_bytes = ser_bytes.decode('utf-8') # decode data to utf-8
        #data =ser_bytes.decode('utf-8')
        #print(data.split(','))
        data = (decoded_bytes.replace('\r','')).replace('\n','').replace(' ','')
        #print(data.split(','))
        if start_word:
            vals = [float(ii) for ii in data.split(',')]
            print(vals)
            if len(vals)<2:
                continue
            angle,dist = vals # separate into angle and distance
            if dist>r_max:
                dist = 0.0 # measuring more than r_max, it's likely inaccurate
            dists[int(angle)] = dist
            if angle % 5 ==0: # update every 5 degrees
                pols.set_data(theta,dists)
                fig.canvas.restore_region(axbackground)
                ax.draw_artist(pols)

                line1.set_data(np.repeat((angle*(np.pi/180.0)),2),
                   np.linspace(0.0,r_max,2))
                ax.draw_artist(line1)

                fig.canvas.blit(ax.bbox) # replot only data
                fig.canvas.flush_events() # flush for next plot
        else:
            if data=='Radar Start': # stard word on Arduno
                start_word = True # wait for Microbit to output start word
                print('Radar Starting...')
            else:
                continue

    except KeyboardInterrupt:
        plt.close('all')
        print('Keyboard Interrupt')
        break

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

# Python + Microbit-based Radar Plotter

# ** Works with any motor that outputs angular rotation

# ** and with any distance sensor (HC-SR04, VL53L0x,LIDAR)

import numpy as np

import matplotlib

matplotlib.use('TkAgg')

import matplotlib.pyplot as plt

from matplotlib.widgets import Button

import serial,sys,glob

import serial.tools.list_ports as COMs

############################################

# Find Microbit ports, select one, then start communication with it

############################################

port1="COM19"

ser = serial.Serial(port1,baudrate=115200)

ser.flush() # clear the port

############################################

# Start the interactive plotting tool and

# plot 180 degrees with dummy data to start

############################################

fig = plt.figure(facecolor='k')

win = fig.canvas.manager.window # figure window

screen_res = win.wm_maxsize() # used for window formatting later

dpi = 150.0 # figure resolution

fig.set_dpi(dpi) # set figure resolution

# polar plot attributes and initial conditions

ax = fig.add_subplot(111,polar=True,facecolor='#006d70')

ax.set_position([-0.05,-0.05,1.1,1.05])

r_max = 100.0 # can change this based on range of sensor

ax.set_ylim([0.0,r_max]) # range of distances to show

ax.set_xlim([0.0,np.pi]) # limited by the servo span (0-180 deg)

ax.tick_params(axis='both',colors='w')

ax.grid(color='w',alpha=0.5) # grid color

ax.set_rticks(np.linspace(0.0,r_max,5)) # show 5 different distances

ax.set_thetagrids(np.linspace(0.0,180.0,10)) # show 10 angles

angles = np.arange(0,181,1) # 0 - 180 degrees

theta = angles*(np.pi/180.0) # to radians

dists = np.ones((len(angles),)) # dummy distances until real data comes in

pols, = ax.plot([],linestyle='',marker='o',markerfacecolor = 'w',

markeredgecolor='#EFEFEF',markeredgewidth=1.0,

markersize=10.0,alpha=0.9) # dots for radar points

line1, = ax.plot([],color='w',

linewidth=4.0) # sweeping arm plot

# figure presentation adjustments

fig.set_size_inches(0.96*(screen_res[0]/dpi),0.96*(screen_res[1]/dpi))

plot_res = fig.get_window_extent().bounds # window extent for centering

win.wm_geometry('+{0:1.0f}+{1:1.0f}'.\

format((screen_res[0]/2.0)-(plot_res[2]/2.0),

(screen_res[1]/2.0)-(plot_res[3]/2.0))) # centering plot

fig.canvas.toolbar.pack_forget() # remove toolbar for clean presentation

fig.canvas.set_window_title('Microbit Radar')

fig.canvas.draw() # draw before loop

axbackground = fig.canvas.copy_from_bbox(ax.bbox) # background to keep during loop

############################################

# button event to stop program

############################################

def stop_event(event):

global stop_bool

stop_bool = 1

prog_stop_ax = fig.add_axes([0.85,0.025,0.125,0.05])

pstop = Button(prog_stop_ax,'Stop Program',color='#FCFCFC',hovercolor='w')

pstop.on_clicked(stop_event)

# button to close window

def close_event(event):

global stop_bool,close_bool

if stop_bool:

plt.close('all')

stop_bool = 1

close_bool = 1

close_ax = fig.add_axes([0.025,0.025,0.125,0.05])

close_but = Button(close_ax,'Close Plot',color='#FCFCFC',hovercolor='w')

close_but.on_clicked(close_event)

fig.show()

############################################

# inifinite loop, constantly updating the

# 180deg radar with incoming Microbit data

############################################

start_word,stop_bool,close_bool = True,False,False

while True:

try:

if stop_bool: # stops program

fig.canvas.toolbar.pack_configure() # show toolbar

if close_bool: # closes radar window

plt.close('all')

break

ser_bytes = ser.readline() # read Microbit serial data

decoded_bytes = ser_bytes.decode('utf-8') # decode data to utf-8

#data =ser_bytes.decode('utf-8')

#print(data.split(','))

data = (decoded_bytes.replace('\r','')).replace('\n','').replace(' ','')

#print(data.split(','))

if start_word:

vals = [float(ii) for ii in data.split(',')]

print(vals)

if len(vals)<2:

continue

angle,dist = vals # separate into angle and distance

if dist>r_max:

dist = 0.0 # measuring more than r_max, it's likely inaccurate

dists[int(angle)] = dist

if angle % 5 ==0: # update every 5 degrees

pols.set_data(theta,dists)

fig.canvas.restore_region(axbackground)

ax.draw_artist(pols)

line1.set_data(np.repeat((angle*(np.pi/180.0)),2),

np.linspace(0.0,r_max,2))

ax.draw_artist(line1)

fig.canvas.blit(ax.bbox) # replot only data

fig.canvas.flush_events() # flush for next plot

else:

if data=='Radar Start': # stard word on Arduno

start_word = True # wait for Microbit to output start word

print('Radar Starting...')

else:

continue

except KeyboardInterrupt:

plt.close('all')

print('Keyboard Interrupt')

break

You can also see

Obstacle avoiding robot using Micro:bit

09-02-23

Water level measurement system controlled by Micro:bit

23-05-22

1 commentaire

Andrew Morgan 02-09-2323

Excelent Please advise where I can access the code to display the data on the computer. Kind regards Andrew

Annuler la réponse

Scroll to Top

Realization of a radar controlled by Micro:bit

Objective of this project:

Radar operation controlled by Microbit:

Components required

Assembly:

Makecode Program:

Python program executed by the computer

You can also see

Obstacle avoiding robot using Micro:bit

Water level measurement system controlled by Micro:bit

1 commentaire

Andrew Morgan 02-09-2323

Leave a comment

Annuler la réponse

Recent tutorials

Using the OV7670 camera with the Arduino UNO board

Video Streaming Web Server with ESP32-CAM

Connect Arduino UNO to Wifi network using ESP8266 module

View location data sent by NEO-M6 GPS using ESP32 board

Most viewed tutorials

Control a water pump by Arduino

Display text on the I2C LCD 1602A display with Arduino

Control a buzzer by the ESP32 card

Control a DC motor with Micro:bit

Most commented tutorials

Send data (temperature and humidity) to the Thingspeak site with Arduino

Order a car equipped with ESP32-CAM via a wifi connection

Display text on the I2C LCD 1602A display with Arduino

Control a thermal printer with Arduino