# Control de LED de usuario por medio de script en C++

El objetivo de este script en lenguaje C++ es controlar uno de los LED's de usuario
integrados en la BeagleBone Black por medio de los registros del sistema.

![BeagleBone Black y sus LED's de usuario](bbled.png)


## Header
### Librerías
En el encabezado **led.h** se importan las librerías necesarias para
realizar las operaciones de entrada y salida en la terminal de la Beaglebone, manejo de archivos,
así como otras operaciones estandar y el manejo de strings.

```cpp
#ifndef LED_H
#define LED_H
#include<iostream>
#include<fstream>
#include<string>
#include<sstream>
```
### Clases
Se define la clase CLED que se usará en el main para nuestro objeto LED, junto 
con su destructor de clase y todos sus métodos.

```cpp
class CLED{
	private:
		std::string path;
		int ledNumber;
		virtual void WriteLED(std::string filename, std::string value);
		virtual void RemoveTrigger();
	public:
		CLED(int ledNumber); //class creator
		virtual ~CLED(); //class deconstructor
		virtual void TurnOn();
		virtual void TurnOff();
		virtual void BlinkLED();
};

#endif
```

## Métodos
En **led.cpp** se desarrollan los métodos definidos en el encabezado, primero 
se establece la dirección de los registros de los LED de usuario.

```cpp
#define LED_PATH "/sys/class/leds/beaglebone:green:usr"

```

**CLED:** Es el creador de la clase y de nuestro objeto, nos entrega la dirección
del LED de usuario que escojamos.

```cpp
CLED::CLED(int ledNumber){
	this->ledNumber = ledNumber; //Solo para argumentos que sean numeros
	std::ostringstream s;
	s << LED_PATH << ledNumber;
	path =std::string(s.str()); //convert to string
}
```
**WriteLED:** Es el método que modifica los registros de nuestro LED.

```cpp
void CLED::WriteLED(std::string filename, std::string value){
	std::ofstream fs;
	fs.open((path+filename).c_str());
	fs << value;
	fs.close();
}
```
**RemoveTrigger:** Método que desactiva el trigger.


```cpp
void CLED::RemoveTrigger(){
	WriteLED("/trigger", "none");
}
```

Los métodos **TurnOn** y **TurnOff** desactivan el trigger con RemoveTrigger, y
con WriteLED cambian el registro *brightness* para encender o apagar el LED. 
**BlinkLED** solo utiliza WriteLED para cambiar el trigger a *timer* y 
así modificar los registros *delay_on* y *delay_off* para cambiar los tiempos de
encendido y apagado.

```cpp
void CLED::TurnOn(){
	std::cout << "LED Turn On: " << ledNumber << " on" << std::endl;
	RemoveTrigger();
	WriteLED("/brightness", "1");
}

void CLED::TurnOff(){
	std::cout << "LED Turn Off: " << ledNumber << " off" << std::endl;
	RemoveTrigger();
	WriteLED("/brightness", "0");
}

void CLED::BlinkLED(){
	std::cout << "LED blinking: " << ledNumber << " blinking" << std::endl;
	WriteLED("/trigger", "timer");
	WriteLED("/delay_on", "50");
	WriteLED("/delay_off", "50");
}
```

Por último, el destructor de clase.
```cpp
CLED::~CLED(){
	std::cout << "destroying LED " << path << std::endl;
}
```

## Main

En **main.cpp** se incluye nuestro encabezado, y se utilizan los argumentos 
*argc* y *argv* para conocer lo que se ingresa en la terminal. Argc nos indicará
si el número de argumentos es correcto.

Se nos indica como usar los comandos, en terminal se desplegará un mensaje que indica que la app inicia, dónde se crean los 4 objetos LED que controlarán nuestros LED de usuario en un arreglo.

```cpp
#include"led.h"
#include<string>
using namespace std;

int main(int argc, char* argv[]){
	
	
	if(argc!=2){
		std::cout << "Error: This is not a command for this application" << std::endl;
		std::cout << "These are the commands you can use: on, off and blink" << std::endl;
	}

	std::cout << "Starting app" << std::endl;
	string cmd(argv[1]);

	CLED leds[4] = {CLED(0), CLED(1), CLED(2), CLED(3)};
```
Los comandos entrarán en un ciclo if para seleccionar la acción del LED, comparando el valor 
de argumento en la terminal con unos comandos definidos: ***on***, ***off*** 
y ***blink***, a su vez, al ingresar un comando erróneo saldrá en la terminal una alerta que desplegará la lista de comandos correctos.

Si se desea controlar un solo LED en particular, se remplaza la letra "i" en el objeto leds[i] por el número de LED que se quiere controlar.

```cpp
	for(int i=0; i<=3; i++){
		if(cmd=="on")
			leds[i].TurnOn();
		
		else if(cmd=="off")
			leds[i].TurnOff();
		
		else if(cmd=="blink")
			leds[i].BlinkLED();
		
		else{
			std::cout << "Error: Invalid command" << std::endl;
			std::cout << "These are the commands you can use: " << std::endl;
			std::cout << "on - Powers on the LED" << std::endl;
			std::cout << "off - Powers off the LED" << std::endl;
			std::cout << "blink - Makes the LED blink" << std::endl;	
		}	
	}	
	return 0;
}
```

## Ejecución

Se creó un archivo makefile para compilar, eliminar archivos 
antiguos de salida y para hacer un debug.
```console
all: 
	g++ main.cpp -o led led.cpp

clean:
	rm led

debug:
	g++ -g main.cpp -o led led.cpp

```

O se puede compilar directamente de terminal con el primer comando del makefile, en modo superusuario.
```
sudo g++ main.cpp -o led led.cpp
```

Se otorgan los permisos necesarios a nuestro ejecutable.
```
sudo chmod u+x led
```

Y se ejecuta con cualquiera de los comandos disponibles.

Encender LED
```
./led on
```

Apagar LED
```
./led off
```

Parpadear LED
```
./led blink
```