---
# System prepended metadata

title: Proyecto 2ndo Semestre - Team 5
tags: [notas Grupales (Proyecto equipo 5)]

---

---
tags: notas Grupales (Proyecto equipo 5)
---


# Proyecto 2ndo Semestre - Team 5 
![](https://hackmd.io/_uploads/HyIP4NF43.png)


# **Led Race**

Después de darle muchas "vueltas" decidimos poner en marcha el proyecto **Led Race** el cual consiste en crear un juego de carreras al estilo scalextric pero utilizando tiras de leds como carriles, la luz de los leds como coches y joysticks como mandos para moverlos.

Pero la cosa no acaba ahí, además tendremos la peculiaridad de implementar nuevas mecánicas que lo harán único como **cambiar de carril, obstáculos y speed points**.

Por último se implementarán sonidos mediante buzzers, una cuenta atrás a través de una pantalla de leds y módulos de cartón para montar tu propio circuito.

> **Creadores:** Raúl Hortelano, Marta Vilaseca, Irina Aynes y Gabriel Vallarta.

---
## **Proposito**
Nuestro proyecto tiene como objetivo desarrollar una carrera de coches LED. La idea es que el usuario pueda crear manualmente diferentes diseños de pistas, incluyendo rectas, curvas y loops.

Con este proyecto, esperamos ofrecer un nuevo juguete que sea accesible para todas las edades, tanto en términos de dificultad como de precio. Nuestro objetivo es crear un juguete que sea fácil de usar, pero que también proporcione una experiencia emocionante y desafiante para los usuarios.

En resumen, nuestro proyecto busca combinar la diversión y emoción de las carreras de coches con la facilidad de uso y accesibilidad de los juguetes LED.


## **Cartel gráfico de presentación del proyecto**

![](https://hackmd.io/_uploads/BJ3VGqmv2.png)

## **Funcionamento**
Antes de empezar ha jugar hay que crear un circuito con elementos que tengas en casa, por ejemplo cartones o cartulinas. Seguidamente enganchar dos tiras de led en este.

El juego consiste en una carrera de coches de leds. Primero un seven segments de 4 digitos te marcara el inicio (3,2,1, GO) seguido de la musica de un buzzer. Una vez dentro de la carrera tendras que ser el mas rápido en esquivar los obstaculos y seguir el circuito que has creado. Para poder realizar esto tendras que ir canviando de carril y intentar no chocar con los obstaculos ya que te paralizaran.

## **Video del proyecto funcionando** :video_camera: 
https://www.canva.com/design/DAFlim4eVTc/yDuPx4qQPxESel_yRaV5vQ/edit?utm_content=DAFlim4eVTc&utm_campaign=designshare&utm_medium=link2&utm_source=sharebutton


## **Elementos necesarios**
1. **2 tiras LED**: Para este proyecto se han utilizado los **WS2811 LED Strip** de 5 metros, son necesarios 12V.
2. **Transformador de 12V**: Para este proyecto se ha utilizado el modelo **HR-W-12V**
3. **Placa Arduino**: Para este proyecto se ha utilizado la placa **Arudino Mega 2560**.
4. **2 joysticks**.
5. **2 Buzzers**.
6. **Pantalla de leds sh5461as**.
7. **Rampas de cartón**

## **Inputs & Outputs**

* Inputs
    2 Joysticks

* Outputs
    2 tiras de led
    Sonido (buzzer)
    Seven segments 4 digitos

## **Diagrama de Flujos**

![](https://hackmd.io/_uploads/Sybj9_XP3.png)


## **Sonidos con Buzzer** desde Arduino

Para este experimento utilicé:
- Placa tipo Arduino - Modelo **ttgo-lora32**
- Protoboard
- 3 cables de tipo macho-macho
- Buzzer de 5v

Les dejo la imagen de refernecia de los pines de la placa **ttgo-lora32**

![](https://i.imgur.com/oulrgoy.png)


Conecté el Buzzer a los 5v de la placa y a su respectivo pin de tierra. Una vez tenía esto para alimengtar correctamente el Buzzer, conecté el pin 12 a la señal del Buzzer y me puse ya de lleno con el código.

---


Primero probé este código básico, con mi pin en el 12 de la placa de Arduino.

```=cpp
#include <Arduino.h>

int buzzer = 12;

void setup() {
  // put your setup code here, to run once:
  pinMode(buzzer, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  tone(buzzer, 10000, 500);
  delay(1000);
  noTone(buzzer);
  delay(1000);
}
```

**tone(buzzer, 10000);** - Para esta función se incluye, en primer lugar, el pin del buzzer, en segundo lugar, la frecuencia del tono, y en tercer lugar, la duración del tono. El valor de reproducción de estos tonos puede oscilar entre 31 y 65000 hercios.

**noTone(buzzer);** — Esto detendrá el tono.

---

```=cpp
#include <Arduino.h>
#include "../lib/pitches.h" //My tone library

int buzzer = 12;

void setup() {
  // put your setup code here, to run once:
  pinMode(buzzer, OUTPUT);
}

void Toneone() {
  int melody[] = { //tone array
    NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0,
    NOTE_B3, NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, NOTE_G3,
    NOTE_B3, NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, NOTE_G3,
    NOTE_C4, NOTE_G3, NOTE_G3, NOTE_G3, 0
  };
  int noteDurations[] = {4, 8, 8, 4, 4, 4, 8, 8, 8, 8, 4, 4, 8, 8, 8, 8, 4, 4, 4, 8, 8, 4, 4};
  for (int thisNote = 0; thisNote < 23; thisNote++) {
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(8, melody[thisNote], noteDuration); //play tone
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);//delay
    noTone(8);//tone off
  }
}

void Tonetwo() {
  int melody2[] = {NOTE_GS7, NOTE_DS8, NOTE_GS7, 0, NOTE_DS8, NOTE_DS8, 0, NOTE_GS7, NOTE_GS7};
  int noteDurations[] = {4, 8, 8, 4, 8, 8, 4, 4, 4};
  for (int thisNote = 0; thisNote < 9; thisNote++) {
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(8, melody2[thisNote], noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(8);
  }
}

void Tonethree() {
  int melody3[] = {NOTE_GS6, NOTE_A6, NOTE_AS6, NOTE_B6, NOTE_C7,
                   NOTE_CS7, NOTE_D7, NOTE_DS7, NOTE_E7 };
  int noteDurations[] = {4, 8, 8, 4, 8, 8, 4, 4, 4};
  for (int thisNote = 0; thisNote < 9; thisNote++) {
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(8, melody3[thisNote], noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(8);
  }
}

void Tonefour() {
  int melody4[] = {  NOTE_F5, NOTE_C6, NOTE_AS5, NOTE_C6, NOTE_AS5, NOTE_C6, NOTE_GS5,
                     NOTE_AS5, NOTE_C6, NOTE_AS5, NOTE_GS5, NOTE_FS5, NOTE_F5, NOTE_C6,
                     NOTE_AS5, NOTE_C6, NOTE_AS5, NOTE_C6, NOTE_GS5, NOTE_AS5, NOTE_C6,
                     NOTE_AS5, NOTE_F5, NOTE_C6, NOTE_AS5, NOTE_C6, NOTE_AS5, NOTE_C6,
                     NOTE_GS5, NOTE_AS5, NOTE_C6, NOTE_AS5, NOTE_GS5, NOTE_FS5, NOTE_DS5,
                     NOTE_F5, NOTE_FS5, NOTE_GS5, NOTE_FS5, NOTE_F5, NOTE_DS5, NOTE_FS5, NOTE_F5
                  };
  int noteDurations[] = {4, 8, 4, 8, 8, 8, 4, 8, 8, 4, 8, 8, 4, 8, 4, 8, 8, 8, 4, 8, 8, 2, 4, 8, 4, 8, 8, 8, 4, 8, 8, 4, 8, 8, 4, 8, 8, 4, 8, 8, 4, 8, 2};
  for (int thisNote = 0; thisNote < 43; thisNote++) {
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(8, melody4[thisNote], noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(8);
  }
}


void loop() {
  Toneone();
  delay(100);
  Tonetwo();
  delay(100);
  Tonethree();
  delay(100);
  Tonefour();//uncomment this tone
  delay(100);
}
```

---

## **Digitos con sh5461as** desde Arduino

Para este experimento utilizamos:
- Placa tipo Arduino - Modelo **MEGA**
- Protoboard
- 12 cables de tipo macho-macho
- Resistencias de 560 Ω

A continuación se muestra una imagen del montaje:

    
<img style="max-height: 500px" src= "https://www.circuitbasics.com/wp-content/uploads/2017/05/Arduino-7-Segment-Display-4-Digit-Display-Connection-Diagram.png"></img> 


En primer lugar, para poder utilizar nuestro 4 Digit 7 Segments necesitamos conectar los 12 cables en sus respetivas posiciones del android MEGA y las diferentes resistencias.

Una vez tenemos todos los cables en sus posiciones pasaremos a implementar el código para mostrar por pantalla una cuenta hacia atras de 3,2,1 y la palabra GO, para ello utilizaremos el programa visual studio code con el siguiente código:

* **Contador**: se ha dividido el codigo en dos ficheros para crear una clase del contador y al final poder integrar esta parte a las otra mas facil. Para esto se ha realizado los archivos .cpp y .hpp.

En el archivo Contador.hpp añadimos lo siguiente, en este se crean las variables y las cabeceras de los métodos:
```=cpp
#pragma once
#include "SevSeg.h"

class Contador{
    SevSeg sevseg; 
    int contador1 = 3;     
    int espera = 0;        
    int esperamax = 8000;  
    int start;

    public:
    Contador();
    void setUpContador();
    void showContador();
};

```

* Seguidamente para el archivo Contador.cpp introducimos el siguiente código donde se implementan las funciones:
```=cpp
#include "Contador.hpp"

Contador::Contador(){}

void Contador::setUpContador(){
        byte numDigits = 4;
        byte digitPins[] = {10, 11, 12, 13};
        byte segmentPins[] = {9, 2, 3, 5, 6, 8, 7, 4};
        bool resistorsOnSegments = true; 
        bool updateWithDelaysIn = true;
        byte hardwareConfig = COMMON_CATHODE; 
        sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
        sevseg.setBrightness(90);
        start = 0;
}

void Contador::showContador(){
        sevseg.refreshDisplay();
        sevseg.setNumber(contador1, -1);
        if (contador1 == 0){
                sevseg.setChars(" GO ");
                sevseg.refreshDisplay();
                start = 1;
        }

        if (start == 0){
                espera = espera + 1;
                if (espera == esperamax){
                        espera = 0;
                        contador1 = contador1 - 1;
                }
        }
}

```
Se usa la la libreria **"Sevseg.h"** para poder configurar el seven segments a arduino. De esta libreria las funciones más usadas han estado **setNumber()** para poner el numero a mostrar en el display, **setChar()** para escrivir la palabra "GO" y **refreshDisplay()** para mostrar los numeros/palabras escritos.

* Y finalmente en el main llamamos a las funciones para que el contador funcione:

```=cpp
#include <Arduino.h>
#include "Contador.hpp"
Contador cont; 

void setup(){
    cont.setUpContador();
}

void loop(){
    cont.showContador();   
}

```

El método **setUpContador()** configura e inicia el display seven segments de 4 digitos. Y el **showContador()** muestra los numero 3,2,1 y la palabra GO.

---
##    Lógica del juego
Se ha decidido implementar programación orientada a objetos con las siguientes clases:
* **GameManager**: Clase encargada de gestionar los diferentes estados que pueda tener el juego así como de llamar a las demás clases para que interctuen entre sí.

```=cpp
#pragma once

#include <FastLED.h>
#include <Arduino.h>
#include "Car.hpp"
#include "Led.hpp"

#define LED_PIN 30 // Define the digital pin connected to the LED strip
#define LED_PIN2 31
#define LED_COUNT 100 // Define the number of LEDs in the strip
#define COLOR_ORDER RGB // Define the color order of the LEDs
#define JOYSTICK_1 A0 // Define the analog pin connected to the joystick X-axis
#define JOYSTICK_2 A1 // Define the analog pin connected to the joystick Y-axis
#define JOYSTICK_THRESHOLD 512 // Define the threshold value for joystick movement detection

class GameManager{

    //Leds to pass to fastLed library
    CRGB lineOne[LED_COUNT];
    CRGB lineTwo[LED_COUNT];

    //Led class linked with position of leds
    Led lineCustomOne[LED_COUNT];
    Led lineCustomTwo[LED_COUNT];
    int joystickOneX = 0;
    int joystickOneY = 0;
    int joystickTwoX = 0;
    int joystickTwoY = 0;
    int frameRate = 1;
    float timeCarStopped = 0.4;
    int totalLaps = 10;
    CFastLED fastLed;
public:
    GameManager();
    void Start();
    void InitLeds();
    void RunRace(); //Llama a las demás funciones en el orden adecuado (modifica la posición de los coches, los pinta, etc...)
    void ReadJoysticks(); //Toma los inputs de los mandos
    void ControlObstacleCollision(); //Se encarga de detectar la colision de los coches con los obstaculos
    void PrintObstacles(); //Ilumina los leds correspondientes a los obstaculos
    void ControlSpeedPointCollision(); //Se encarga de detectar la colision de los coches con los speed points
    void PrintSpeedPoints(); //Ilumina los leds correspondientes a los speed points
    void ControlLaps(); //Gestiona las vueltas de los coches
    void SpawnObstaclePoint(bool isLineOne); //Inserta un obstaculo en un lugar libre
    void SpawnSpeedPoint(bool isLineOne); //Inserta un speed point en un lugar libre
    int* GetFreeSlots(bool isLineOne, int* freeIndex); //Devuelve todos los huecos libres de una tira de leds (sin obstaculos, speed points ni coches)
};
```

* **Car**: Clase encargada de gestionar cada coche (su posición, velocidad, etc.).

```=cpp
#pragma once

#include <FastLED.h>


class Car{
    int totalLeds;

    public:
        float position = 0;
        float velocity = 0;
        float aceleration = 0.02;
        float maxVelocity = 0.1;
        float speedBurtsVelocity = 0.9;
        int currentLap = 0;
        
        bool canRun = true;
        float currentStoppedTime = 0;
        float currentSpeedBurstTime = 0;
        CRGB color;
        CRGB* line;

        Car();
        Car(CRGB color, int ledCount);
        int GetPosition(); //Devuelve el indice de la posición en la que se encuentra el coche
        void Run(int totalLeds, int canMove); //Calcula la posición del coche en función de su velocidad y la aceleración
        void PrintCar(); //Ilumina el led correspondiente a la posición del coche
        void StopCar(); //Para el coche durante un tiempo determinado
        void ControlIfCarCanRun(float time); //Controla si el coche puede correr o no
        void ControlIfCarCanBurst(float time); //Controla si el coche va muy acelerado o no
};
```
* **Led**: Clase encargada de gestionar cada led por separado (si es un obstáculo, un speed point, etc.).

```=cpp
#pragma once

#include "Car.hpp"

class Led
{

    
public:
    int position;
    bool isObstacle = false;
    bool isSpeedPoint = false;

    Led();
    
};
```


---

## Usando RX y TX para hablar entre placas

Recomiendo usar una terminal por proyecto dentro del Visual Studio Code:

![](https://i.imgur.com/5Yx0ohx.png)

Es **importante** mencionar que si se estan utilizando dos placas distintas e insertando código a ambas de manera simultanea, se **desconecten** los puertos **RX** y **TX** porque estarán ocupadas mientras subimos el código. 

![](https://i.imgur.com/NxuoG3C.png)


---

## Elementos de cartón

Para poder realizar lo diferentes elementos para el circuito vamos a necesitar:

- Cartón 
- Cinta adhesiva
- Cinta doble cara 
- Tijeras o cúter

En este caso, este paso es bastante abierto al usuario, dado que cada persona puede decidir como quiere diseñar su circuito. 

Como pases generales tenemos:

1. Marcar las medidas en el cartón con lapiz.
2. Recordar los diferentes elementos.
3. Pegarlos con celo o algun otro material.

Como paso opcional, podemos añadir papeles de colores o otro tipo de material decorativo para dejar nuestros elementos más bonitos visualmente.

---

# Modelando Mando para imprimir en 3D

Sabiamos que necesitaríamos un mando para nuestro proyecto, ya que haría la interacción con el juego mucho más user-friendly e intuitivo. De esta manera también podiamos aprovechar la oportunidad de aprender a preparar y diseñar un producto pensando en llevarlo a producción mediante el uso de las impresoras 3D que tiene la uni.


## Prototipo cartón

A continuación está el prototipo que he realizado con cartón reciclado del mando. Originalmente habíamos pensado hacerlo de cierta forma que favoreciera a los diestros, pero después de hacer uso de la pista con este mando nuevo, pensamos que sería mejor hacerlo simétrico para no tener que favorecer a nadie.

<img style="max-height: 400px" src= "https://hackmd.io/_uploads/B1Q4zEtV2.jpg"></img> 

<img style="max-height: 400px" src= "https://hackmd.io/_uploads/rkR1ZEtN3.jpg"></img> 

Lo hecos hecho bastante ergonómico, basandonos bastante en las "mitades" de mandos de Play Station y de Xbox.

<img style="max-height: 400px" src= "https://hackmd.io/_uploads/SkUHGEK4h.jpg"></img> 

<img style="max-height: 400px" src= "https://hackmd.io/_uploads/rynOfNF4h.jpg"></img> 

## Modelo 3D - 3DsMax

![](https://hackmd.io/_uploads/SJ50MNYVn.png)

Incluso ya teniendo las medidas tomadas de cada parte específica del prototipo realizado con cartón, fueron necesarias varias iteraciones del modelo 3D. Tuvimos también que tomar en cuenta el espacio que ocuparían los cables del joystick, al igual que el motor que hará que vibre el mando, el cual tiene su sitio debajo del mando.

![](https://hackmd.io/_uploads/SkFE74t43.jpg)

Es importante mencionar que todas las medidas actuales del modelo fueron posibles de replicar en 3D gracias a que utilicé referencias instanciadas como cajas "Boxes" en el software, con medidas en milimetros para que fuera de escala 1:1 con la realidad y encajara con nuestros componentes que hemos estado utilizando.

![](https://hackmd.io/_uploads/r16LrVFEh.png)

Esto ya es un detalle más técnico, pero es altamente recomendable que, cual sea el Software que esten usando para modelar, activen el modo de transparencia para poder observar más claramente los espacios interiores del modelo. En 3DsMax es Alt + X para entrar en modo transparente.

![](https://hackmd.io/_uploads/SyiPI4Y4h.png)

Compartimiento para el motor que hará vibrar el mando nuevo.

![](https://hackmd.io/_uploads/rJLfvEF4n.png)



--- 
# Instrucciones básicas
Se ha creado un libro con imágenes detalladas y explicadas dirigidas a un público infantil supervisado por un adulto. A continuación se muestra los apartados que contiene el libro y seguidamente las imágenes con cada explicación paso a paso.

Apartados:
- Conectar el arduino a los leds
- Conectar el arduino a la fuente
- Conectar los mandos al arduino
- Conectar el display al arduino
- Conectar el buzzer al arduino
- Colocar el codigo al ordenador
- Conexión entre los dos arduinos
- Conectar el codigo con arduino
- Construir tu propio circuito
- A Jugar!

Imágenes:

![](https://hackmd.io/_uploads/ryHmvNtVh.jpg)

![](https://hackmd.io/_uploads/SkuC84FNn.jpg)

![](https://hackmd.io/_uploads/S1egvVtVh.jpg)

![](https://hackmd.io/_uploads/SyBgPEYEn.jpg)

![](https://hackmd.io/_uploads/B1ulD4K43.jpg)

![](https://hackmd.io/_uploads/HkjevNFVh.jpg)

![](https://hackmd.io/_uploads/Hk0gwNKV3.jpg)

![](https://hackmd.io/_uploads/ryM-PEKV2.jpg)

![](https://hackmd.io/_uploads/SywZvEYNn.jpg)

![](https://hackmd.io/_uploads/BkK-DVKNh.jpg)

No hemos detallado el proceso interno, ya que es  bastante difícil para la comprensión de un niño. Pero este proyecto se puede realizar sin la conexión, simplemente hay que ejecutar los dos scripts por separado. No obstante, hemos dejado estas instrucciones por si alguien quiere investigar como hacer el proceso internamente.

![](https://hackmd.io/_uploads/BJeMDEtN3.jpg)

![](https://hackmd.io/_uploads/r1zzvNYEh.jpg)

![](https://hackmd.io/_uploads/Hy8MP4KN2.jpg)

![](https://hackmd.io/_uploads/r1lXwNY4n.jpg)

---
# BOM (Bill Of Materials)

Se ha calculado un presupuesto para evaluar si a nivel de negoció sería rentable.
Primero se ha calculado componente a componente cuanto sería el Total, a continuación se muestra el cálculo:

![](https://hackmd.io/_uploads/r1zbmu7Ph.png)

Se puede observar como el presupuesto sube mucho, pero tenemos previsto comprar una gran cantidad de estos componentes y así obtener un mejor precio unitario. Y por ende un presupuesto mucho más económico. Podríamos rebajar el precio actual a 73 €.


---

# Packaging del producto

Para poder empaquetar nuestro producto, hemos realizado un análisis comparativo inicial para identificar productos similares en el mercado. Debido a que nuestro producto está dirigido a niños, hemos elegido utilizar colores vivos, como el rojo, y tipografías llamativas que evocan la velocidad y la emoción de las carreras. Además, la caja presenta varias ilustraciones que también reflejan el tema de las carreras, como la marca del neumático.

En primer lugar, creamos una versión inicial del empaque sin tener en cuenta las dimensiones de los componentes del producto. Después de identificar el tamaño de la batería, decidimos modificar la caja para que tenga unas dimensiones mayores.

A continuación se muestra la primera versión:

![](https://hackmd.io/_uploads/BJN9_VtNn.png)

Finalmente tenemos la última versión del packaging de nuestro producto:

![](https://hackmd.io/_uploads/rkle3YNF43.png)

Utilizamos una herramienta en línea que nos permitió generar automáticamente los planos de la caja al introducir las medidas requeridas.
Luego, utilizamos Figma para crear las ilustraciones.


Para crear el prototipo real, tomamos una caja y la pintamos completamente de negro. Luego, imprimimos todas las ilustraciones del diseño de la caja y las adherimos al prototipo. De esta manera, pudimos visualizar cómo se vería el producto finalizado.

Imágenes del proceso:


![](https://hackmd.io/_uploads/S1sniNt43.png)

![](https://hackmd.io/_uploads/Hk1XnNFEh.jpg)


---
## Les dejamos debajo la documetación de nuestra primera idea de proyecto por si han llegado hasta aquí y siguen con ganas de leer más cosas :wink:

:::spoiler **Primera idea** :fortune_cookie:

### Idea original - Casita :house:

**Casita**: https://planner5d.com/v?key=d8f9d6aecfad3b7de4b05f64917c3c63&viewMode=2d


Estamos revolucionando la manera de porteger tu casa.
 
Con nuestro sistema de simulación de comportamineto humano, logramos simular tus rutinas como si estuvieras en casa, mientras disfrutas de tus bien merecidas vacaciones donde quiera que estes.

Hagamops que los ladrones crean que estas en casa y deja que tu casa se proteja sola mientras tu descansas. 

Súmate a nuestra inovadora revolución de sistema de seguridad accesible para todos!



### Inputs & Outputs

#### Inputs
1. Detección de movimiento (EMOS G1240)
2. Detección de ruido (MIC)
4. Cerrojo de puerta
5. Ejecución desde App - Instrucción de script
6. Finalización desde App - Stop

#### Outputs
1. Televisor
2. Luces comedor
3. Luces Baño
4. Luces Cocina
5. Alarma al detectar movimiento
6. Sonido retrete
7. Sonido pasos
8. Sonido microondas
9. Sonido puertas cerrando
10. Sonido Tosido
11. Sonido Lavadora
12. Sonido Lavaplatos


---
## Reproducir Audios en Altavos Bluetooth

**Link:** https://www.okdo.com/project/set-up-a-bluetooth-speaker-with-a-raspberry-pi/?ok_ts=1676474797756


### 1. Get your Pi ready
Update the operating system.
>  sudo apt update
>  sudo apt full-upgrade

Remove any previous Alsa Bluetooth profile loader.
> sudo apt purge bluealsa

Install PulseAudio Bluetooth profile loader.
> sudo apt install pulseaudio-module-bluetooth

For Lite users, add pi user to bluetooth group.
> sudo usermod -a -G bluetooth pi

Reboot.
After restart, your system will be ready to connect to Bluetooth audio.

*Continuar en:* https://www.okdo.com/project/set-up-a-bluetooth-speaker-with-a-raspberry-pi/?ok_ts=1676474797756


---

## Detector de Distancia y LED Arduino MEGA 22/02

Hoy, 22 de febrero comenzamos las primeras pruebas con Arduino MEGA 2560

### Encender LED en Arduino MEGA

Usamos un PIN 7 para mandar voltaje a nuestro LED con su resistencia para hacer que parpadeara.

```=cpp
#include <Arduino.h>
#define LED_PIN 7

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(1000);
  digitalWrite(LED_PIN, LOW);
  delay(1000);
}
```

### Encender un LED cuando estemos a 15cm del sensor HC-SR04


```=cpp
#include <Arduino.h>

/*
    Ultrasonic sensor Pins:
        VCC: +5VDC
        Trig : Trigger (INPUT) - Pin11
        Echo: Echo (OUTPUT) - Pin 12
        GND: GND
 */
 
#define trigPin 11   // Disparador (Trigger)
#define echoPin 12    // Eco (Echo)
#define LED_PIN 7
long duration, cm, inches;
 
void setup() {
  //Inicia el Serial Port
  Serial.begin (9600);
  //Define entradas y salidas
  pinMode(trigPin, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
  pinMode(echoPin, INPUT);
}
 
void loop() {
  // El sensor se activa con un pulso ALTO de 10 microsegundos o más
  // Emite un breve pulso BAJO antes para asegurar un pulso ALTO limpio:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
 
  // Lee la señal del sensor: un pulso ALTO cuya duración
  // es el tiempo (en microsegundos) desde el envío del
  // ping hasta la recepción de su eco de un objeto.
  pinMode(echoPin, INPUT);
  duration = pulseIn(echoPin, HIGH);
 
  // Convierte el tiempo en distancia
  cm = (duration/2) / 29.1;     // Divide entre 29.1 o multiplica por 0.0343
  
  Serial.print(cm);
  Serial.print("cm");
  Serial.println();

  cm < 18 ? digitalWrite(LED_PIN, HIGH) : digitalWrite(LED_PIN, LOW);
  
  delay(250);
}
```

Link de info: https://mielectronicafacil.com/proyectos/arduino/sensor-ultrasonico-hc-sr04/#codigo


### Fotos

![](https://i.imgur.com/dRPzNY9.jpg)
![](https://i.imgur.com/Ifyf1v4.jpg)
![](https://i.imgur.com/l6OgUzz.jpg)
![](https://i.imgur.com/xbGI9DX.jpg)




---

## TODO

1. Conectar los "Arduinos" de Víctor a internet mediante código de VS para arduino.
2. Conectar el NODE RED a la Raspberry PI.
3. Probar el sensor de infrarrojos desde VS Arduino.

### Idea loquita
Mapear la clase en la que estamos en la maqueta 

- **Inputs** 
Ruidos 
Presencias

- **Outputs (en maqueta)**
Leds (intensidad variable)
Sonidos

Podriamos añadir un plano más sentimental, por ejemplo tener la casa de tus padres en miniatura en tu casa y poder tener una idea de dónde estan (habitaciones) y como están (ruidos o otros inputs).


---

## LoLin

Descargar IDE de Arduino 
```
https://www.arduino.cc/en/donate/
```

*A continuación seleccionamos File -> Examples -> ESP8266 -> Blink* 

Meter esto en Arduino 

`http://arduino.esp8266.com/stable/package_esp8266com_index.json`


---

:::