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

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

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

[poll id=»7″]

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

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

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

Size: 5 kB

Version: 0.0.3

Скачать сейчас!526 Загрузки

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

Relay.h

```
#ifndef Relay_h
```
```
#define Relay_h
```
```
 
```
```
#include "Arduino.h"
```
```
#include "Timer.h"
```
```
class Relay {
```
```
public:
```
```
/*constructors*/
```
```
    Relay();
```

    Relay(uint8_t pin, uint8_t initCond);

```
/*methods*/
```

    uint8_t on(uint32_t time = 0);                      /*Устанавливает включает реле, если передается не обязательный параметр time то осуществляется включение реле на указанное время в мс*/

    uint8_t off(uint32_t time = 0);                     /*Устанавливает выключает реле, если передается не обязательный параметр time то осуществляется выключение реле на указанное время в мс*/

    void toggle();                                      /*Переключает реле в противоположное состояние*/

    void blink();                                       /*Осуществляет мигание реле по маске в 32 бита. Необходимо задать дополнительные параметры: _blinkPattern (маска), _blinkInterval (временной интервал каждого бита в мс)  */

    void buzzer();                                      /*Осуществляет звкуковое мигание реле по маске в 32 бита, при подключении пьезо-электрического источника звука (пищалки). Необходимо задать дополнительные параметры: _blinkPattern (маска), _blinkInterval (время вкл/выкл каждого бита в мс), _soundFrequency (частота колебаний в Гц)*/

    uint8_t getCond();                                  /*Возвращает состояние реле: 1 - включено, 0 - выключено*/

    void reset();                                       /*Устанавливает реле в исходное состояние, сбрасывая время задержек*/

    void setBlinkPattern(uint32_t blinkPattern);        /*Задает маску мигания _blinkPattern*/

    void setBlinkInterval(uint32_t blinkInterval);      /*Задает временной интервал _blinkInterval*/

    void setSoundFrequency(uint16_t soundFrequency);    /*Задает частоту колебаний _soundFrequency*/

    void setup();                                       /*Устанавливает реле в исходное состояние*/

    void setPin(uint8_t pin);                           /*Задает пин управления реле*/

    void setInitCond(uint8_t initCond);                 /*Задает исходное состояние реле*/

```
private:
```
```
    uint8_t _pin;
```
```
    uint8_t _initCond;
```
```
    /* [_initCond]
```
```
    0 // default relay is off
```
```
    1 // default relay is on
```
```
    */
```
```
 
```
```
/*for delay*/
```
```
    Timer timer;
```
```
    uint8_t time_delay(uint32_t time);
```
```
/*for blink*/
```
```
    uint32_t _mask = 0x00000001;
```
```
    uint32_t _blinkPattern;
```
```
    uint32_t _blinkInterval;
```
```
    uint32_t _blinkPatternBuff;
```
```
/*set relay*/
```
```
    void setHigh();
```
```
    void setLow();
```
```
/*for buzzer*/
```
```
    void sound();
```
```
    void mute();
```
```
    uint16_t _soundFrequency;
```
```
};
```
```
#endif
```

Relay.cpp

```
#include "Arduino.h"
```
```
#include "Relay.h"
```
```
Relay::Relay(){
```
```
};
```

Relay::Relay(uint8_t pin, uint8_t initCond){

```
    _pin=pin;
```
```
    _initCond=initCond;
```
```
    setup();
```
```
    _blinkInterval = 150;
```
```
    _blinkPattern = 0x0ABB9500;
```
```
    _blinkPatternBuff = 0x00000000;
```
```
    _soundFrequency = 1000;
```
```
};
```
```
uint8_t Relay::on(uint32_t time){
```
```
    setHigh();
```
```
    if (time){
```
```
        if (time_delay(time)){
```
```
            setLow();
```
```
            return 0; // relay is off
```
```
        }
```
```
    }
```
```
    return 1; // relay is on
```
```
};
```
```
uint8_t Relay::off(uint32_t time){
```
```
    setLow();
```
```
    if (time){
```
```
        if (time_delay(time)){
```
```
            setHigh();
```
```
            return 1; // relay is on
```
```
        }
```
```
    }
```
```
    return 0; // relay is off
```
```
};
```
```
void Relay::toggle(){
```

    if (this->getCond()) this->setLow();

```
    else this->setHigh();
```
```
};
```
```
void Relay::blink(){
```
```
    if (_blinkPatternBuff){
```
```
        if (_blinkPattern & _mask){
```

                if(!on(_blinkInterval)){

                _blinkPatternBuff = _blinkPatternBuff & (~_mask);

```
                _mask = _mask << 1;
```
```
                }
```
```
        }
```
```
        else {
```

                if(off(_blinkInterval)){

                _blinkPatternBuff = _blinkPatternBuff & (~_mask);

```
                _mask = _mask << 1;
```
```
                }
```
```
        }
```
```
    }
```
```
    else {
```

            _blinkPatternBuff = _blinkPattern;

```
            _mask = 0x00000001;
```
```
 
```
```
    }
```
```
};
```
```
void Relay::buzzer(){
```
```
     if (_blinkPatternBuff){
```
```
        if (_blinkPattern & _mask){
```
```
                sound();
```

                if (time_delay(_blinkInterval)){

                _blinkPatternBuff = _blinkPatternBuff & (~_mask);

```
                _mask = _mask << 1;
```
```
                }
```
```
        }
```
```
        else {
```
```
                mute();
```

                if (time_delay(_blinkInterval)){

                _blinkPatternBuff = _blinkPatternBuff & (~_mask);

```
                _mask = _mask << 1;
```
```
                }
```
```
        }
```
```
    }
```
```
    else {
```

            _blinkPatternBuff = _blinkPattern;

```
            _mask = 0x00000001;
```
```
 
```
```
    }
```
```
};
```

uint8_t Relay::time_delay(uint32_t time){

```
    if (timer.getTime() == 0 ) {
```
```
            timer.setTime(time);
```
```
            timer.reset();
```
```
    }
```
```
    timer.start();
```
```
    timer.delay();
```

    if (timer.getStatus() == 2){// задержка закончилась

```
        timer.setTime(0);
```
```
        timer.reset();
```
```
        return 1;
```
```
    }
```
```
    else {
```

            return 0; // задержка идет

```
    }
```
```
 
```
```
};
```
```
void Relay::setHigh(){
```
```
    digitalWrite(_pin, HIGH);
```
```
    };
```
```
void Relay::setLow(){
```
```
    digitalWrite(_pin, LOW);
```
```
};
```
```
uint8_t Relay::getCond(){
```
```
    return digitalRead(_pin);
```
```
};
```
```
void Relay::sound(){
```
```
    tone(_pin, _soundFrequency);
```
```
};
```
```
void Relay::mute(){
```
```
    noTone(_pin);
```
```
};
```
```
void Relay::setup(){
```
```
    pinMode(_pin, OUTPUT);
```
```
    if (_initCond>0) setHigh();
```
```
    else setLow();
```
```
}
```
```
void Relay::reset() {
```
```
        timer.setTime(0);
```
```
        timer.reset();
```
```
        mute();
```
```
        setup();
```
```
        };
```

void Relay::setBlinkPattern(uint32_t blinkPattern){

```
_blinkPattern = blinkPattern;
```
```
};
```

void Relay::setBlinkInterval(uint32_t blinkInterval){

```
_blinkInterval = blinkInterval;
```
```
};
```

void Relay::setSoundFrequency(uint16_t soundFrequency){

```
_soundFrequency = soundFrequency;
```
```
};
```
```
void Relay::setPin(uint8_t pin){
```
```
_pin = pin;
```
```
};
```

void Relay::setInitCond(uint8_t initCond){

```
_initCond=initCond;
```
```
};
```

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

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

```
#include <Relay.h>
```
```
Relay rele1(7, 0);
```
```
 
```
```
 
```
```
uint8_t flag1 = 0;
```
```
uint8_t flag2 = 0;
```
```
uint8_t flag3 = 0;
```
```
 
```
```
void setup() {
```
```
  Serial.begin(9600);
```
```
}
```
```
 
```
```
void loop() {
```
```
  if (flag1 == 1){
```
```
    if (!rele1.on(5000)) flag1=0;
```
```
    }
```
```
  if (flag2 == 1){
```
```
    if (rele1.off(5000)) flag2=0;
```
```
    }
```
```
  if (flag3 == 1) rele1.buzzer();
```
```
  test();
```
```
}
```
```
void test() {
```
```
  if (Serial.available()) {
```
```
    byte symbol = Serial.read();
```
```
    if (symbol == '0') {
```
```
      Serial.println(F("0 pressed"));
```
```
      rele1.on();
```
```
    }
```
```
    else  if (symbol == '1') {
```
```
      Serial.println(F("1 pressed"));
```
```
      rele1.off();
```
```
    }
```
```
    else  if (symbol == '2') {
```
```
      Serial.println(F("2 pressed"));
```
```
      flag1=1; // set ON time
```
```
    }
```
```
    else  if (symbol == '3') {
```
```
      Serial.println(F("3 pressed"));
```
```
      flag2=1; // set OFF time
```
```
    }
```
```
    else  if (symbol == '4') {
```
```
      Serial.println(F("4 pressed"));
```
```
      flag3 = 1; // start blink
```
```
    }
```
```
    else  if (symbol == '5') {
```
```
      Serial.println(F("5 pressed"));
```
```
      flag3 = 0; // stop blink
```
```
      rele1.reset();
```
```
    }
```
```
    else  if (symbol == '6') {
```
```
      Serial.println(F("6 pressed"));
```
```
     rele1.toggle();
```
```
    }
```
```
  }
```
```
}
```

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