You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
567 lines
18 KiB
567 lines
18 KiB
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "driver/gpio.h"
|
|
|
|
#include "esp_log.h"
|
|
#include "esp_timer.h"
|
|
#include "freertos/timers.h"
|
|
|
|
#include "freertos/queue.h"
|
|
#include "driver/uart.h"
|
|
|
|
#include "HUB75.h"
|
|
#include "Numeros.h"
|
|
#include "FlechasV.h"
|
|
#include "FlechasA.h"
|
|
#include "FlechasR.h"
|
|
#include "Circulos.h"
|
|
|
|
#include "Pines.h"
|
|
|
|
const char * TAG = "PAS";
|
|
|
|
#define EDO_AMA 1
|
|
#define EDO_VER 2
|
|
#define EDO_ROJ 3
|
|
|
|
#define SIMULACION
|
|
|
|
#ifdef SIMULACION
|
|
#define CONT_ROJ 12
|
|
#define CONT_VER 6
|
|
#define CONT_AMA 3
|
|
#else
|
|
static void Luces_task(void *arg);
|
|
#endif
|
|
|
|
static void HUB75_task(void *arg);
|
|
|
|
#define TAM 1536
|
|
|
|
uint32_t graphicsBuffer[TAM];
|
|
|
|
int16_t ds = 0;
|
|
|
|
uint8_t estado_actual, estado_inicial;
|
|
|
|
uint8_t estado_solapado, estado_solapado_ant = 0;
|
|
|
|
uint8_t tiempos_OK = 0;
|
|
|
|
uint8_t estado = EDO_VER;
|
|
|
|
uint8_t contador;
|
|
|
|
uint8_t at = 40;
|
|
|
|
//#define AAA 1
|
|
//#define DDD 2
|
|
//#define III 3
|
|
//
|
|
//#define ADD 4
|
|
//#define AAD 5
|
|
//#define IAA 6
|
|
//#define IIA 7
|
|
//#define IDD 8
|
|
//#define IID 9
|
|
//
|
|
//#define IAD 10
|
|
//
|
|
//#define SOL 20
|
|
//
|
|
//#define NADD 21
|
|
//#define AAND 22
|
|
//#define NIAA 23
|
|
//#define IINA 24
|
|
//#define NIDD 25
|
|
//#define IIND 26
|
|
//
|
|
//#define IAND 27
|
|
//#define NIAD 28
|
|
|
|
uint8_t MODO = IAD;
|
|
|
|
void app_main(void)
|
|
{
|
|
uint16_t i = 0, cu, cd, vv = 0, v5 = 0;
|
|
|
|
#ifdef SIMULACION
|
|
uint8_t cont_edo;
|
|
#else
|
|
TaskHandle_t Luces_Handle = NULL;
|
|
#endif
|
|
TaskHandle_t HUB75_Handle = NULL;
|
|
|
|
xTaskCreatePinnedToCore(HUB75_task, "HUB75_task", 4096, NULL, 10, &HUB75_Handle, 1);
|
|
#ifndef SIMULACION
|
|
xTaskCreatePinnedToCore(Luces_task, "Luces_task", 2048, NULL, 10, &Luces_Handle, 0);
|
|
#endif
|
|
|
|
i = 50;
|
|
|
|
#ifdef SIMULACION
|
|
cont_edo = 3;
|
|
estado_actual = EDO_VER;
|
|
tiempos_OK = 3;
|
|
#endif
|
|
|
|
while (true)
|
|
{
|
|
i++;
|
|
|
|
if(i >= 50)
|
|
{
|
|
i = 0;
|
|
|
|
#ifdef SIMULACION
|
|
cont_edo--;
|
|
if(cont_edo == 0)
|
|
{
|
|
switch(estado_actual)
|
|
{
|
|
case EDO_VER:
|
|
estado_actual = EDO_AMA;
|
|
cont_edo = CONT_AMA;
|
|
break;
|
|
case EDO_AMA:
|
|
estado_actual = EDO_ROJ;
|
|
cont_edo = CONT_ROJ;
|
|
break;
|
|
case EDO_ROJ:
|
|
estado_actual = EDO_VER;
|
|
cont_edo = CONT_VER;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ds = 10 * cont_edo;
|
|
#endif
|
|
if(ds > 0)
|
|
{
|
|
cd = 64 * 4 * ((ds/10) / 10);
|
|
cu = 64 * 4 * ((ds/10) % 10);
|
|
}
|
|
|
|
switch (estado_actual)
|
|
{
|
|
case EDO_AMA:
|
|
estado = EDO_ROJ;
|
|
break;
|
|
case EDO_ROJ:
|
|
estado = EDO_VER;
|
|
break;
|
|
case EDO_VER:
|
|
estado = EDO_AMA;
|
|
break;
|
|
}
|
|
|
|
estado_solapado = gpio_get_level(ENT_SOL);
|
|
if (estado_solapado_ant != estado_solapado)
|
|
{
|
|
estado_solapado_ant = estado_solapado;
|
|
}
|
|
|
|
|
|
estado = estado_actual;
|
|
switch(estado)
|
|
{
|
|
case EDO_ROJ:
|
|
if((tiempos_OK == 3)&&(ds > 10))
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
graphicsBuffer[i * 24 + 0 + 0] = NumGRR[cd + 0];
|
|
graphicsBuffer[i * 24 + 0 + 1] = NumGRR[cd + 1];
|
|
graphicsBuffer[i * 24 + 0 + 2] = NumGRR[cd + 2];
|
|
graphicsBuffer[i * 24 + 0 + 3] = NumGRR[cd + 3];
|
|
graphicsBuffer[i * 24 + 4 + 0] = NumGRR[cu + 0];
|
|
graphicsBuffer[i * 24 + 4 + 1] = NumGRR[cu + 1];
|
|
graphicsBuffer[i * 24 + 4 + 2] = NumGRR[cu + 2];
|
|
graphicsBuffer[i * 24 + 4 + 3] = NumGRR[cu + 3];
|
|
cu += 4;
|
|
cd += 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 8; j++)
|
|
{
|
|
graphicsBuffer[i * 24 + j] = CR[i*8 + j];
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case EDO_AMA:
|
|
if((tiempos_OK == 3)&&(ds > 10))
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
graphicsBuffer[i * 24 + 0 + 0] = NumGRA[cd + 0];
|
|
graphicsBuffer[i * 24 + 0 + 1] = NumGRA[cd + 1];
|
|
graphicsBuffer[i * 24 + 0 + 2] = NumGRA[cd + 2];
|
|
graphicsBuffer[i * 24 + 0 + 3] = NumGRA[cd + 3];
|
|
graphicsBuffer[i * 24 + 4 + 0] = NumGRA[cu + 0];
|
|
graphicsBuffer[i * 24 + 4 + 1] = NumGRA[cu + 1];
|
|
graphicsBuffer[i * 24 + 4 + 2] = NumGRA[cu + 2];
|
|
graphicsBuffer[i * 24 + 4 + 3] = NumGRA[cu + 3];
|
|
cu += 4;
|
|
cd += 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 8; j++)
|
|
{
|
|
graphicsBuffer[i * 24 + j] = CA[i*8 + j];
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case EDO_VER:
|
|
if((tiempos_OK == 3)&&(ds > 10))
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
graphicsBuffer[i * 24 + 0 + 0] = NumGRV[cd + 0];
|
|
graphicsBuffer[i * 24 + 0 + 1] = NumGRV[cd + 1];
|
|
graphicsBuffer[i * 24 + 0 + 2] = NumGRV[cd + 2];
|
|
graphicsBuffer[i * 24 + 0 + 3] = NumGRV[cd + 3];
|
|
graphicsBuffer[i * 24 + 0 + 4] = NumGRV[cu + 0];
|
|
graphicsBuffer[i * 24 + 0 + 5] = NumGRV[cu + 1];
|
|
graphicsBuffer[i * 24 + 0 + 6] = NumGRV[cu + 2];
|
|
graphicsBuffer[i * 24 + 0 + 7] = NumGRV[cu + 3];
|
|
cu += 4;
|
|
cd += 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 8; j++)
|
|
{
|
|
graphicsBuffer[i * 24 + j] = CV[i*8 + j];
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((estado == EDO_ROJ) && ((i % 3) == 0) && (MODO < SOL)) // No hay Solpados Configurados
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 16; j++)
|
|
{
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Rojo[i * 16 + j];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if ((estado == EDO_ROJ) && ((i % 10) == 0) && (MODO > SOL)) // Hay un Solapado configurado
|
|
{
|
|
if(v5 == 0)
|
|
{
|
|
vv++;
|
|
if (vv >= 5)
|
|
{
|
|
v5 = 1;
|
|
vv = 5;
|
|
}
|
|
}
|
|
else if(v5 < 2)
|
|
v5++;
|
|
else
|
|
{
|
|
v5 = 0;
|
|
vv = 0;
|
|
}
|
|
|
|
if(estado_solapado == 1) // No hay solape
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 16; j++)
|
|
{
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Rojo[i * 16 + j];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 16; j++)
|
|
{
|
|
switch(MODO)
|
|
{
|
|
case NADD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Rojo_Sol_AI[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IINA:
|
|
graphicsBuffer[i * 24 + 8 + j] = Rojo_Sol_AD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case AAND:
|
|
case IIND:
|
|
case IAND:
|
|
graphicsBuffer[i * 24 + 8 + j] = Rojo_Sol_D[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case NIAA:
|
|
case NIDD:
|
|
case NIAD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Rojo_Sol_I[vv * 1024 + i * 16 + j];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if ((estado == EDO_AMA) && (i % 10) == 0)
|
|
{
|
|
if (v5 == 0)
|
|
{
|
|
vv++;
|
|
if (vv >= 5)
|
|
{
|
|
v5 = 1;
|
|
vv = 5;
|
|
}
|
|
}
|
|
else if (v5 < 4)
|
|
v5++;
|
|
else
|
|
{
|
|
v5 = 0;
|
|
vv = 0;
|
|
}
|
|
|
|
if((MODO < SOL)||((MODO > SOL) && (estado_solapado == 1))) // No hay solape
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 16; j++)
|
|
{
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Amarillo[i * 16 + j];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 16; j++)
|
|
{
|
|
switch(MODO)
|
|
{
|
|
case NADD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Ama_Sol_AI[vv * 384 + i * 6 + j];
|
|
break;
|
|
case IINA:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Ama_Sol_AD[vv * 384 + i * 6 + j];
|
|
break;
|
|
case AAND:
|
|
case IIND:
|
|
case IAND:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Ama_Sol_D[vv * 384 + i * 6 + j];
|
|
break;
|
|
case NIAA:
|
|
case NIDD:
|
|
case NIAD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Ama_Sol_I[vv * 1024 + i * 16 + j];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ((estado == EDO_VER) && (i % 10) == 0)
|
|
{
|
|
if(v5 == 0)
|
|
{
|
|
vv++;
|
|
if (vv >= 5)
|
|
{
|
|
v5 = 1;
|
|
vv = 5;
|
|
}
|
|
}
|
|
else if(v5 < 2)
|
|
v5++;
|
|
else
|
|
{
|
|
v5 = 0;
|
|
vv = 0;
|
|
}
|
|
|
|
for (uint16_t i = 0; i < 64; i++)
|
|
{
|
|
for (uint16_t j = 0; j < 16; j++)
|
|
{
|
|
if(estado_solapado == 0)
|
|
{
|
|
switch(MODO)
|
|
{
|
|
case AAA:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_AAA[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case DDD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_DDD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case III:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_III[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case ADD:
|
|
case NADD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_ADD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case AAD:
|
|
case AAND:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_AAD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IAA:
|
|
case NIAA:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IAA[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IIA:
|
|
case IINA:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IIA[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IDD:
|
|
case NIDD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IDD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IID:
|
|
case IIND:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IID[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IAD:
|
|
case IAND:
|
|
case NIAD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IAD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(MODO)
|
|
{
|
|
case NADD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_NADD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case AAND:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_AAND[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case NIAA:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_NIAA[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IINA:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IINA[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case NIDD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_NIDD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IIND:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IIND[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case IAND:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IAND[vv * 1024 + i * 16 + j];
|
|
break;
|
|
case NIAD:
|
|
graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_NIAD[vv * 1024 + i * 16 + j];
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(20));
|
|
}
|
|
}
|
|
|
|
static void HUB75_task(void *arg)
|
|
{
|
|
HUB75_init();
|
|
|
|
while (1)
|
|
{
|
|
HUB75_displayBuffer_Color64(graphicsBuffer, at);
|
|
vTaskDelay(pdMS_TO_TICKS(1));
|
|
}
|
|
}
|
|
|
|
|
|
#ifndef SIMULACION
|
|
|
|
#define INTERVALO 20
|
|
|
|
static void Luces_task(void *arg)
|
|
{
|
|
uint16_t tiempo[4] = {0, 0, 0, 0};
|
|
|
|
gpio_reset_pin(ENT_VER);
|
|
gpio_set_direction(ENT_VER, GPIO_MODE_INPUT);
|
|
gpio_set_pull_mode(ENT_VER, GPIO_PULLUP_ONLY);
|
|
|
|
gpio_reset_pin(ENT_AMA);
|
|
gpio_set_direction(ENT_AMA, GPIO_MODE_INPUT);
|
|
gpio_set_pull_mode(ENT_AMA, GPIO_PULLUP_ONLY);
|
|
|
|
gpio_reset_pin(ENT_SOL);
|
|
gpio_set_direction(ENT_SOL, GPIO_MODE_INPUT);
|
|
gpio_set_pull_mode(ENT_SOL, GPIO_PULLUP_ONLY);
|
|
|
|
estado_inicial = gpio_get_level(ENT_AMA) * 2 + gpio_get_level(ENT_VER);
|
|
do
|
|
{
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
estado_actual = gpio_get_level(ENT_AMA) * 2 + gpio_get_level(ENT_VER);
|
|
} while (estado_actual == estado_inicial);
|
|
|
|
while (1)
|
|
{
|
|
if (tiempos_OK < 3)
|
|
{
|
|
ds = 0;
|
|
estado_inicial = estado_actual;
|
|
do
|
|
{
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
ds++;
|
|
estado_actual = gpio_get_level(ENT_AMA) * 2 + gpio_get_level(ENT_VER);
|
|
} while (estado_actual == estado_inicial);
|
|
tiempo[estado_inicial] = ds;
|
|
tiempos_OK++;
|
|
}
|
|
else
|
|
{
|
|
ds = tiempo[estado_actual] + 10;
|
|
estado_inicial = estado_actual;
|
|
do
|
|
{
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
if (ds < 0)
|
|
tiempos_OK = 0;
|
|
else
|
|
ds--;
|
|
estado_actual = gpio_get_level(ENT_AMA) * 2 + gpio_get_level(ENT_VER);
|
|
} while (estado_actual == estado_inicial);
|
|
if (ds > INTERVALO)
|
|
tiempos_OK = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|