TARJETA de CONTROL para SEMAFOROS de 4 FASES con ARDUINO

En cada intersección, siempre hay un pequeño tablero de control que gobierna los tiempos en verde, amarillo y rojo. Y justamente hoy, vamos a aprender a crear la tarjeta de control, el cerebro que gestiona toda la secuencia del grupo de semáforos. Veremos desde el esquemático electrónico, el diseño de la PCB y la programación.

1. Tensión de alimentación……………………….…………100-240Vac
2. Corriente de alimentación………………….……………60mA
3. Entrada Digital    ………………………………..…………………1
4. Pulsadores de configuracion de tiempos………………Sí
5. Puerto programacion ISP……………………………………Sí
6. Pantalla lcd 16*2……………………………………………….Sí
7. Barra de  led señalizadores de nivel de semaforo……….Sí
8. Entorno de programación-………………………………………..Arduino IDE
9. Condiciones ambientales min………………………….-10°
10. Condiciones ambientales max…………………..…….55
11. capacidad de control…………………………………………….4 fases
12. Salida a triac 6A…………………………………… 12

#include <EEPROM.h>
#include <Wire.h>
#include "RTClib.h"

#define SW4_A 2
#define SW4_B 3
#define link_in 9
#define link_out 10
#define no_use 17

#define spi1 13
#define spi2 12
#define spi3 11

// Pines para el 74hc595
byte clockpin = 14;  // SH
byte data = 15;       // DS
byte latch = 16;      // ST

// Objeto RTC
RTC_DS1307 rtc;

// Variables de control
enum Estado { NORMAL,
              AMARILLO,
              TODOS_ROJO,
              APAGADO };
Estado estado = NORMAL;

unsigned long tiempoInicioFase;
int faseActual = 0;

// Configuraciones almacenadas en EEPROM
byte contador_fases_M = 2;
byte duracionesVerde[4];
const int duracionAmarillo = 3;
const int duracionTodosRojo = 2;

byte hora_apagado_M = 23;
byte minu_apagado_M = 30;
byte hora_encendido_M = 4;
byte minu_encendido_M = 30;

// Patrones de luces
const int lights_1_8[] = {0, 50, 82, 134, 138, 144, 145, 146, 146, 146};
const int lights_9_16[] = {0, 64, 76, 74, 65, 193, 76, 29, 39, 64};

void setup() {
  Wire.begin();
  rtc.begin();

  // Configurar pines
  pinMode(clockpin, OUTPUT);
  pinMode(data, OUTPUT);
  pinMode(latch, OUTPUT);
  pinMode(SW4_A, INPUT);
  pinMode(SW4_B, INPUT);
  pinMode(link_in, INPUT);
  pinMode(link_out, OUTPUT);
  pinMode(no_use, OUTPUT);
  pinMode(spi1, OUTPUT);
  pinMode(spi2, OUTPUT);
  pinMode(spi3, OUTPUT);

  // Leer configuración de EEPROM
  contador_fases_M = EEPROM.read(direc_fases);
  loadDuracionesDeEEPROM();
  hora_apagado_M = EEPROM.read(direc_hora_apagado);
  minu_apagado_M = EEPROM.read(direc_minu_apagado);
  hora_encendido_M = EEPROM.read(direc_hora_encendido);
  minu_encendido_M = EEPROM.read(direc_minu_encendido);

  tiempoInicioFase = rtc.now().unixtime();
  cambiarFase(0);
}

void loop() {
  DateTime now = rtc.now();
  int horaActual = now.hour();
  int minutoActual = now.minute();

  // Verificar horario de apagado
  bool fueraHorario = false;
  if (hora_apagado_M < hora_encendido_M || 
     (hora_apagado_M == hora_encendido_M && minu_apagado_M < minu_encendido_M)) {
    fueraHorario = (horaActual > hora_apagado_M || 
                   (horaActual == hora_apagado_M && minutoActual >= minu_apagado_M)) &&
                   (horaActual < hora_encendido_M || 
                   (horaActual == hora_encendido_M && minutoActual < minu_encendido_M));
  } else {
    fueraHorario = (horaActual > hora_apagado_M || 
                   (horaActual == hora_apagado_M && minutoActual >= minu_apagado_M)) ||
                   (horaActual < hora_encendido_M || 
                   (horaActual == hora_encendido_M && minutoActual < minu_encendido_M));
  }

  if (fueraHorario) {
    if (estado != APAGADO) {
      estado = APAGADO;
      apagarLuces();
    }
    return;
  }

  if (estado == APAGADO) {
    estado = NORMAL;
    tiempoInicioFase = now.unixtime();
    cambiarFase(faseActual);
  }

  unsigned long tiempoActual = now.unixtime();
  unsigned long tiempoTranscurrido = tiempoActual - tiempoInicioFase;

  switch (estado) {
    case NORMAL:
      if (tiempoTranscurrido >= duracionesVerde[faseActual]) {
        iniciarTransicion();
      }
      break;

    case AMARILLO:
      if (tiempoTranscurrido >= duracionAmarillo) {
        estado = TODOS_ROJO;
        tiempoInicioFase = now.unixtime();
        apagarLuces();
        lights = 9;
        lights_OUT();
      }
      break;

    case TODOS_ROJO:
      if (tiempoTranscurrido >= duracionTodosRojo) {
        estado = NORMAL;
        tiempoInicioFase = now.unixtime();
        cambiarFase((faseActual + 1) % contador_fases_M);
      }
      break;
  }
}

// Funciones de control de luces
void iniciarTransicion() {
  estado = AMARILLO;
  tiempoInicioFase = rtc.now().unixtime();
  lights = (faseActual * 2) + 2;
  lights_OUT();
}

void cambiarFase(int nuevaFase) {
  apagarLuces();
  lights = (nuevaFase * 2) + 1;
  lights_OUT();
  faseActual = nuevaFase;
}

void apagarLuces() {
  lights = 0;
  lights_OUT();
}

void lights_OUT() {
  digitalWrite(latch, LOW);
  shiftOut(data, clockpin, LSBFIRST, lights_9_16[lights]);
  shiftOut(data, clockpin, LSBFIRST, lights_1_8[lights]);
  digitalWrite(latch, HIGH);
}

// Funciones EEPROM
void loadDuracionesDeEEPROM() {
  EEPROM.get(direc_tiempo_ledGreen_Fase1, duracionesVerde[0]);
  EEPROM.get(direc_tiempo_ledGreen_Fase2, duracionesVerde[1]);
  EEPROM.get(direc_tiempo_ledGreen_Fase3, duracionesVerde[2]);
  EEPROM.get(direc_tiempo_ledGreen_Fase4, duracionesVerde[3]);
}