Create a new controller and implement a wall following behaviour using PID controller. You

are expected to use sensors to detect the presence of the wall or obstacle nearby.

Here's the fundamental steps that you may implement:

a$.$ Reading Sensor Input: The robot e$-$puck is equipped with sensors capable of

detecting the distance to the wall or obstacle.

b$.$ Setpoint: Define the desired distance from the wall that the robot should maintain.

This is the reference value or setpoint for the PID controller.

c$.$ Error Calculation: Calculate the error, which is the difference between the desired

distance $($setpoint$)$ and the actual distance measured by the sensor$.$

d$.$ Proportional Control $($P$)$: Use the proportional term of the PID controller to generate a

control signal proportional to the error. The robot adjusts its motion based on how far

it is from the desired distance from the wall. For example, if the error is large $($far from

the wall$),$ the robot steers more sharply towards the wall.

e$.$ Integral Control $($I$)$: Introduce integral control to account for accumulated error over

time. This helps the robot to overcome steady$-$state errors and biases. It continuously

adjusts the robot's motion based on the integral of the error over time.

f$.$ Derivative Control $($D$)$: Incorporate derivative control to anticipate future error trends

based on the rate of change of the error. This helps dampen oscillations and improve

stability by adjusting the robot's motion based on how quickly the error is changing.

g$.$ Controller Tuning: Tune the PID parameters $($proportional gain, integral gain, and

derivative gain$)$ to achieve the desired wall following behavior. This may involve

experimentation or automated tuning methods to find the optimal parameters for the

specific robot and environment.

h$.$ Actuation: Based on the combined output of the proportional, integral, and derivative

terms, adjust the robot's actuators $($such as motor speeds or steering angles$)$ to

execute the desired motion and maintain the desired distance from the wall.

THE ENVIROMENT IS GIVEN ABOVE PLEASE ADJUST THE CODE BASED ON THAT: from controller import Robot

class State:

WALL$\_$FOLLOWING $=0$

TURN$\_$RIGHT $=1$

TURN$\_$LEFT $=2$

def run$\_$robot$($robot$)$:

timestep $=$ int$($robot$.$getBasicTimeStep$())$

max$\_$speed $=6\mathrm{.}28$

left$\_$motor $=$ robot.getMotor$(\text{'}$left wheel motor'$)$

right$\_$motor $=$ robot.getMotor$(\text{'}$right wheel motor'$)$

left$\_$motor.setPosition$($float$(\text{'}$inf$\text{'}))$

left$\_$motor.setVelocity$(0\mathrm{.}0)$

right$\_$motor.setPosition$($float$(\text{'}$inf$\text{'}))$

right$\_$motor.setVelocity$(0\mathrm{.}0)$

prox$\_$sensors $=[]$

for ind in range$(8)$:

sensor$\_$name $=\text{'}$ps$\text{'}+$ str$($ind$)$

prox$\_$sensors$.$append$($robot$.$getDistanceSensor$($sensor$\_$name$))$

prox$\_$sensors$[$ind$].$enable$($timestep$)$

# PID controller parameters

kp $=0\mathrm{.}1$ # Proportional gain

ki $=0\mathrm{.}001$ # Integral gain

kd $=0\mathrm{.}001$ # Derivative gain

integral $=0$

prev$\_$error $=0$

state $=$ State.WALL$\_$FOLLOWING

while robot.step$($timestep$)!=-1$:

# Read sensor data

distances $=[$prox$\_$sensors$[$ind$].$getValue$()$ for ind in range$(8)]$

# Detect T$-$shaped wall

front$\_$wall $=$ distances$[7]>80$

left$\_$wall $=$ distances$[5]>80$

right$\_$wall $=$ distances$[2]>80$

# Wall$-$following behavior

if state $==$ State.WALL$\_$FOLLOWING:

if not front$\_$wall:

error $=80-$ distances$[7]$

proportional $=$ kp $*$ error

integral $+=$ ki $*$ error

derivative $=$ kd $*($error $-$ prev$\_$error$)$

prev$\_$error $=$ error

control$\_$signal $=$ proportional $+$ integral $+$ derivative

left$\_$speed $=$ max$\_$speed $-$ control$\_$signal

right$\_$speed $=$ max$\_$speed $+$ control$\_$signal

else:

if left$\_$wall and right$\_$wall:

# Both left and right walls detected

# Move forward while slightly turning towards the opposite direction

left$\_$speed $=$ max$\_$speed $*0\mathrm{.}7$

right$\_$speed $=$ max$\_$speed $*0\mathrm{.}3$

elif left$\_$wall:

# Left wall detected

# Perform a turn to the right while moving forward

left$\_$speed $=$ max$\_$speed $*0\mathrm{.}5$

right$\_$speed $=$ max$\_$speed

elif right$\_$wall:

# Right wall detected

# Perform a turn to the left while moving forw

left$\_$speed $=$ max$\_$speed

right$\_$speed $=$ max$\_$speed $*0\mathrm{.}5$

else:

# No walls detected

# Turn left to search for a wall

left$\_$speed $=-$max$\_$speed

right$\_$speed $=$ max$\_$speed

# Apply speed limits

left$\_$speed $=$ min$($max$($left$\_$speed, $-$max$\_$speed$),$ max$\_$speed$)$

right$\_$speed $=$ min$($max$($right$\_$speed, $-$max$\_$speed$),$ max$\_$speed$)$

# Set motor velocities

left$\_$motor.setVelocity$($left$\_$speed$)$

right$\_$motor.setVelocity$($right$\_$speed$)$

# Main function

if $\_$name$\_=="\_$main$\_"$:

my$\_$robot$=$Robot$()$

run$\_$robot$($my$\_$Robot$)$

code is giving error