Controle remoto do Arduino Youtube para dormir (Leobot Electronics): 4 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Arduino Youtube Remote

Se você usa o Youtube para fornecer um filme ou música para assistir enquanto dorme, certamente você acordou por um anúncio carregado ou por níveis de volume diferentes quando um novo filme começa. Não é preciso dizer que isso pode ser bastante irritante.

Então, minha solução que eu provo para você construir por si mesmo é um controle remoto baseado em Arduino para interagir com o Youtube à distância. O controle remoto é necessário para alterar o volume do som principal do meu PC, pular anúncios no Youtube e pular vídeos no Youtube.

Além disso, está incluído um sensor de nível de áudio para determinar o quão alto o alto-falante realmente é, que por sua vez pode ser usado para diminuir automaticamente o nível de som ao detectar interrupções altas, como um anúncio.

Por último, adicionei um gráfico no aplicativo para PC para exibir os níveis de áudio detectados.

A solução pode ser melhor refinada, mas para mim ela cumpre a tarefa.

Etapa 1: componentes necessários

Todos esses componentes são fornecidos pela Leobot Electronics (https://leobot.net)

1) Arduino UNO R3

leobot.net/viewproduct.aspx?id=530

2) 4 CANAIS REMOTO (315MHZ) + MÓDULO RECEPTOR (315MHZ)

leobot.net/viewproduct.aspx?id=521

3) MÓDULO SENSOR DE DETECÇÃO DE VOZ DE MICROFONE E SOM (KY-037)

leobot.net/viewproduct.aspx?id=217

Programas

1) Visual Studio

visualstudio.microsoft.com/

2) IDE Arduino

www.arduino.cc/en/main/software

Etapa 2: configuração do hardware

1) Conecte o módulo receptor de 4 canais ao Arduino.

Pin do receptor de 4 canais-> Pin do Arduino Uno

GND-> GND

5V-> 5V

D0-> Digital 2

D1-> Digital 3

D2-> Digital 4

D3-> Digital 5

2) Conecte o módulo Microfone KY-037 ao Arduino

Pin do microfone KY-037-> Pin do Arduino Uno

GND-> GND

+ -> 3,3 V

A0-> Analógico 3

Etapa 3: Código Arduino

Visão geral

A lógica que o Arduino precisa seguir é a seguinte:

A) Verifique se o receptor está sinalizando algum pino.

B) Dependendo de qual porta IO o sinal é recebido é o comando que será enviado ao PC.

C) Depois de concluir todas as ações do controle remoto, detecte o nível de áudio com o microfone e envie para o PC.

D) Todos os comandos enviados para o PC têm o formato de primeiro ter um caractere depois um valor (se um valor for necessário).

E) Existem cinco comandos enviados do Arduino para o PC

uma. “U” - Aumentar o volume

b. “D” - Diminuir o volume

c. “S” - Pular Adicionar

d. “V” - Pular vídeo

e. “A” - Nível de áudio detectado seguido pelo valor

O Código Arduino:

Baixe o código do Arduino aqui:

int in1 = 2;

int in2 = 3;

int in3 = 4;

int in4 = 5;

void setup () {

Serial.begin (9600);

pinMode (A3, INPUT);

pinMode (in1, INPUT);

pinMode (in2, INPUT);

pinMode (in3, INPUT);

pinMode (in4, INPUT);

}

void loop () {

if (digitalRead (in1))

{

Serial.println ("u");

atraso (100);

}

if (digitalRead (in2))

{

Serial.println ("d");

atraso (100);

}

if (digitalRead (in3))

{

Serial.println ("s");

atraso (100);

}

if (digitalRead (in4))

{

Serial.println ("v");

atraso (100);

}

int readVal = analogRead (A3);

Serial.println (String ("a") + String (readVal));

atraso (50);

}

Etapa 4: código de aplicativo para PC (C #. NET)

O aplicativo ouvirá pela porta COM (USB) e reagirá de acordo com o comando recebido. A maneira mais simples de aumentar ou diminuir o som no PC é usar os serviços da Interrop para falar diretamente com o sistema operacional Windows. Também usamos os serviços da Interrop para mover o mouse para uma posição específica na tela e clicar. Para permitir diferentes telas e tamanhos de visualização, permitimos que o usuário especifique a posição dos botões de adicionar e ignorar vídeo.

Usamos um gráfico.net padrão para exibir todos os comandos de áudio que recebemos.

Código do Windows:

Baixe o projeto completo aqui:

leobot.net/audioadjust.zip

using System;

using System. Collections. Generic;

using System. ComponentModel;

using System. Data;

using System. Drawing;

usando System. Linq;

using System. Text;

using System. Windows. Forms;

using System. Runtime. InteropServices;

using System. IO. Ports;

using System. Threading;

namespace AudioAdjust

{

classe pública parcial Form1: Formulário

{

[DllImport ("User32. Dll")]

public static extern long SetCursorPos (int x, int y);

[DllImport ("User32. Dll")]

public static extern bool ClientToScreen (IntPtr hWnd, ref POINT point);

[DllImport ("user32.dll", CharSet = CharSet. Auto, CallingConvention = CallingConvention. StdCall)]

public static extern void mouse_event (uint dwFlags, uint dx, uint dy, uint cButtons, uint dwExtraInfo);

// Ações do mouse

const int privado MOUSEEVENTF_LEFTDOWN = 0x02;

private const int MOUSEEVENTF_LEFTUP = 0x04;

const int privado MOUSEEVENTF_RIGHTDOWN = 0x08;

const int privado MOUSEEVENTF_RIGHTUP = 0x10;

[DllImport ("user32.dll")]

estático extern void keybd_event (byte bVk, byte bScan, uint dwFlags, int dwExtraInfo);

Aleatório aRand = novo Aleatório ();

public int LastLevel = 0;

public int MaxLevel = 255;

static SerialPort _serialPort;

int adX = 1281;

int adY = 706;

int vidX = 250;

int vidY = 780;

bool enableAudioChange = false;

public Form1 ()

{

InitializeComponent ();

}

private void Form1_Load (objeto remetente, EventArgs e)

{

string names = System. IO. Ports. SerialPort. GetPortNames ();

comboBoxPort. Items. AddRange (nomes);

comboBoxPort. SelectedIndex = 0;

}

int currentPoint = 0;

private void button1_Click (objeto remetente, EventArgs e)

{

_serialPort = novo SerialPort ();

_serialPort. DataReceived + = novo SerialDataReceivedEventHandler (_serialPort_DataReceived);

_serialPort. PortName = comboBoxPort. SelectedItem. ToString (); // Defina o COM da sua placa

_serialPort. BaudRate = 9600;

if (_serialPort. IsOpen) _serialPort. Close ();

outro

{

_serialPort. Open ();

}

// keybd_event ((byte) Keys. VolumeDown, 0, 0, 0); // diminuir o volume

}

void _serialPort_DataReceived (remetente do objeto, SerialDataReceivedEventArgs e)

{

Experimente

{

string fullval = _serialPort. ReadLine ();

string com = fullval [0]. ToString ();

switch (com)

{

case "a":

{

{

// nível de áudio

string val = fullval. Replace ("a", "");

int valInt = int. Parse (val);

AddData (valInt);

}

pausa;

}

case "u":

{

// áudio

keybd_event ((byte) Keys. VolumeUp, 0, 0, 0); // diminuir o volume

pausa;

}

caso "d":

{

// áudio para baixo

keybd_event ((byte) Keys. VolumeDown, 0, 0, 0); // diminuir o volume

pausa;

}

case "s":

{

//pular Anúncio

MoveCursorSkipAd ();

Thread. Sleep (10);

DoMouseClick ();

pausa;

}

caso "v":

{

//pular Anúncio

MoveCursorSkipVideo ();

Thread. Sleep (10);

DoMouseClick ();

pausa;

}

}

}

pegar

{

}

// lança novo NotImplementedException ();

}

private void MoveCursorSkipAd ()

{

Cursor. Position = novo ponto (1140, 725);

Cursor. Position = novo ponto (adX, adY);

}

private void MoveCursorSkipVideo ()

{

Cursor. Position = novo ponto (1140, 725);

Cursor. Position = novo ponto (vidX, vidY);

}

public void DoMouseClick ()

{

// Chame a função importada com a posição atual do cursor

uint X = (uint) Cursor. Position. X;

uint Y = (uint) Cursor. Position. Y;

mouse_event (MOUSEEVENTF_LEFTDOWN, X, Y, 0, 0);

mouse_event (MOUSEEVENTF_LEFTUP, X, Y, 0, 0);

}

void AddData (nível interno)

{

if (enableAudioChange)

{

if (level> = MaxLevel)

{

keybd_event ((byte) Keys. VolumeDown, 0, 0, 0); // diminuir o volume

keybd_event ((byte) Keys. VolumeDown, 0, 0, 0); // diminuir o volume

keybd_event ((byte) Keys. VolumeDown, 0, 0, 0); // diminuir o volume

}

outro

{

if (nível <MaxLevel - 0)

{

keybd_event ((byte) Keys. VolumeUp, 0, 0, 0); // diminuir o volume

}

}

}

SetChart (nível);

currentPoint ++;

}

delegado void SetTextCallback (int val);

private void SetChart (int val)

{

// InvokeRequired obrigatório compara o ID do segmento do

// chamando o encadeamento para o ID do encadeamento do encadeamento em criação.

// Se esses threads forem diferentes, ele retorna verdadeiro.

if (this.chart1. InvokeRequired)

{

SetTextCallback d = new SetTextCallback (SetChart);

this. Invoke (d, novo objeto {val});

}

outro

{

chart1. Series [0]. Points. AddXY (0, val);

if (currentPoint> = 10)

{

chart1. Series [0]. Points. RemoveAt (0);

}

}

}

private void textBoxLevel_TextChanged (objeto remetente, EventArgs e)

{

Experimente

{

MaxLevel = int. Parse (textBoxLevel. Text);

}

pegar

{

textBoxLevel. Text = MaxLevel + "";

}

}

private void buttonTestSkip_Click (objeto remetente, EventArgs e)

{

MoveCursorSkipAd ();

Thread. Sleep (10);

DoMouseClick ();

}

private void textBoxXpos_TextChanged (objeto remetente, EventArgs e)

{

Experimente

{

adX = int. Parse (textBoxXpos. Text);

}

pegar

{

textBoxXpos. Text = adX + "";

}

}

private void textBoxYpos_TextChanged (objeto remetente, EventArgs e)

{

Experimente

{

adY = int. Parse (textBoxYpos. Text);

}

pegar

{

textBoxYpos. Text = adY + "";

}

}

private void buttonSkipVideo_Click (objeto remetente, EventArgs e)

{

MoveCursorSkipVideo ();

Thread. Sleep (10);

DoMouseClick ();

}

private void textBoxXposVid_TextChanged (objeto remetente, EventArgs e)

{

Experimente

{

vidX = int. Parse (textBoxXposVid. Text);

}

pegar

{

textBoxXposVid. Text = vidX + "";

}

}

private void textBoxYposVid_TextChanged (objeto remetente, EventArgs e)

{

Experimente

{

vidY = int. Parse (textBoxYposVid. Text);

}

pegar

{

textBoxYposVid. Text = vidY + "";

}

}

private void checkBoxEnable_CheckedChanged (objeto remetente, EventArgs e)

{

enableAudioChange = checkBoxEnable. Checked;

}

}

[StructLayout (LayoutKind. Sequential)]

estrutura pública POINT

{

public int x;

public int y;

}

}