# Description: Contains the main logic of the SWBMS Project(Smart Waste Bin Management System Project)
# Date:16/10/2023
#--------------------import all the necessary library--------------------------
from machine import UART, Pin, I2C #this is the library to intract with i/o pin Used for interacting with hardware pins, ADC (Analog-to-Digital Converter), and UART for serial communication.
from utime import ticks_ms, sleep,sleep_us,sleep_ms,ticks_us,time
from mfrc522 import MFRC522
from hx711 import HX711
from gsmm import GSM
import _thread
from queue import Queue
import ure
import json
import _thread
import machine
import ubinascii
#------------------------------------------------------------------------------
#--------------variable initialisation------------------------------------------
global Start_Calibration_Flag
Debug = True
Start_Calibration_Flag = 0
# URLs for data communication
get_url = "http://3.28.131.115:8081/agb/"
post_url = "http://3.28.131.115:8081/agb/saveBinData"
#-------------------------------------------------------------------------------
#Function for the load cell calibration
def LoadSensorCalibration():
try:
#white light: means calibration start
Red_LED.high()
Green_LED.high()
Blue_LED.high()
LoadCellOffset = LoadCell.read_avg() #is essential for accurately calibrating the load cell sensor and ensuring that subsequent weight measurements are correct by accounting for any zero errors or noise in the sensor's readings.
if Debug:
print("Enter the Load")
#aqua light: which mean you have to put the load( for now we have taken 5KG load for reference).
Red_LED.low()
Green_LED.high()
Blue_LED.high()
while LoadCell.read()-LoadCellOffset<2000: #. The system waits for the load cell to detect a significant change (more than 2000 units from the offset) to ensure the weight is placed correctly.
print(LoadCell.read()-LoadCellOffset)
pass
sleep(3)
if Debug:
print("Calibration Done")
#magenta light load detected.
Red_LED.high()
Green_LED.low()
Blue_LED.high()
referenceLoad = LoadCell.read_avg()
LoadCellScaling = referenceLoad- LoadCellOffset
#calibration completed
return [int(LoadCellScaling),int(LoadCellOffset)]
except Exception as e:
if Debug:
print(e)
# Function to start the calibration
# This function also checks if calibration has already been done
def CalibrationStart():
global LoadCellOffset,LoadCellScaling
try:
#it will check if calibration file exist with conaitning the calibration values
if Start_Calibration_Flag!=1:
calibrationFile = open('calibration.txt', "r")
LoadCellValue = calibrationFile.read().split(',') #2932, 41906
if len(LoadCellValue)<=0:
raise Exception("Blank File!!!")
LoadCellScaling = int(LoadCellValue[0])
LoadCellOffset = int(LoadCellValue[1])
calibrationFile.close()
else:
raise Exception("Start Calibration!!!")
except:
#if not exist then it will calll the calibration function
LoadArray = LoadSensorCalibration()
calibrationFile = open('calibration.txt', "w")
calibrationFile.write(str(LoadArray)[1:-1])
calibrationFile.close()
calibrationFile = open('calibration.txt', "r")
LoadCellValue = calibrationFile.read().split(',')
LoadCellScaling = int(LoadCellValue[0])
LoadCellOffset = int(LoadCellValue[1])
calibrationFile.close()
#Function to setup the gpio's and initialisation of the variables
def setup_gpio():
global LA_Forward,LA_Feedback,BinLevelSensor_2,BinLevelSensor_1,Red_LED,Green_LED,Blue_LED,Pico_led,Registered_card,PWR_Key,reader,gsm,LM35_Sens,Pico_temp
global conversion_factor,ProximitySensor,LA_Backward,Alert_code_buf,Bin_location,Garbage_limit,card
global Debug,RFID_Card_State,Mosfet_1,Mosfet_2,LoadCell,MachineID,Calibration_card,Bin_Request_q,Post_Request_q
global GPS
GPS = True
Debug = False
# --------------pin defination------------------------
Pico_led_pin =25
# Pin for the bin level sensor
Echo_pin_1 = 0
Echo_pin_2 = 1
# pin 2 for relay 2
LA_Forward_pin = 2
LA_Backward_pin = 3
#pin 4(Rx) - tx GSM
Pico_temp_pin= 4 # this is internal Analog pin not on board
# pin 5 (Tx) - Rx GSM
Power_key_pin = 6
Bin_1_Mosfet_pin = 7
LoadCell_SCK_pin = 8
LoadCell_DOUT_pin = 9
Blue_LED_pin = 12 # 12
Green_LED_pin = 13
Red_LED_pin = 14 #14
# pin 16 MISO
# pin 17 CS
# pin 18 SCK
# pin 19 MOSI
# pin 20 RST
ProximitySensor_pin = 21
Bin_2_Mosfet_pin = 22
LM35_Sens_pin = 2 # this is analog 2 and pin 28
LA_Feedback_Pin = 26
#--------------------------------------------------
#-----------------object create--------------------
reader = MFRC522(spi_id=0,sck=18,miso=16,mosi=19,cs=17,rst=20)
gsm = GSM()
Bin_Request_q = Queue()
Post_Request_q = Queue()
LM35_Sens = machine.ADC(LM35_Sens_pin)#object created for the LM35 sensor
Pico_temp = machine.ADC(Pico_temp_pin)#object created for the pico temperature sensor
LM35_Sens = machine.ADC(LM35_Sens_pin)#object created for the LM35 sensor
Pico_temp = machine.ADC(Pico_temp_pin)#object created for the pico temperature sensor
Pico_led = Pin(Pico_led_pin, Pin.OUT)#object created for the pico led
BinLevelSensor_1 = Pin(Echo_pin_1, Pin.IN)#object created for the trash level -1 sensor
BinLevelSensor_2 = Pin(Echo_pin_2, Pin.IN)#object created for the trash level -2 sensor
Red_LED = Pin(Red_LED_pin, Pin.OUT)#object created for the Red LED
Green_LED = Pin(Green_LED_pin, Pin.OUT)#object created for the Green LED
Blue_LED = Pin(Blue_LED_pin, Pin.OUT)#object created for the Blue LED
LA_Forward = Pin(LA_Forward_pin, Pin.OUT) # object for linear actuator in forward direction
LA_Backward = Pin(LA_Backward_pin, Pin.OUT) # object for linear actuator in Backward direction
LA_Feedback = machine.ADC(LA_Feedback_Pin)
Mosfet_1 = Pin(Bin_1_Mosfet_pin, Pin.OUT) # object for Mosfet of bin 1 control
Mosfet_2 = Pin(Bin_2_Mosfet_pin, Pin.OUT) # object for Mosfet of the bin 2 control
# need to add one more relay and battery adc and linear actuator feedback (Analog read)
PWR_Key = Pin(Power_key_pin, Pin.OUT)# object for gsm power key
ProximitySensor = Pin(ProximitySensor_pin, Pin.IN,Pin.PULL_UP) # object created for the Left Limit switch
#RSwitch = Pin(RSwitch_pin, Pin.IN,Pin.PULL_UP) # object created for the Right Limit switch
# object created for the Load cell pin
LoadCellDout = Pin(LoadCell_DOUT_pin, Pin.IN, pull=Pin.PULL_DOWN)
LoadCellSck = Pin(LoadCell_SCK_pin, Pin.OUT)
LoadCell = HX711(LoadCellSck, LoadCellDout)
#----------initialization of the Led-------------------------
Red_LED.low()
Green_LED.high()
Blue_LED.low()
#--------------------------------------------------------
#---------------variable initalisation-------------------------
CalibrationStart()
Alert_code_buf = [0,0,0,0,0]
#Alert_code_buf[0] = TBL (TBL>90 ==> 1, TBL<90 ==> 0)
#Alert_code_buf[1] = TBL Sensor (TBL working =0, Not working = 1)
#Alert_code_buf[2] = RFID Sensor (RFID Sensor Working=0, RFID sensor not working =1)
#Alert_code_buf[3] = Trash bin temperature (If temperature >75 then 1 else 0)
#Alert_code_buf[4] = Proximity Switch status (if any one of two limit switch off then 0 other wise 1)
#Alert_code_buf[5] = Trash bin Weight Value( if Trash bin Weight return the 0, then 1 else 0)
conversion_factor = 3.3/65535 # conversion factor for the temperature
#This variable contains the id of the cards i.e registration and calibration cards
Registered_card = [1406550997,821727780,810275380,818998548,2867844179,2840751363,269220211,2866838851] #registered card for the SWBMS
Calibration_card = [1394027849,2863046499,2862073619,2863075139,2846364563]
Garbage_limit = 40
card=0
Bin_location = {"latitude": 0,"longitude": 0}
RFID_Card_State = False
MachineID = ubinascii.hexlify(machine.unique_id()).decode() # get the MAC ID/device id
Mosfet_1.high()
Mosfet_2.high()
Pico_led.high()
#function perform for pico led on
def led_on():
Pico_led.value(1)
#function perform for pico led off
def led_off():
Pico_led.value(0)
#function to send the data on tadweer api and also get the data for the qr scan
def tadweerApi(Bin_Request_q,Post_Request_q):
inital_value = ''
while True:
try:
if Post_Request_q.empty() and Bin_Request_q.empty():
get_init_resp = gsm.send_at("AT+HTTPINIT",timeout=10000)
if "ERROR" in get_init_resp:
gsm.send_at("AT+HTTPTERM",timeout=120000)
gsm.send_at("AT+HTTPINIT",timeout=10000)
gsm.send_at('AT+HTTPPARA=\"URL\",\"'+get_url+MachineID+'\"',timeout=10000)
gsm.send_at("AT+HTTPACTION=0", timeout=15000,check=b'200')
rcv = gsm.send_at('AT+HTTPREAD=0,100',timeout=15000,check=b'}')
if "track_id" in rcv:
rcv = rcv.replace(" ", "").replace("\n", "")
rcv = ure.search('({.*})', rcv).group(1)
try:
Packet = json.loads(rcv)
RandomString = Packet.get("track_id")
if inital_value != RandomString:
user_id = Packet.get("user_id")
Bin_Request_q._put(user_id)
inital_value=RandomString
except Exception as e:
if Debug:
print("Error : ", e)
pass
gsm.send_at("AT+HTTPTERM",timeout=120000)
elif not(Post_Request_q.empty()):
try:
data_json = Post_Request_q._get()
except:
pass
#if gsm.check_network():
http_str = 'AT+HTTPPARA=\"URL\",\"'+post_url+'\"';
post_init_resp = gsm.send_at("AT+HTTPINIT",timeout=10000) # ,check=True)
if "ERROR" in post_init_resp:
gsm.send_at("AT+HTTPTERM",timeout=120000) # ,check=True)
gsm.send_at("AT+HTTPINIT",timeout=10000)#
gsm.send_at("AT+HTTPINIT",timeout=10000)
gsm.send_at(http_str,timeout=10000)
gsm.send_at("AT+HTTPPARA=\"CONTENT\",\"application/json\"",timeout=10000)
gsm.send_at("AT+HTTPDATA="+str(len(data_json))+",10000",timeout=10000)
gsm.send_at(data_json,timeout=10000)
gsm.send_at("AT+HTTPACTION=1", timeout=15000,check=b'200')
gsm.send_at("AT+HTTPTERM",timeout=120000)
#print("Sent")
else:
if Debug:
print("NO GET POST")
pass
except Exception as e:
if Debug:
print("Error : ",e)
#print("error",e)
pass
#This function is utilized to monitor for any potential faults in the Bin level sensor
def TBL_check():
myStartingTime = time()
global Alert_code_buf,Garbage_limit
Mosfet_1.high()
Mosfet_2.high()
signalon = ticks_us()
signaloff = ticks_us()
#print("Test Signal difference: -",signalon-signaloff)
while BinLevelSensor_2.value() == 0:
# this is to check the Sensor Connected or not
calculation_starting_time = time()
if calculation_starting_time - myStartingTime > 1:
break
signaloff = ticks_us()
while BinLevelSensor_2.value() == 1:
# this is to check the Sensor Connected or not
calculation_starting_time = time()
if calculation_starting_time - myStartingTime > 1:
break
signalon = ticks_us()
timepassed = signalon - signaloff
distance = (timepassed)/58
if timepassed<0:
Alert_code_buf[1] = 1
return -1
else:
Alert_code_buf[1] = 0
return distance
#This function perform the bin level meaurement and also update teh alert code
def bin_level(timeout_seconds=5):
global Alert_code_buf, Garbage_limit
Mosfet_1.high()
Mosfet_2.high()
Average_distance = []
start_time = ticks_ms()
for i in range(0, 5):
signalon = ticks_us()
signaloff = ticks_us()
while BinLevelSensor_2.value() == 0:
signaloff = ticks_us()
if time.ticks_diff(ticks_ms(), start_time) / 1000 > timeout_seconds:
print("Timeout reached. Exiting loop.")
break
while BinLevelSensor_2.value() == 1:
signalon = ticks_us()
if time.ticks_diff(ticks_ms(), start_time) / 1000 > timeout_seconds:
print("Timeout reached. Exiting loop.")
break
timepassed = signalon - signaloff
distance = (timepassed) / 58
Average_distance.append(distance)
distance = sum(Average_distance) / 5
if distance <= Garbage_limit:
Alert_code_buf[0] = 1
else:
Alert_code_buf[0] = 0
return distance
#function to blink the blue led
def Blink_Blue(blinks):
Red_LED.low()
Green_LED.low()
Blue_LED.low()
for i in range(0, blinks):
Blue_LED.low()
sleep(0.25)
Blue_LED.high()
sleep(0.25)
# function to setup gsm
def setup_gsm(): # function initializes the GSM module, configures it, checks for network connectivity, and provides visual feedback using LEDs.
Red_LED.high()
Green_LED.low()
Blue_LED.low()
# Start the gsm
if gsm.boot_gsm():# This method tries to power on the GSM module and checks if it's ready to use by sending the "AT" command up to 20 times. If it gets an "OK" response, it means the module is ready.
gsm.configure_gsm() #This method sets up the GSM module for operations by: @ Deleting all stored messages. @ Setting the network mode to automatic (finds the best available network).@ Setting up an APN (Access Point Name) for internet access.
# Check we're attached
state = True
while not gsm.check_network():
#print("trut")
if state:
led_on()
#LED_R.high()
else:
led_off()
#LED_R.low()
state = not state
# Light the LED
led_on()
else:
# Error! Blink LED 5 times
Blink_Blue(5)
led_off()
#function to initalise the GPS
def setup_gps():
gsm.send_at('AT+CGNSSPWR=0,0,0',timeout=10000) # This command turns off the GPS power to reset the module or ensure it starts from a known state.
gsm.send_at("AT+CGNSSPWR=1",timeout=10000) #This command powers on the GPS module. It is essential for enabling the GPS hardware to begin satellite communication for location tracking.
gsm.send_at("AT+CGNSSMODE=1",timeout=10000) #Configures the mode in which the GPS operates.
gsm.send_at("AT+CGPSCOLD",timeout=10000) #Initializes the GPS module to perform a "cold start."
gsm.send_at("AT+CAGPS",timeout=10000) # This command appears to be an additional GPS configuration or initialization command. The exact behavior might vary depending on the GSM/GPS module model.
#Function to extract the gps value from the Raw GPS packet
def extract_coordinates(string):
pattern = r'(\d+\.\d+),([NSEW]),(\d+\.\d+),([NSEW])'
match = ure.search(pattern, string)
if match:
latitude_decimal = float(match.group(1))
if match.group(2) in ('S', 'W'):
latitude_decimal *= -1
longitude_decimal = float(match.group(3))
if match.group(4) in ('S', 'W'):
longitude_decimal *= -1
return latitude_decimal, longitude_decimal
else:
return None
#Function to convert the raw gps value into degree minute
def convert_coordinates(latitude, longitude):
latitude_degrees = int(latitude) // 100
latitude_minutes = float(latitude) % 100 / 60
latitude_decimal = latitude_degrees + latitude_minutes
longitude_degrees = int(longitude) // 100
longitude_minutes = float(longitude) % 100 / 60
longitude_decimal = longitude_degrees + longitude_minutes
return latitude_decimal, longitude_decimal
#Function to update the Bin location Packet
def fetch_gps_location():
global Bin_location
response = gsm.send_at("AT+CGPSINFO",timeout=10000)
coordinates = extract_coordinates(response)
if coordinates:
latitude_str, longitude_str = coordinates
latitude, longitude = convert_coordinates(latitude_str, longitude_str)
Bin_location['latitude'] = str(latitude)
Bin_location['longitude'] = str(longitude)
#function to get the bin temperature from lm35 and pico
def bin_temperature(): #Reads temperature from the LM35 sensor and the built-in Pico temperature sensor. Calculates the average temperature and raises alerts if it exceeds a certain threshold.
global Alert_code_buf
lm35_temp_voltage_raw = LM35_Sens.read_u16()*conversion_factor
pico_temp_voltage_raw = Pico_temp.read_u16()* conversion_factor
# Converts ADC value back to voltage
pico_temperature = 27 - (pico_temp_voltage_raw - 0.706)/0.001721
lm35_temperature = lm35_temp_voltage_raw/(10.0 / 1000)
#F_temp = (C_temp*9/5) +32
Average_temperature = (pico_temperature+lm35_temperature)/2
#print(pico_temperature,lm35_temperature,Average_temperature)
if Average_temperature>80:
Alert_code_buf[3] = 1
return Average_temperature
#function to check the bin lid
def check_Bin_Lid():
global Alert_code_buf
if ProximitySensor.value()==1:
Alert_code_buf[4] = 0
return 1
else:
Alert_code_buf[4] = 1
return 0
# function to read the Bin weight
def Bin_Weight():
try:
TBW = ((LoadCell.read()-LoadCellOffset)/LoadCellScaling)*4.9
if TBW>-1 and TBW<0:
TBW =0
#Alert_code_buf[5] = 0
return TBW-37 #37 is the main bin weight which is inside the container or bin
except Exception as e:
#print(e)
#Alert_code_buf[5] = 1
return 0
# function to check the bin ideal state
def Bin_ideal_check():
global Alert_code_buf
TBL_check() # This function likely checks the bin level sensor, possibly using an ultrasonic sensor to determine the trash level in the bin. It updates
check_Bin_Lid() # This function checks the status of the bin lid, possibly using a proximity sensor or limit switch to determine if the lid is open or closed. It updates
bin_temperature() #This function reads the temperature inside the bin using a temperature sensor (e.g., LM35 or onboard Pico temperature sensor) and updates
Bin_Weight() #: This function measures the weight of the trash in the bin using a load cell and updates Alert_code_buf[5] based on the weight reading.
try:
reader.init()
#print(reader.check())
if reader.check()==0:
Alert_code_buf[2] = 1
else:
Alert_code_buf[2] = 0
except:
Alert_code_buf[2] = 1
# This loop will execute continuously, provided all functions run without errors
while True: # This main loop runs indefinitely to continuously monitor and manage the waste bin system.
try:
setup_gpio() # Setting up all input and output pins
led_off() # Turning off the LED indicator
setup_gsm() # Boots and configures the GSM module to ensure it's ready for communication. It checks for network connectivity and handles any errors that occur during initialization.
setup_gps() # Powers on the GPS module, configures it for location tracking, and prepares it to fetch GPS data.
Bin_ideal_check() # Runs a series of diagnostic checks on the bin's sensors and components (e.g., RFID reader, bin level sensor, lid sensor, temperature sensor, load cell). Updates the Alert_code_buf based on the results.
myStartingTime = time()
while True: # This inner loop attempts to fetch the GPS location of the bin for up to 60 seconds.
#calculation_starting_time =
if time() - myStartingTime > 60:
break
try:
fetch_gps_location()
except:
pass
Bin_Data_Packet ={"tbmID":MachineID,"user_id":0,"tbt":int(bin_temperature()),"tbl":int(TBL_check()),"tbw":Bin_Weight(),"latitude":Bin_location['latitude'],"longitude":Bin_location['longitude'],"alerts":str(Alert_code_buf)[1:-1]}
Bin_Data_Packet = json.dumps(Bin_Data_Packet)
Post_Request_q._put(Bin_Data_Packet)
if Debug:
print(Alert_code_buf)
break
except:
pass
# Start a thread to handle data sending and fetching processes using a queue management system
# This system facilitates communication between two core processes
_thread.start_new_thread(tadweerApi, (Bin_Request_q,Post_Request_q,))
# This loop will run continuously in the beginning if any alert code occurs.
# It will also update the queue to send that data over the server/api
while 1 in Alert_code_buf:
try:
Bin_ideal_check()
Red_LED.high()
Green_LED.low()
Blue_LED.low()
#print(Alert_code_buf)
TBL_check()
#fetch_gps_location()
Bin_Data_Packet ={"tbmID":MachineID,"user_id":card,"tbt":int(bin_temperature()),"tbl":int(TBL_check()),"tbw":Bin_Weight(),"latitude":Bin_location['latitude'],"longitude":Bin_location['longitude'],"alerts":str(Alert_code_buf)[1:-1]}
#Bin_Data_Packet = {"ID":0,"TBT":int(bin_temperature()),"TBL":int(23),"TBW":23,"TBGL":Bin_location}
Bin_Data_Packet = json.dumps(Bin_Data_Packet)
Post_Request_q._put(Bin_Data_Packet)
except:
pass
# This loop, running in core 1, continuously monitors the bin parameters.
while True:
try:
space = TBL_check() #signalon - signaloff/58 or -1
temperature = bin_temperature() # Average_temperature
TBW = Bin_Weight() # TBW-37
check_Bin_Lid()
try:
reader.init() # Initializes the RFID reader, setting up necessary configurations to make it ready for operation. This might include SPI communication setup and powering up the antenna.
if reader.check()==0: # Check the version of the RFID reader to ensure it's working correctly Checks if the RFID reader is responding correctly. The method check() returns the version number or status. A return value of 0 might indicate a failure or malfunction. If so, an alert is set in Alert_code_buf[2]
Alert_code_buf[2] = 1
else:
Alert_code_buf[2] = 0
(stat, tag_type) = reader.request(reader.REQIDL) # |
if stat == reader.OK: # | The RFID reader attempts to detect a tag using reader.request(reader.REQIDL) and selects a tag using reader.SelectTagSN().
(stat, uid) = reader.SelectTagSN() # |
if stat == reader.OK:
card = int.from_bytes(bytes(uid),"little",False)
RFID_Card_State = True
if Debug:
print("CARD ID: "+str(card))
#RFID_flag =True
except Exception as E:
if Debug:
print("RFID exception",E)
if 1 in Alert_code_buf:
#RED LED Glow if any bit is high in alert_code_buf
Red_LED.high()
Green_LED.low()
Blue_LED.low()
Bin_Data_Packet = {"tbmID":MachineID,"user_id":0,"tbt":int(bin_temperature()),"tbl":int(TBL_check()),"tbw":Bin_Weight(),"latitude":Bin_location['latitude'],"longitude":Bin_location['longitude'],"alerts":str(Alert_code_buf)[1:-1]}
Bin_Data_Packet = json.dumps(Bin_Data_Packet)
Post_Request_q._put(Bin_Data_Packet)
else:
try:
#initialise and check the reader
if (RFID_Card_State == True) or (not Bin_Request_q.empty()): # If an RFID card is detected or there is a request in Bin_Request_q, the system checks if the card is registered.
try:
QR_request = Bin_Request_q._get()
card = QR_request
QR_request = True
except:
QR_request = False
#pass
if (card in Registered_card) or QR_request: #and RFID_flag == True: If an RFID card is detected or there is a request in Bin_Request_q, the system checks if the card is registered.
#BLue LED Glow
Red_LED.low()
Green_LED.low()
Blue_LED.high()
sleep(0.5) #delay
# Linear Actuator Backward
LA_Forward.high() #unlock the bin
LA_Backward.low()
sleep(2)
#Stop the Linear Actuator
LA_Forward.low()
LA_Backward.low()
#Yellow LED Glow
Red_LED.high()
Green_LED.high()
Blue_LED.low()
sleep(3) #delay
start_time = time()
while ProximitySensor.value()==1:#Wait for the bin Open:
if time()- start_time > 120:
break
start_time = time()
while not(ProximitySensor.value()==1):#Wait for the bin close:
if time()- start_time > 120:
#update the Bin_data_packet to send the alert code and other parameter on server
Bin_Data_Packet = {"tbmID":MachineID,"user_id":card,"tbt":int(temperature),"tbl":int(bin_level()),"tbw":Bin_Weight(),"latitude":Bin_location['latitude'],"longitude":Bin_location['longitude'],"alerts":"0,0,0,0,1,0"}
Bin_Data_Packet = json.dumps(Bin_Data_Packet)
Post_Request_q._put(Bin_Data_Packet)
#Red LED Glow
Red_LED.high()
Green_LED.low()
Blue_LED.low()
start_time = time()
#Blue LED Glow
Red_LED.low()
Green_LED.low()
Blue_LED.high()
sleep(1)
#lock the bin
LA_Forward.low()
LA_Backward.high()
sleep(2)
LA_Forward.low()
LA_Backward.low()
RFID_Card_State = False
# update the Queue buffer
Bin_Data_Packet ={"tbmID":MachineID,"user_id":card,"tbt":int(temperature),"tbl":int(bin_level()),"tbw":Bin_Weight(),"latitude":Bin_location['latitude'],"longitude":Bin_location['longitude'],"alerts":"0,0,0,0,0"}
Bin_Data_Packet = json.dumps(Bin_Data_Packet)
Post_Request_q._put(Bin_Data_Packet)
card = 0
'''
If the card is valid:
The blue LED is turned on.
A linear actuator is triggered to unlock the bin (move forward).
The yellow LED is turned on to indicate the bin is ready to use.
The system waits for the bin lid to be opened (checked using a proximity sensor).
Once the bin lid is closed, the bin is locked again using the actuator.
'''
elif card in Calibration_card: #Handling Calibration Cards: @ If a calibration card is detected, the system starts the calibration process using CalibrationStart()
#if clibration_card
CalibrationStart()
Start_Calibration_Flag = 1
card = 0
else:
RFID_Card_State = False
Blink_Blue(3)
else:
#Green LED glow if no alert code or bin not in use.
Red_LED.low()
Green_LED.high()
Blue_LED.low()
except Exception as e:
if Debug:
print(e)
#if any exception occurs RED LED GLOW
Red_LED.high()
Green_LED.low()
Blue_LED.low()
except Exception as e:
if Debug:
print(e)
#if any exception occurs RED LED GLOW
Red_LED.high()
Green_LED.low()
Blue_LED.low()