Обновленная библиотека для управления реле в ARDUINO

Возможности библиотеки:

  • Включить реле
  • Включить реле на время
  • Выключить реле
  • Выключить реле на время
  • Переключить реле в противоположное состояние
  • Мигать по маске в 32 бита с заданным интервалом
  • Мигать звуком по маске в 32 бита с заданным интервалом и заданной частотой при подключении пьезо-электрического источника звука (пищалки)

Нужен ли видеокомментарий по пользованию библиотекой Relay?

Просмотреть результаты

Загрузка ... Загрузка ...

Библиотека для управления реле в ARDUINO

Описание библиотеки можно посмотреть здесь:Обновленная библиотека для управления реле в ARDUINO

Текущая версия: 0.0.3 / 2018.11.05
Предыдущие версии:
0.0.2 / 2018.03.02

Size: 5 kB
Version: 0.0.3


Файлы библиотеки:


Relay.h


  1. #ifndef Relay_h
  2. #define Relay_h
  3.  
  4. #include "Arduino.h"
  5. #include "Timer.h"
  6. class Relay {
  7. public:
  8. /*constructors*/
  9.     Relay();
  10.     Relay(uint8_t pin, uint8_t initCond);
  11. /*methods*/
  12.     uint8_t on(uint32_t time = 0);                      /*Устанавливает включает реле, если передается не обязательный параметр time то осуществляется включение реле на указанное время в мс*/
  13.     uint8_t off(uint32_t time = 0);                     /*Устанавливает выключает реле, если передается не обязательный параметр time то осуществляется выключение реле на указанное время в мс*/
  14.     void toggle();                                      /*Переключает реле в противоположное состояние*/
  15.     void blink();                                       /*Осуществляет мигание реле по маске в 32 бита. Необходимо задать дополнительные параметры: _blinkPattern (маска), _blinkInterval (временной интервал каждого бита в мс)  */
  16.     void buzzer();                                      /*Осуществляет звкуковое мигание реле по маске в 32 бита, при подключении пьезо-электрического источника звука (пищалки). Необходимо задать дополнительные параметры: _blinkPattern (маска), _blinkInterval (время вкл/выкл каждого бита в мс), _soundFrequency (частота колебаний в Гц)*/
  17.     uint8_t getCond();                                  /*Возвращает состояние реле: 1 - включено, 0 - выключено*/
  18.     void reset();                                       /*Устанавливает реле в исходное состояние, сбрасывая время задержек*/
  19.     void setBlinkPattern(uint32_t blinkPattern);        /*Задает маску мигания _blinkPattern*/
  20.     void setBlinkInterval(uint32_t blinkInterval);      /*Задает временной интервал _blinkInterval*/
  21.     void setSoundFrequency(uint16_t soundFrequency);    /*Задает частоту колебаний _soundFrequency*/
  22.     void setup();                                       /*Устанавливает реле в исходное состояние*/
  23.     void setPin(uint8_t pin);                           /*Задает пин управления реле*/
  24.     void setInitCond(uint8_t initCond);                 /*Задает исходное состояние реле*/
  25. private:
  26.     uint8_t _pin;
  27.     uint8_t _initCond;
  28.     /* [_initCond]
  29.     0 // default relay is off
  30.     1 // default relay is on
  31.     */
  32.  
  33. /*for delay*/
  34.     Timer timer;
  35.     uint8_t time_delay(uint32_t time);
  36. /*for blink*/
  37.     uint32_t _mask = 0x00000001;
  38.     uint32_t _blinkPattern;
  39.     uint32_t _blinkInterval;
  40.     uint32_t _blinkPatternBuff;
  41. /*set relay*/
  42.     void setHigh();
  43.     void setLow();
  44. /*for buzzer*/
  45.     void sound();
  46.     void mute();
  47.     uint16_t _soundFrequency;
  48. };
  49. #endif

Relay.cpp


  1. #include "Arduino.h"
  2. #include "Relay.h"
  3. Relay::Relay(){
  4. };
  5. Relay::Relay(uint8_t pin, uint8_t initCond){
  6.     _pin=pin;
  7.     _initCond=initCond;
  8.     setup();
  9.     _blinkInterval = 150;
  10.     _blinkPattern = 0x0ABB9500;
  11.     _blinkPatternBuff = 0x00000000;
  12.     _soundFrequency = 1000;
  13. };
  14. uint8_t Relay::on(uint32_t time){
  15.     setHigh();
  16.     if (time){
  17.         if (time_delay(time)){
  18.             setLow();
  19.             return 0; // relay is off
  20.         }
  21.     }
  22.     return 1; // relay is on
  23. };
  24. uint8_t Relay::off(uint32_t time){
  25.     setLow();
  26.     if (time){
  27.         if (time_delay(time)){
  28.             setHigh();
  29.             return 1; // relay is on
  30.         }
  31.     }
  32.     return 0; // relay is off
  33. };
  34. void Relay::toggle(){
  35.     if (this->getCond()) this->setLow();
  36.     else this->setHigh();
  37. };
  38. void Relay::blink(){
  39.     if (_blinkPatternBuff){
  40.         if (_blinkPattern & _mask){
  41.                 if(!on(_blinkInterval)){
  42.                 _blinkPatternBuff = _blinkPatternBuff & (~_mask);
  43.                 _mask = _mask << 1;
  44.                 }
  45.         }
  46.         else {
  47.                 if(off(_blinkInterval)){
  48.                 _blinkPatternBuff = _blinkPatternBuff & (~_mask);
  49.                 _mask = _mask << 1;
  50.                 }
  51.         }
  52.     }
  53.     else {
  54.             _blinkPatternBuff = _blinkPattern;
  55.             _mask = 0x00000001;
  56.  
  57.     }
  58. };
  59. void Relay::buzzer(){
  60.      if (_blinkPatternBuff){
  61.         if (_blinkPattern & _mask){
  62.                 sound();
  63.                 if (time_delay(_blinkInterval)){
  64.                 _blinkPatternBuff = _blinkPatternBuff & (~_mask);
  65.                 _mask = _mask << 1;
  66.                 }
  67.         }
  68.         else {
  69.                 mute();
  70.                 if (time_delay(_blinkInterval)){
  71.                 _blinkPatternBuff = _blinkPatternBuff & (~_mask);
  72.                 _mask = _mask << 1;
  73.                 }
  74.         }
  75.     }
  76.     else {
  77.             _blinkPatternBuff = _blinkPattern;
  78.             _mask = 0x00000001;
  79.  
  80.     }
  81. };
  82. uint8_t Relay::time_delay(uint32_t time){
  83.     if (timer.getTime() == 0 ) {
  84.             timer.setTime(time);
  85.             timer.reset();
  86.     }
  87.     timer.start();
  88.     timer.delay();
  89.     if (timer.getStatus() == 2){// задержка закончилась
  90.         timer.setTime(0);
  91.         timer.reset();
  92.         return 1;
  93.     }
  94.     else {
  95.             return 0; // задержка идет
  96.     }
  97.  
  98. };
  99. void Relay::setHigh(){
  100.     digitalWrite(_pin, HIGH);
  101.     };
  102. void Relay::setLow(){
  103.     digitalWrite(_pin, LOW);
  104. };
  105. uint8_t Relay::getCond(){
  106.     return digitalRead(_pin);
  107. };
  108. void Relay::sound(){
  109.     tone(_pin, _soundFrequency);
  110. };
  111. void Relay::mute(){
  112.     noTone(_pin);
  113. };
  114. void Relay::setup(){
  115.     pinMode(_pin, OUTPUT);
  116.     if (_initCond>0) setHigh();
  117.     else setLow();
  118. }
  119. void Relay::reset() {
  120.         timer.setTime(0);
  121.         timer.reset();
  122.         mute();
  123.         setup();
  124.         };
  125. void Relay::setBlinkPattern(uint32_t blinkPattern){
  126. _blinkPattern = blinkPattern;
  127. };
  128. void Relay::setBlinkInterval(uint32_t blinkInterval){
  129. _blinkInterval = blinkInterval;
  130. };
  131. void Relay::setSoundFrequency(uint16_t soundFrequency){
  132. _soundFrequency = soundFrequency;
  133. };
  134. void Relay::setPin(uint8_t pin){
  135. _pin = pin;
  136. };
  137. void Relay::setInitCond(uint8_t initCond){
  138. _initCond=initCond;
  139. };

Для работы библиотеки для управления реле в ARDUINO используется вспомогательная библиотека Timer для реализации задержек.


Скетч для проверки:


  1. #include <Relay.h>
  2. Relay rele1(7, 0);
  3.  
  4.  
  5. uint8_t flag1 = 0;
  6. uint8_t flag2 = 0;
  7. uint8_t flag3 = 0;
  8.  
  9. void setup() {
  10.   Serial.begin(9600);
  11. }
  12.  
  13. void loop() {
  14.   if (flag1 == 1){
  15.     if (!rele1.on(5000)) flag1=0;
  16.     }
  17.   if (flag2 == 1){
  18.     if (rele1.off(5000)) flag2=0;
  19.     }
  20.   if (flag3 == 1) rele1.buzzer();
  21.   test();
  22. }
  23. void test() {
  24.   if (Serial.available()) {
  25.     byte symbol = Serial.read();
  26.     if (symbol == '0') {
  27.       Serial.println(F("0 pressed"));
  28.       rele1.on();
  29.     }
  30.     else  if (symbol == '1') {
  31.       Serial.println(F("1 pressed"));
  32.       rele1.off();
  33.     }
  34.     else  if (symbol == '2') {
  35.       Serial.println(F("2 pressed"));
  36.       flag1=1; // set ON time
  37.     }
  38.     else  if (symbol == '3') {
  39.       Serial.println(F("3 pressed"));
  40.       flag2=1; // set OFF time
  41.     }
  42.     else  if (symbol == '4') {
  43.       Serial.println(F("4 pressed"));
  44.       flag3 = 1; // start blink
  45.     }
  46.     else  if (symbol == '5') {
  47.       Serial.println(F("5 pressed"));
  48.       flag3 = 0; // stop blink
  49.       rele1.reset();
  50.     }
  51.     else  if (symbol == '6') {
  52.       Serial.println(F("6 pressed"));
  53.      rele1.toggle();
  54.     }
  55.   }
  56. }

Оцените пожалуйста статью:

ПечальноТак себеНе плохоХорошоОтличная статья! (Пока оценок нет)
Загрузка...

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *