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.

135 lines
3.5 KiB

  1. # Control de LED Beagle Bone Black
  2. ## Este programa permite encender, apagar o hacer parpadear los LED de la Beagle Bone Black con un script en C++.
  3. Se comienza por importat librerías y declarar el path a seguir para
  4. manipular los LEDs.
  5. ```C++
  6. /* led.cpp */
  7. #include"led.h"
  8. #include<iostream>
  9. #include<fstream>
  10. #include<string>
  11. #include<sstream>
  12. #define LED_PATH "/sys/class/leds/beaglebone:green:usr"
  13. ```
  14. Se creó un archivo de libreria llamado led.h, donde se declara CLED como una clase
  15. y también se declaran los distinto métodos que puede utilizar.
  16. ```C++
  17. class CLED{
  18. private:
  19. std::string path;
  20. int ledNumber;
  21. virtual void WriteLED(std::string filename, std::string value);
  22. virtual void RemoveTrigger();
  23. public:
  24. CLED(int ledNumber); //class creator
  25. virtual void TurnOn();
  26. virtual void TurnOff();
  27. virtual void blink();
  28. virtual ~CLED(); //class deconstructor
  29. };
  30. ```
  31. El método para poder escribir a los LED es el siguiente:
  32. ```C
  33. void CLED::WriteLED(std::string filename, std::string value){
  34. std::ofstream fs;
  35. fs.open((path+filename).c_str());
  36. fs << value;
  37. fs.close();
  38. }
  39. ```
  40. El método para poder eliminar el trigger es el siguiente:
  41. ```C++
  42. void CLED::RemoveTrigger(){
  43. WriteLED("/trigger", "none");
  44. }
  45. ```
  46. Los métodos para encender, apagar y parpadear son los siguientes:
  47. ```C++
  48. void CLED::TurnOn(){
  49. std::cout << "LED" << ledNumber << "on" << std::endl;
  50. RemoveTrigger();
  51. WriteLED("/brightness", "1");
  52. }
  53. void CLED::TurnOff(){
  54. std::cout << "LED" << ledNumber << "off" << std::endl;
  55. RemoveTrigger();
  56. WriteLED("/brightness","0");
  57. }
  58. void CLED::blink(){
  59. std::cout << "LED" << ledNumber << "blinking" << std::endl;
  60. WriteLED("/trigger", "timer");
  61. WriteLED("/delay_on", "50");
  62. WriteLED("/delay_off", "50");
  63. }
  64. ```
  65. Se inicia el main, donde se indica cómo ejecutar la aplicación, también se manda
  66. un mensaje indicando que comienza la aplicación,
  67. asimismo, se hace una comparación de los argumentos de entrada para
  68. determinar si se enciende, se apaga o parpadea los LED.
  69. ```C++
  70. int main(int argc, char* argv[]){
  71. if(argc!=2){
  72. std::cout << "Para usarse es: makeLEDS <comand>" << std::endl;
  73. std::cout << "los comandos son on, off y blink" << std::endl;
  74. }
  75. std::cout << "Starting app" << std::endl;
  76. std::string cmd(argv[1]);
  77. // se crean 4 objetos de LED y se ponen en el array para controlar todos los LEDS.
  78. CLED leds[4]= {CLED(0), CLED(1), CLED(2), CLED(3) };
  79. ````
  80. Si se desea controlar un solo LED simplemente se remplaza la letra "i" por el número del LED que se quiere controlar.
  81. ```C++
  82. for(int i=0; i<=3; i++){
  83. if(cmd=="on")leds[i].TurnOn();
  84. else if(cmd=="off")leds[i].TurnOff();
  85. else if(cmd=="blink")leds[i].blink();
  86. else{std::cout << "comando invalido" << std::endl;}
  87. }
  88. std::cout << "programa terminado" << std::endl;
  89. return 0;
  90. }
  91. ```
  92. Se creó un archivo que se puede ejecutar para compilar, eliminar archivos antiguos de led
  93. y para hacer un debug, este archivo se llama mkefile.
  94. ```C++
  95. all:
  96. g++ main.cpp -o led led.cpp
  97. clean:
  98. rm led
  99. debug:
  100. g++ -g main.cpp -o led led.cpp
  101. ```
  102. También se puede compilar desde la terminal con el siguiente comando:
  103. ```sh
  104. sudo g++ led.cpp -o leds
  105. ```
  106. Finalmente para ejecutar el archivo en la Beagle Bone se utiliza el siguiente comando, en este ejemplo se le da el argumento para que los LED prenda y apague:
  107. ```sh
  108. sudo ./leds blink
  109. ```