Created February 9, 2020 © GPL3+

Sensors Detecting Human Body on a ROS Self-Driving Mini Car

I have thought of creating a sensory array to detect the human body in order to use it in robotics and other application.

AdvancedFull instructions provided3 days870

2nd Place

Make Sense of Our Proximity Sensor

Sensors Detecting Human Body on a ROS Self-Driving Mini Car

Things used in this project

Hardware components

KEMET Electronics Corporation SS-430L-BK

KEMET Electronics Corporation C0603C105K4PACTU

KEMET Electronics Corporation C0603C104J5RACTU

SMT-1640-S-R

NXP PESD5V0L2BT

Broadcom HLMP-K105

Broadcom HLMP-1540

Broadcom HLMP-1440

S4B-XH-A (LF)(SN)

Amphenol 10118194-0001LF

Panasonic ERJ-3EKF1001V

MC0063W0603122R

Vishay CRCW06032K20FKEAC

Cypress CY8C3866PVI-021

Texas Instruments LM3480IM3-3.3/NOPB

XHP-4

BXH-001T-P0.6

SHR-05V-S-B

SH3-SH3-28150

Custom PCB

Software apps and online services

ROS Robot Operating System

Cypress PSoC Creator

Hand tools and fabrication machines

Soldering Station Power Supply, For Weller WX Soldering System

Story

Introduction

I have thought of creating a sensory system to be put on a self-driving mini toy car. This mini toy car is controlled by a Raspberry Pi 3 on which I have installed the ROS (Robot Operating System).

1 / 4 • Self-driving mini toy car

Step One: K-board

The sensory system is composed of three KEMET SS-430L-BK sensors rotated by 70° in order to have a greater surveillance area and understand if the person is moving from right to left or vice versa.

I have designed an electronic board (I have called it “K-board”) with a Cypress PSoC CY8C3866PVI-021 48-SSOP microcontroller that reads the status of the three KEMET SS-430L-BK sensors.

K-board

I have associated a different colored LED to each sensor: it lights up when a person is detected. The K-board is equipped with a buzzer that emits an acoustic signal when one of the three sensors SS-430L-BK detects a person. The system also performs multiple detections; they consist in the simultaneous detection performed by two or three SS-430L-BK sensors.

K-board

The PSoC reads the status of the three KEMET SS-430L-BK sensors every 100ms. When a person is detected in front of the sensor, a beep is emitted from the buzzer and the respective LED lights up. The LEDs are red, green, and yellow. Red refers to sensor 1, green refers to sensor 2 and yellow refers to sensor 3. The beep has a duration of approximately 200ms and three different tones. The LEDs turn on for about 500ms.
The K-board is equipped with UART, I2C and USB. In this case I will use the USB to send an ASCII string with the state of the sensors to the Raspberry Pi 3. The string consists of five ASCII characters:

Kxyz\r

K : Start of string;

x : Sensor 1 status | 0 = no human body | 1 = human body;

y : Sensor 2 status | 0 = no human body | 1 = human body;

z : Sensor 3 status | 0 = no human body | 1 = human body;

\r : Carriage return | End of string.

The string will be sent with an interval of about 100ms.

Note. There is a small mistake in the text on PCB: I have reversed the abbreviation NC with GND on the connectors text of the KEMET SS-430L-BK sensors (see the image below).

5V = Power supply;
C = Comparator input;
GND = Ground;
NC = No connection.

Detail of a mistake in the text on K-board

I have attached the electrical schematic, the bill of materials and the Gerber files of the K-board, in order to give users the possibility to replicate it. In addition, I have attached the hexadecimal file to program the CY8C3866PVI-021 48-SSOP PSoC microcontroller. Finally for the most experienced people on PSoC I have attached the source code in C and the internal diagrams of the PsoC microcontroller.

1 / 2 • Internal diagram of the PsoC microcontroller

Step Two: Case

I have designed and printed in 3D an orange PLA case in order to fix the three KEMET SS-430L-BK sensors and the K-board. The case consists of two parts: the lower part which contains the hardware and the upper part which is the lid. In the lower part there are openings for the USB cable, for the buzzer and for three KEMET SS-430L-BK sensors. On the lid there are three holes from which the three LEDs come out.

Here attached you will find the two files that you need to 3D print the two parts of the case.

1 / 7 • Lower part of the case

Note (see the image below):

I have soldered the wires directly to the connector on KEMET SS-430L-BK.
I have used hot glue to fix the KEMET SS-430L-BK in the case.

Positioning of KEMET SS-430L-BK sensors

Detected area

Step Three: Robot Operating System

I have created a ROS node in Python that reads data sent by the K-board through the USB serial port and publishes them on three ROS Topics. The node is called "kemet" and the data rate is 10Hz. Topic names are kemet1, kemet2 and kemet3. The type of data published on the topics is unsigned int 16 and the values are one (0x01) or zero (0x00). The value one indicates the presence of one or more people. The kemet1 topic refers to sensor one of the K-board; kemet2 topic refers to sensor two of the K-board; kemet3 topic refers to sensor three of the K-board.

I have attached the source code of the kemet ROS node.

I have inserted the K-board on a self-driving mini toy car and I have created a simple algorithm that uses kemet1, kemet2 and kemet3 topics: if sensor 1 detects a human body the mini toy car rotates to the right; if sensor 3 detects a human body the mini toy car rotates to the left; if sensor 2 detects a human body the mini toy car stops.

1 / 3 • Execution of kemet ROS node

I have attached some videos explaining how it works.

Sensors detecting Human Body on a ROS Self-Driving mini Toy Car - demo 0

Sensors detecting Human Body on a ROS Self-Driving mini Toy Car - demo 1

Sensors detecting Human Body on a ROS Self-Driving mini Toy Car - demo 2

Future evolution

This system can be expanded by creating a matrix of sensors with different lenses and arranged for example on a hemisphere. This way you could have a larger surveillance area with different detection distances. Furthermore, other sensors of different type could be coupled to make the system more reliable and able to be certified, for example as Cat. 3 and PL.

That's all!

If you have any questions or suggestions don't hesitate to leave a comment below.

Sensors detecting Human Body on a ROS Self-Driving mini Toy Car - demo 3

Sensors detecting Human Body on a ROS Self-Driving mini Toy Car - demo 4

Sensors detecting Human Body on a ROS Self-Driving mini Toy Car - demo 5

Sensors detecting Human Body on a ROS Self-Driving mini Toy Car - demo 6

Schematics

Code

/* ========================================
 *
 * Copyright Mario Soranno, 2020
 * All Rights Reserved
 *
 * CONFIDENTIAL AND PROPRIETARY INFORMATION
 * WHICH IS THE PROPERTY OF Mario Soranno.
 *
 * ========================================
*/
#include "project.h"

#define loopAlarmValue 5    // 500ms
#define loopBeepValue 2     // 200ms

uint8 status = 0; 
uint8 loopAlarm1 = 0;
uint8 loopAlarm2 = 0;
uint8 loopAlarm3 = 0;
uint8 loopBeep = 0;
uint8 array_char[5];
uint8 ss430Stato1 = 0x30;
uint8 ss430Stato2 = 0x30;
uint8 ss430Stato3 = 0x30;

int main(void)
    {
    // Test LEDs and Buzzer
    LEDR_Write(1);
    LEDG_Write(0);
    LEDY_Write(0);
    CyDelay(500);
    LEDR_Write(0);
    LEDG_Write(1);
    LEDY_Write(0);
    CyDelay(500);
    LEDR_Write(0);
    LEDG_Write(0);
    LEDY_Write(1);
    CyDelay(500);
    LEDR_Write(0);
    LEDG_Write(0);
    LEDY_Write(0);
    CyGlobalIntEnable;
    // Peripherals initialization
    PWM_Start();
    PWM_WritePeriod(255);
    CyDelay(500);
    PWM_WritePeriod(0);
    CyDelay(50);
    USBUART_Start(0u, USBUART_5V_OPERATION);
    CyDelay(50);
    VDAC8_Start();
    Comp1_Start();
    Comp2_Start();
    Comp3_Start();
    for(;;)
        {
        if (0u != USBUART_IsConfigurationChanged())
            {
            if (0u != USBUART_GetConfiguration())
                {
                USBUART_CDC_Init();
                }
            }

        status = Status_Reg_Read();
        if((status & 0x01) == 0x01)
            {
            LEDR_Write(1);              // Red LED on
            loopAlarm1 = loopAlarmValue;// Update of countdown for LED off
            loopBeep = loopBeepValue;   // Update of countdown for Buzzer off
            ss430Stato1 = 0x31;         // Sensor status
            PWM_WritePeriod(255);       // Buzzer on - low frequency
            }
        else loopAlarm1--;


        if((status & 0x02) == 0x02)
            {
            LEDG_Write(1);              // Green LED on
            loopAlarm2 = loopAlarmValue;// Update of countdown for LED off
            loopBeep = loopBeepValue;   // Update of countdown for Buzzer off
            ss430Stato2 = 0x31;         // Sensor status
            PWM_WritePeriod(240);       // Buzzer on - medium frequency
            }
        else loopAlarm2--;

            
        if((status & 0x04) == 0x4)
            {
            LEDY_Write(1);              // Yellow LED on
            loopAlarm3 = loopAlarmValue;// Update of countdown for LED off
            loopBeep = loopBeepValue;   // Update of countdown for Buzzer off
            ss430Stato3 = 0x31;         // Sensor status
            PWM_WritePeriod(220);       // Buzzer on - high frequency
            }
        else loopAlarm3--;

 
        if(loopAlarm1 == 0) 
            {
            LEDR_Write(0);              // Red LED off
            ss430Stato1 = 0x30;
            }   
        if(loopAlarm2 == 0) 
            {
            LEDG_Write(0);              // Green LED off
            ss430Stato2 = 0x30;
            }  
        if(loopAlarm3 == 0) 
            {
            LEDY_Write(0);              // Yellow LED off
            ss430Stato3 = 0x30;
            }
        if(loopBeep == 0) PWM_WritePeriod(0); // Buzzer off
        else loopBeep--;   

        if(USBUART_GetConfiguration() != 0u)
            {                           // Send string on USB
            array_char[0] = 'K';
            array_char[1] = ss430Stato1;
            array_char[2] = ss430Stato2;
            array_char[3] = ss430Stato3;
            array_char[4] = '\r';
            USBUART_PutData(array_char,5);
            }
        CyDelay(100);
        }
    }

/* [] END OF FILE */

#!/usr/bin/env python

import serial
import rospy
from std_msgs.msg import UInt16
from time import sleep

if __name__ == '__main__':
	rospy.init_node('kemet')                                # ROS node name
	serdata = serial.Serial("/dev/ttyACM0", 9600) # serial port inizialization
	pub1 = rospy.Publisher("kemet1", UInt16, queue_size=10) # kemet1 ROS topic
	pub2 = rospy.Publisher("kemet2", UInt16, queue_size=10) # kemet2 ROS topic
	pub3 = rospy.Publisher("kemet3", UInt16, queue_size=10) # kemet3 ROS topic
	rate = rospy.Rate(10)   # ROS node rate = 10Hz
	while not rospy.is_shutdown():
		datain = serdata.read() # Read data from serial port
		sleep(0.05)
		numberdatain = serdata.inWaiting()
		datain += serdata.read(numberdatain)
		rospy.loginfo(datain)
		if datain[0] == 'K':  # data publication on ROS topics
			# rospy.loginfo("ok")
			msgKemet1 = ord(datain[1]) - 0x30
			pub1.publish(msgKemet1)
			msgKemet2 = ord(datain[2]) - 0x30
			pub2.publish(msgKemet2)
			msgKemet3 = ord(datain[3]) - 0x30
			pub3.publish(msgKemet3)
		else: # Error in data read
			rospy.loginfo("errore")
		rate.sleep()

Credits

Mario Soranno

9 projects • 24 followers

I have a Bachelor's Degree in Industrial Engineering - Electronics. I am an expert in hardware design, I can program in C/C++,Python and ROS

Comments

Awards

2nd Place

Make Sense of Our Proximity Sensor

Sensors Detecting Human Body on a ROS Self-Driving Mini Car