PROYECTO II B 2025 » Grupo 3B 2025

import cv2

import time

import socket

from grovepi import *

from enum import Enum

hog = cv2.HOGDescriptor()

hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

cap = cv2.VideoCapture(0)

cap.open("peatones-dublin.mp4", cv2.CAP_FFMPEG)

class Estado(Enum):

    ROJO = 1

    AMARILLO = 2

    VERDE = 3

class Ultrasonico:

    def __init__(self, pin):

        self.pin = pin

        self.activo = True

        self.distancia = 0

        pinMode(pin, "INPUT")

    def activar(self):

        self.activo = True

    def desactivar(self):

        self.activo = False

    def getDistancia(self):

        try:

            distance = ultrasonicRead(self.pin)

            return distance

        except IOError as e:

            print("Error: " + str(e))

class Camara:

    def __init__(self):

        self.activo = True

        self.cap = cv2.VideoCapture(0)

    def activar(self):

        self.activo = True

    def desactivar(self):

        self.activo = False

    def getImagen(self):

        ret, frame = self.cap.read()

        return ret, frame

class Buzzer:

    def __init__(self, pin):

        self.pin = pin

        self.activo = True

        self.volumen = 50

        pinMode(pin, "OUTPUT")

    def activar(self):

        self.activo = True

    def desactivar(self):

        self.activo = False

    # TODO

    def pulsar(self, tiempo):

        pass

    def setVolumen(self, newVolumen):

        self.volumen = newVolumen

class Led:

    def __init__(self, pin):

        self.pin = pin

        self.activo = False

        pinMode(pin, "OUTPUT")

    def prender(self):

        digitalWrite(self.pin, 1)

    def apagar(self):

        digitalWrite(self.pin, 0)

class Boton:

    def __init__(self, pin):

        self.pin = pin

        pinMode(pin, "INPUT")

    def getEstado(self):

        try:

            status = digitalRead(self.pin)

            print("Button pressed")

            return status

        except IOError as e:

            print("Error: " + str(e))

class Sistema:

    def __init__(self, pinUts = 2, pinBoton = 3, pinBuzzer = 4, \

                pinLedRojo = 5, pinLedAmarillo = 6, pinLedVerde = 7):

        self.ultrasonico = Ultrasonico(pinUts)

        self.boton = Boton(pinBoton)

        self.buzzer = Buzzer(pinBuzzer)

        self.ledRojo = Led(pinLedRojo)

        self.ledAmarillo = Led(pinLedAmarillo)

        self.ledVerde = Led(pinLedVerde)

        self.camara = Camara()

        self.timer = Timer(SEGUNDOS_INTERVALO_FOTO)

        self.timerEstado = Timer(SEGUNDOS_SEMAFORO)

        self.prioridadPeatones = 0

        self.prioridadVehiculos = 100

        self.cantidadPeatones = 0

        self.distanciaVehiculos = 0

        self.setEstado(Estado.ROJO)

    def setEstado(self, nuevoEstado):

        self.estado = nuevoEstado

        if nuevoEstado == Estado.ROJO:

            self.ledAmarillo.apagar()

            self.ledVerde.apagar()

            self.ledRojo.prender()

        elif nuevoEstado == Estado.AMARILLO:

            self.ledVerde.apagar()

            self.ledRojo.apagar()

            self.ledAmarillo.prender()

        else:

            self.ledRojo.apagar()

            self.ledAmarillo.apagar()

            self.ledVerde.prender()

    def apagarTodo(self):

        self.ledAmarillo.apagar()

        self.ledVerde.apagar()

        self.ledRojo.apagar()

    def cambiarPaso(self):

        if self.estado == Estado.ROJO:

            self.setEstado(Estado.VERDE)

        elif self.estado == Estado.VERDE:

            self.setEstado(Estado.AMARILLO)

            time.sleep(3)

            self.setEstado(Estado.ROJO)

    def isPasoPeatones(self):

        return self.estado == Estado.ROJO

    # TODO

    def activarBuzzer(self):

        self.buzzer.activar()

    # TODO

    def calcularPrioridades(self):

        self.prioridadPeatones = 0

        self.prioridadVehiculos = 100

    def getCantidadPersonas(self):

        """Se usan HOGDescriptors para reconocer personas.

           Devuelve los rectángulos que encierran a las personas detectadas"""

        ret, frame = self.camara.getImagen()

        if not ret:

            print("Error obteniendo frame.")

            return -1

        # Reducir resolución para mayor rendimiento

        frame = cv2.resize(frame, (960, 540))

        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        personas, _ = hog.detectMultiScale(

            gray,

            winStride=(4,4),

            padding=(32,32),

            scale=1.3

            )

        return personas

class Timer:

    def __init__(self, segundos):

        self.startTime = time.time()

        self.tiempoPasado = 0

        self.segundos = segundos

    def timerTerminado(self):

        return self.tiempoPasado >= self.segundos

    def reiniciar(self):

        self.startTime = time.time()

        self.tiempoPasado = 0

    def actualizarTiempo(self):

        delta = time.time() - self.startTime

        self.startTime = time.time()

        self.tiempoPasado += delta

SEGUNDOS_SEMAFORO = 15

METROS_DISTANCIA_AUTO = 50

SEGUNDOS_INTERVALO_FOTO = 3

SEGUNDOS_INCREMENTO_TIMER = 3

def main():

    sistema = Sistema()

    personas = 0

    distancia = 100

    timerSegundo = Timer(1)

    try:

        while True:

            # Foto cada 3 segundos

            if sistema.timer.timerTerminado():

                distancia = sistema.ultrasonico.getDistancia()

                personas = len(sistema.getCantidadPersonas())

                print(f"Distancia: {distancia}")

                print(f"Personas: {personas}")

                sistema.timer.reiniciar()

                if personas == -1:

                    continue

            # Si hay autos esperando y ha pasado un segundo desde el último chequeo

            if sistema.isPasoPeatones() and timerSegundo.timerTerminado():

                timerSegundo.reiniciar()

                if distancia <= METROS_DISTANCIA_AUTO:

                    sistema.timerEstado.tiempoPasado += SEGUNDOS_INCREMENTO_TIMER

                    print("Reduciendo tiempo")

            # Si hay personas esperando y ha pasado un segundo desde el último chequeo

            elif not sistema.isPasoPeatones() and timerSegundo.timerTerminado():

                timerSegundo.reiniciar()

                if personas >= 3 and distancia >= METROS_DISTANCIA_AUTO:

                    sistema.timerEstado.tiempoPasado += SEGUNDOS_INCREMENTO_TIMER

            # Si el timer indica que hay que cambiar el paso

            if sistema.timerEstado.timerTerminado():

                sistema.cambiarPaso()

                sistema.timerEstado.reiniciar()

            sistema.timer.actualizarTiempo()

            sistema.timerEstado.actualizarTiempo()

            timerSegundo.actualizarTiempo()

    except KeyboardInterrupt:

        sistema.apagarTodo()

if __name__ == "__main__":

    main()

    cap.release()

    cv2.destroyAllWindows()