Amazing Open Source Raspberry Pi Pico 2 Synth, Cutting Edge Power over Skin Research, and much more!

0:00:00 / -

Watch now on YouTube Watch now

Micron Uv Robotic Arm

Made by ashokr / Communication / Displays / Fitness / Robotics / Sensors

About the project

An autonomous UV Robotic Arm handles cleaning, sanitizing surfaces in any environment.

Project info

Difficulty: Moderate

Platforms: Cypress, MikroElektronika

Estimated time: 6 days

License: Creative Commons Attribution-NonCommercial-NoDerivs CC BY-NC-ND version 4.0 or later (CC BY-NC-ND 4+)

Items used in this project

Hardware components

	Cypress CY8CKIT-044 PSoC® 4 M-Series Pioneer Kit	x 1
	SG90 Micro-servo motor	x 3
	MikroElektronika MikroE Eink Display	x 1
	LED (generic)	x 2
	Jumper wires (generic)	x 1
	Craft Wood	x 1

Software apps and online services

	Image2Lcd
	Cypress PSoC Creator

Hand tools and fabrication machines

	Hacksaw Blade	x 1
	Hot glue gun (generic)	x 1

Story

Introduction

UV plays a major role in fighting against the virus and bacteria. Already so many products came on the market to serve the purpose but still there are some gray areas where we cannot use existing products or UV lamps directly. I decided to serve those gray areas with an intelligent, autonomous and low cost solution is called "UV Robotic Arm"

What is UV Robotic Arm?

It's a normal robotic arm enhanced with UV LED'S and sensors.This UV Robotic Arm is autonomous, portable and multipurpose. It can be used in any environment to disinfect the virus.

Why UV Robotic Arm?

Today's situation everyone worries about safety and maintaining social distancing. There are many ways to take precautions like hand washing, sanitizer and avoid touching with hands etc. UV lights are one of the ways to disinfect the virus but mostly used in a closed environment due to safety reasons.

For example every office has printers, many people use the same printer and we cannot define a UV disinfection system for particular printers because printer design and sizes vary. This is the reason UV Robotic Arm came into picture where it can fit into any environment with flexibility. This UV can be aligned to any type of printer for disinfection with one time configuration.

Designing Robotic Arm

My Initial thought was to have 4 wheels rover with Robotic Arm but unfortunately could not get the components on time. Finally I decided to build only the robotic arm with 3DOF. I ordered craft woods from amazon and created the ARM body with the help of a hacksaw blade and glue gun. I used Ada-fruit SG92R servo motors in the Arm. Two normal LED's are mounted on the top of the Arm.

1 / 2

Microcontroller

This concept has a CapSense sensor so I chose the Cypress PSoC4M Series Kit. It comes with two CapSense Proximity sensors. To drive the Arm Servos I used 3 PWM channels. I used an E-ink display click module from Mikroe which is interfaced with PSoC4M through SPI. This display shows the Arm modes for configuration. All the wiring setup goes through normal pcb boards for servos and LED's. The coding was done from Cypress PSoC Creator.

EInk Pin conections:

MOSI - P6_0

CLK - P6_2

CS - P2_7

DC - P5_3

RES - P2_3

BSY - P1_0

Servosand LED's:

Servo1 - P2_1

Servo1 - P2_2

Servo1 - P2_3

GREEN LED - P2_0

RED LED - P0_6

UV Arm Configuration (Modes):

This UV Arm operates in multiple modes, in this demo I have used 3 modes of operation.

1. Table Mode

2. Printer Mode

3. Gym Mode

Based on these modes robotic Arm's positions will be configured. It depends are where we going to use this UV Arm. Example if I want to use it for Gym equipment the Arm movements will be adjusted to the equipment design. Robotic Arm is flexible to use at any angle position.

What are the main Features?

1. It's portable and can be used for any home appliance.

2. It can capable of doing routine task of cleaning (office workspace)

3. It's safe because it has sensors to detect the human presence

4. Robotic Arm is flexible to reach any hidden places.

5. Its capable to operate in any open environment

How it works?

This Arm is portable, let's say we mounted on the table. If someone is using or touching the table this robotic Arm's sensor detects that and waits for the user to leave. After the user leaves this UV Arm starts and disinfects the table surface. This is autonomous and configurable. Configuration things can be extended to wireless or cloud.

Its low cost design and it can be installed in many places like offices, shops, malls, schools, churches etc.

In the demo I have just shown working with one direction disinfection but in practical we can have multi direction to clean the surface precisely.

The working demo is here.

Schematics, diagrams and documents

Schematic

CAD, enclosures and custom parts

3D Concept Design

Go to download

Code

SPI Code

/* ========================================
 *
 * Copyright YOUR COMPANY, THE YEAR
 * All Rights Reserved
 * UNPUBLISHED, LICENSED SOFTWARE.
 *
 * CONFIDENTIAL AND PROPRIETARY INFORMATION
 * WHICH IS THE PROPERTY OF your company.
 *
 * ========================================
*/
#include "spi_comm.h"



uint16_t spi_write(uint8_t *data , uint32_t length)
{
   uint8 rxBuffer[2];
    uint8 dummyBuffer[2]={0};
   uint16 status;
    uint32 i;
  /* Start transfer */
    SPIM_SpiUartPutArray(data, length);
    

  // Wait for the transmission to complete

    while(0 != (SPIM_SpiUartGetTxBufferSize() | SPIM_SpiIsBusBusy()))

    {

    }
    
    return (status);

    
}


uint16 spi_read(uint8_t *data, uint8_t length)
{
    uint8 rxBuffer[2];
    uint16 status;
    uint32 i;
    
    SPIM_SpiUartClearRxBuffer();
    
    /* Start transfer */
    SPIM_SpiUartPutArray(data, length);

       
    /* Wait for the end of the transfer. The number of transmitted data
    * elements has to be equal to the number of received data elements.
    */
    while (length != SPIM_SpiUartGetRxBufferSize())
    {
    }
    /* Read data from the RX buffer */
    i = 0u;
    while (0u != SPIM_SpiUartGetRxBufferSize())
    {
        rxBuffer[i] = SPIM_SpiUartReadRxData();
        i++;
    }
    
    status = rxBuffer[1];
    status = status<<8;
    status |= rxBuffer[0];


    return (status);
}

Main Code

/* ========================================
 *
 * Copyright YOUR COMPANY, THE YEAR
 * All Rights Reserved
 * UNPUBLISHED, LICENSED SOFTWARE.
 *
 * CONFIDENTIAL AND PROPRIETARY INFORMATION
 * WHICH IS THE PROPERTY OF your company.
 *
 * ========================================
*/
#include "project.h"
#include "spi_comm.h"
#include "tle94112.h"
#include "pwm.h"
#include "ssd1608.h"
#include "images.h"

void TimerCounterStart();
void uv_config_table();
void uv_config_printer();
void uv_config_gym();
void uv_cleaning(uint8_t mode);
uint8_t motion_detected=0;
uint16_t debug[10];

uint8_t mode =0;

CY_ISR_PROTO(GPIOIsrHandler);

CY_ISR(GPIOIsrHandler)
{
    /* Clear pending Interrupt */
    isr_GPIO_ClearPending(); 
    
    SW1_ClearInterrupt();
    
  
   mode++;
   GLED_Write(1);
   if(mode >2) mode =0;

   switch(mode)
{
    case 0:  
    eink154_displayImage(gImage_epd_table);
    uv_config_table();
    break;
    case 1:
    eink154_displayImage(gImage_epd_print);
    uv_config_printer();
    break;
    case 2:
    eink154_displayImage(gImage_epd_gym);
    uv_config_gym();
    break;
}
    
}

CY_ISR(TC_InterruptHandler)
{
    /* Clears the Timer terminal count interrupt */
    Timer_ClearInterrupt(Timer_INTR_MASK_TC);
    
    GLED_Write(0);
    CyDelay(1000);
    uv_cleaning(0);
    uv_cleaning(0);
    CyDelay(1000);
    GLED_Write(1);
    
}

void uv_cleaning(uint8_t mode)
{ 
    setangle(0,0,60);
    CyDelay(1000);
    setangle(0,130,60);
    CyDelay(1000);    
}


void uv_config_table()
{
    setangle(0,60,60);
    setangle(1,150,60);
    setangle(2,80,60); 
    
}

void uv_config_printer()
{
    
    setangle(0,60,60);
    setangle(1,10,60);
    setangle(2,40,60);    
    
}

void uv_config_gym()
{
    
    setangle(0,60,60);
    setangle(1,90,60);
    setangle(2,100,60);    
    
}

void set_timeout(uint8_t mode)
{
    if(mode == 1)
    {
        RLED_Write(0);
        GLED_Write(1);
        motion_detected = 1;
    }
    else
    {
        RLED_Write(1);
        
        if(motion_detected)
        {
        TimerCounterStart();
        //clean
        motion_detected=0;
        }
    }
 		   
    
}


void TimerCounterStart()
{
    
    /* Starts the timer */
    Timer_Start();
    
    /* Enable interrupt component and set up handler */
    TC_Interrupt_StartEx(TC_InterruptHandler);
    
}

int main(void)
{
    
    	/* Proximity sensor state. */
	uint8 proximity  = INACTIVE;
    
	/* This variable is used to implement a software counter. If the value
	 * of this counter is greater than 100, the proximity sensor was inactive
	 * for more than 3s. */
	uint8 softCounter = RESET;

	/* Variable to store the WDT match value. */
	uint16 currentCountVal = ZERO;

	/* Variable to determine whether to update the WDT match value. */
	uint8 updateMatch = UPDATE_100MS;
    
    //isr_GPIO_Start();
    
      /* Sets up the GPIO interrupt and enables it */
    isr_GPIO_StartEx(GPIOIsrHandler);

    
    CyGlobalIntEnable; /* Enable global interrupts. */

    /* Place your initialization/startup code here (e.g. MyInst_Start()) */
    
       /* Start SPIS and SPIM components operation */
    SPIM_Start();
    
 /* Sets up the GPIO interrupt and enables it */

    PWM_1_Start();
    PWM_2_Start();

    DC_Write(1);
    RES_Write(1);
    
    
	/* Enable and start the CapSense block. */
	CapSense_Start();

	/* Initialize the baselines of all CapSense widgets. */
	CapSense_InitializeSensorBaseline(CapSense_SENSOR_PROXIMITYSENSOR_0__PROX);

    
    eink154_startConfig();
    eink154_setLut();
    eink154_displayImage(gImage_epd_table);
    

    while(1)
    {      
      
        
/* Update the baseline of the proximity sensor. */
		CapSense_UpdateSensorBaseline(CapSense_SENSOR_PROXIMITYSENSOR_0__PROX);

		/* Scan the proximity sensor. */
		CapSense_ScanSensor(CapSense_SENSOR_PROXIMITYSENSOR_0__PROX);

		/* Wait till the scan is complete*/
		while(CapSense_IsBusy())
		{
			/* Put the PSoC 4200M in Sleep power mode while the CapSense is scanning.
			 * The device wakes up using the interrupt generated by CapSense CSD Component
			 * after scanning. */
			CySysPmSleep();
		}

		/* Check if proximity sensor is active. */
		proximity = CapSense_CheckIsSensorActive(CapSense_SENSOR_PROXIMITYSENSOR_0__PROX);

		if(proximity == ACTIVE)
		{
			/* Set the LED at a brightness level corresponding
			 * to the proximity distance. */
			//LED1_SetBrightness(ON);
            set_timeout(1);
			/* Update the WDT if required. */
			if(updateMatch == UPDATE_30MS)
			{
				/* Configure the wake up period to 30ms and update WDT match value. */
		    	CySysWdtWriteMatch(CY_SYS_WDT_COUNTER0, WDT_MATCH_VALUE_30MS);

				/* Read the current count value of the WDT. */
			    currentCountVal = CySysWdtReadCount(CY_SYS_WDT_COUNTER0);

				/* Reset the counter if the count value is greater than
				 * the match value */
			    if (currentCountVal > WDT_MATCH_VALUE_30MS)
			    {
			        CySysWdtResetCounters(CY_SYS_WDT_COUNTER0_RESET);
				}

				/* Provide a delay to allow the changes on WDT register to take
				 * effect. This is approximately 4 LFCLK cycles. */
				CyDelayUs(ILOX4);

				/* Next update to the WDT match value is required only when
				 * switching to 100ms scan interval. */
				updateMatch = UPDATE_100MS;
			}

			/* Reset the software counter if proximity is detected. */
			softCounter = RESET;

			/* Put CPU in sleep mode after displaying output on LED. */
			//CySysPmSleep();
		}
		else /* Proximity sensor is inactive. */
		{
			/* Switch off the LED if proximity is not detected. */
			//LED1_SetBrightness(OFF);
            set_timeout(0); 
			/* Increment the software counter every 30ms if proximity is not detected. */
			softCounter++;

			/* Set the maximum limit for the soft counter. */
			if(softCounter >= MAX_VALUE)
			{
				/* Set the maximum limit for the softCounter. */
				softCounter = MAX_VALUE;

				/* Update the WDT if required. */
				if(updateMatch == UPDATE_100MS)
				{
					/* Proximity sensor is inactive for more than 3s.
					 * Increase Deep-Sleep duration to 100ms and update WDT match value. */
			    	CySysWdtWriteMatch(CY_SYS_WDT_COUNTER0, WDT_MATCH_VALUE_100MS);

					/* Read the current count value of the WDT. */
				    currentCountVal = CySysWdtReadCount(CY_SYS_WDT_COUNTER0);

					/* Reset the counter if the count value is greater than
					 * the match value */
				    if (currentCountVal > WDT_MATCH_VALUE_100MS)
				    {
				        CySysWdtResetCounters(CY_SYS_WDT_COUNTER0_RESET);
					}

					/* Provide a delay to allow the changes on WDT register to take
					 * effect. This is approximately 4 LFCLK cycles. */
					CyDelayUs(ILOX4);

					/* Next update to the WDT match value is required only when
					 * switching to 30ms scan interval. */
					updateMatch = UPDATE_30MS;
				}
			}        
        
        
     }   
    }

    

}



/* [] END OF FILE */

Credits

ashokr

Hello! I’m Ashok. I’m currently working as software engineer. passionate about doing Hobbies Projects and Animations works.

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast