rpi/domo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

backport ubuscpp, chacond, and sprinklersd

Browse Source
This commit is contained in:
NADAL Jean-Baptiste
2017-04-21 22:48:42 +02:00
parent ad868bda8e
commit 3201fb4735
27 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
deprecated/src/chacond/builders/cmake/CMakeLists.txt
View File

@@ -1,30 +0,0 @@
cmake_minimum_required(VERSION 2.8.11)
project(chacond)
include (libubus)
include (libubox)
include (wiringPi)
include_directories(../../src)
file(
GLOB_RECURSE
source_files
../../src/main.c
../../src/UBusModel.c
../../src/Chacon.c
)
add_executable (
chacond
${source_files}
)
target_link_libraries (chacond
LINK_PUBLIC
ubus
wiringPi
rt
pthread
)

BIN
deprecated/src/chacond/libwiringPi.a
View File

Binary file not shown.

BIN
deprecated/src/chacond/radioEmission
View File

Binary file not shown.

231
deprecated/src/chacond/radioEmission.cpp
View File

@@ -1,231 +0,0 @@
#include <wiringPi.h>
#include <iostream>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>
#include <sched.h>
#include <sstream>
#include <unistd.h>
/*
Par Idleman (idleman@idleman.fr - http://blog.idleman.fr)
Licence : CC by sa
Toutes question sur le blog ou par mail, possibilité de m'envoyer des bières via le blog
*/
using namespace std;
int pin;
bool bit2[26]={}; // 26 bit Identifiant emetteur
bool bit2Interruptor[4]={};
int interruptor;
int sender;
string onoff;
void log(string a){
//Décommenter pour avoir les logs
cout << a << endl;
}
void scheduler_realtime() {
struct sched_param p;
p.__sched_priority = sched_get_priority_max(SCHED_RR);
if( sched_setscheduler( 0, SCHED_RR, &p ) == -1 ) {
perror("Failed to switch to realtime scheduler.");
}
}
void scheduler_standard() {
struct sched_param p;
p.__sched_priority = 0;
if( sched_setscheduler( 0, SCHED_OTHER, &p ) == -1 ) {
perror("Failed to switch to normal scheduler.");
}
}
//Envois d'une pulsation (passage de l'etat haut a l'etat bas)
//1 = 310µs haut puis 1340µs bas
//0 = 310µs haut puis 310µs bas
void sendBit(bool b) {
if (b) {
digitalWrite(pin, HIGH);
delayMicroseconds(310); //275 orinally, but tweaked.
digitalWrite(pin, LOW);
delayMicroseconds(1340); //1225 orinally, but tweaked.
}
else {
digitalWrite(pin, HIGH);
delayMicroseconds(310); //275 orinally, but tweaked.
digitalWrite(pin, LOW);
delayMicroseconds(310); //275 orinally, but tweaked.
}
}
//Calcul le nombre 2^chiffre indiqué, fonction utilisé par itob pour la conversion decimal/binaire
unsigned long power2(int power){
unsigned long integer=1;
for (int i=0; i<power; i++){
integer*=2;
}
return integer;
}
//Convertis un nombre en binaire, nécessite le nombre, et le nombre de bits souhaité en sortie (ici 26)
// Stocke le résultat dans le tableau global "bit2"
void itob(unsigned long integer, int length)
{
for (int i=0; i<length; i++){
if ((integer / power2(length-1-i))==1){
integer-=power2(length-1-i);
bit2[i]=1;
}
else bit2[i]=0;
}
}
void itobInterruptor(unsigned long integer, int length)
{
for (int i=0; i<length; i++){
if ((integer / power2(length-1-i))==1){
integer-=power2(length-1-i);
bit2Interruptor[i]=1;
}
else bit2Interruptor[i]=0;
}
}
//Envoie d'une paire de pulsation radio qui definissent 1 bit réel : 0 =01 et 1 =10
//c'est le codage de manchester qui necessite ce petit bouzin, ceci permet entre autres de dissocier les données des parasites
void sendPair(bool b) {
if(b)
{
sendBit(true);
sendBit(false);
}
else
{
sendBit(false);
sendBit(true);
}
}
//Fonction d'envois du signal
//recoit en parametre un booleen définissant l'arret ou la marche du matos (true = on, false = off)
void transmit(int blnOn)
{
int i;
// Sequence de verrou anoncant le départ du signal au recepeteur
digitalWrite(pin, HIGH);
delayMicroseconds(275); // un bit de bruit avant de commencer pour remettre les delais du recepteur a 0
digitalWrite(pin, LOW);
delayMicroseconds(9900); // premier verrou de 9900µs
digitalWrite(pin, HIGH); // high again
delayMicroseconds(275); // attente de 275µs entre les deux verrous
digitalWrite(pin, LOW); // second verrou de 2675µs
delayMicroseconds(2675);
digitalWrite(pin, HIGH); // On reviens en état haut pour bien couper les verrous des données
// Envoie du code emetteur (272946 = 1000010101000110010 en binaire)
for(i=0; i<26;i++)
{
sendPair(bit2[i]);
}
// Envoie du bit définissant si c'est une commande de groupe ou non (26em bit)
sendPair(false);
// Envoie du bit définissant si c'est allumé ou eteint 27em bit)
sendPair(blnOn);
// Envoie des 4 derniers bits, qui représentent le code interrupteur, ici 0 (encode sur 4 bit donc 0000)
// nb: sur les télécommandes officielle chacon, les interrupteurs sont logiquement nommés de 0 à x
// interrupteur 1 = 0 (donc 0000) , interrupteur 2 = 1 (1000) , interrupteur 3 = 2 (0100) etc...
for(i=0; i<4;i++)
{
if(bit2Interruptor[i]==0){
sendPair(false);
}else{
sendPair(true);
}
}
digitalWrite(pin, HIGH); // coupure données, verrou
delayMicroseconds(275); // attendre 275µs
digitalWrite(pin, LOW); // verrou 2 de 2675µs pour signaler la fermeture du signal
}
int main (int argc, char** argv)
{
if (setuid(0))
{
perror("setuid");
return 1;
}
scheduler_realtime();
log("Demarrage du programme");
pin = atoi(argv[1]);
sender = atoi(argv[2]);
interruptor = atoi(argv[3]);
onoff = argv[4];
//Si on ne trouve pas la librairie wiringPI, on arrête l'execution
if(wiringPiSetup() == -1)
{
log("Librairie Wiring PI introuvable, veuillez lier cette librairie...");
return -1;
}
pinMode(pin, OUTPUT);
log("Pin GPIO configure en sortie");
itob(sender,26); // convertion du code de l'emetteur (ici 8217034) en code binaire
itobInterruptor(interruptor,4);
if(onoff=="on"){
system("/etc/lcd/screen -p \"Radio signal ON...\"");
log("envois du signal ON");
for(int i=0;i<5;i++){
transmit(true); // envoyer ON
delay(10); // attendre 10 ms (sinon le socket nous ignore)
}
}else{
system("/etc/lcd/screen -p \"Radio signal OFF...\"");
log("envois du signal OFF");
for(int i=0;i<5;i++){
transmit(false); // envoyer OFF
delay(10); // attendre 10 ms (sinon le socket nous ignore)
}
}
log("fin du programme"); // execution terminée.
scheduler_standard();
}

187
deprecated/src/chacond/radioReception.cpp
View File

@@ -1,187 +0,0 @@
/*
* Code pour reception d'un signal de sonde de temperature "maison", récupère une temperature et l'envois sur un fichier php passé en paramêtre
* Fréquence : 433.92 mhz
* Protocole : Ridle (Radio Idle, protocole customisé basé sur home easy)
* Licence : CC -by -sa
* Matériel associé : récepteur RF AM 433.92 mhz
* Auteur : Valentin CARRUESCO aka idleman (idleman@idleman.fr - http://blog.idleman.fr)
*/
#include <wiringPi.h>
#include <iostream>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>
#include <sched.h>
#include <sstream>
using namespace std;
int pin = 7;
void log(string a){
//Décommenter pour avoir les logs
cout << a << endl;
}
void scheduler_realtime() {
struct sched_param p;
p.__sched_priority = sched_get_priority_max(SCHED_RR);
if( sched_setscheduler( 0, SCHED_RR, &p ) == -1 ) {
perror("Failed to switch to realtime scheduler.");
}
}
void scheduler_standard() {
struct sched_param p;
p.__sched_priority = 0;
if( sched_setscheduler( 0, SCHED_OTHER, &p ) == -1 ) {
perror("Failed to switch to normal scheduler.");
}
}
string longToString(long mylong){
string mystring;
stringstream mystream;
mystream << mylong;
return mystream.str();
}
int pulseIn(int pin, int level, int timeout)
{
struct timeval tn, t0, t1;
long micros;
gettimeofday(&t0, NULL);
micros = 0;
while (digitalRead(pin) != level)
{
gettimeofday(&tn, NULL);
if (tn.tv_sec > t0.tv_sec) micros = 1000000L; else micros = 0;
micros += (tn.tv_usec - t0.tv_usec);
if (micros > timeout) return 0;
}
gettimeofday(&t1, NULL);
while (digitalRead(pin) == level)
{
gettimeofday(&tn, NULL);
if (tn.tv_sec > t0.tv_sec) micros = 1000000L; else micros = 0;
micros = micros + (tn.tv_usec - t0.tv_usec);
if (micros > timeout) return 0;
}
if (tn.tv_sec > t1.tv_sec) micros = 1000000L; else micros = 0;
micros = micros + (tn.tv_usec - t1.tv_usec);
return micros;
}
int main (int argc, char** argv)
{
//scheduler_realtime();
string command;
string path = "php ";
path.append(argv[1]);
log("Demarrage du programme");
pin = atoi(argv[2]);
if(wiringPiSetup() == -1)
{
log("Librairie Wiring PI introuvable, veuillez lier cette librairie...");
return -1;
}
pinMode(pin, INPUT);
log("Pin GPIO configure en entree");
log("Attente d'un signal du transmetteur ...");
for(;;)
{
int i = 0;
unsigned long t = 0;
int prevBit = 0;
int bit = 0;
unsigned long temperature = 0;
unsigned long emiter = 0;
unsigned long positive = 0;
bool group=false;
bool on =false;
unsigned long recipient = 0;
command = path+" ";
t = pulseIn(pin, LOW, 1000000);
while((t < 2550 || t > 2900)){
t = pulseIn(pin, LOW,1000000);
}
while(i < 24)
{
t = pulseIn(pin, LOW, 1000000);
if(t > 500 && t < 1500)
{
bit = 0;
}
else if(t > 2000 && t < 3000)
{
bit = 1;
}
else
{
i = 0;
cout << "FAIL? = " << t << endl;
break;
}
if(i % 2 == 1)
{
if((prevBit ^ bit) == 0)
{
i = 0;
break;
}
if(i < 15)
{
temperature <<= 1;
temperature |= prevBit;
}else if(i == 15){
positive = prevBit;
}else{
emiter <<= 1;
emiter |= prevBit;
}
}
prevBit = bit;
++i;
}
if(i>0){
log("------------------------------");
log("Donnees detectees");
cout << "temperature = " << temperature << " C" << endl;
cout << "positif = " << positive << endl;
cout << "code sonde = " << emiter << endl;
command.append("UPDATE_ENGINE_STATE ");
command.append(" "+longToString(emiter));
command.append(" "+longToString(temperature));
command.append(" "+longToString(positive));
log("Execution de la commande PHP...");
log(command.c_str());
system(command.c_str());
}else{
log("Aucune donnee...");
}
delay(3000);
}
//scheduler_standard();
}

309
deprecated/src/chacond/src/Chacon.c
View File

@@ -1,309 +0,0 @@
/*!
* chacon.c
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 20/03/2015
*
*/
/*-------------------------------- INCLUDES ---------------------------------*/
#include <stdio.h>
#include <sched.h>
#include <wiringPi.h>
#include "chacon.h"
/*-------------------------------- GLOBALES ---------------------------------*/
static int gGpioPin = 0;
bool gBit2[26]={}; // 26 bit Identifiant emetteur
bool gBit2Interruptor[4]={};
void sendBit (bool aBit);
unsigned long power2 (int aPower);
void itob (unsigned long anInteger, int aLength);
void itobInterruptor (unsigned long anInteger, int aLength);
void sendPair (bool aBit);
void transmit (bool aState);
/*! ----------------------------------------------------------------------------
* @fn SetupChacon
*
* @brief this method setup the Chacon environment.
*/
int SetupChacon (int aGpioPin)
{
gGpioPin = aGpioPin;
if (wiringPiSetup() == -1) {
fprintf (stderr, "Impossible to setup the WiringPI...");
return -1;
}
pinMode (gGpioPin, OUTPUT);
return 0;
}
/*! ----------------------------------------------------------------------------
* @fn Chacon_SetInterruptorState
*
* @brief This function Change the State of the Interruptor.
*/
int Chacon_SetInterruptorState (uint32_t aSender, uint32_t anInterruptor, bool aState)
{
int i;
fprintf (stdout, "Chacon_SetInterruptorState - aSender:%d, anInterruptor:%d, aState:%d\n",
aSender, anInterruptor, aState);
/* convert sender and interruptor ID */
itob (aSender, 26); // convertion du code de l'emetteur (ici 8217034) en code binaire
itobInterruptor (anInterruptor, 4);
/* Send the State Five Time. */
for (i = 0; i < 10; i++) {
transmit (aState);
delay (10); // attendre 10 ms (sinon le socket nous ignore)
}
return 0;
}
/*-------------------------------- LOCALES ---------------------------------*/
/*! ----------------------------------------------------------------------------
* @fn scheduler_realtime
*
* @brief Switch the process to the RealTime Scheduler
*/
void scheduler_realtime (void)
{
struct sched_param theSchedParam;
theSchedParam.__sched_priority = sched_get_priority_max (SCHED_RR);
if( sched_setscheduler (0, SCHED_RR, &theSchedParam) == -1 ) {
perror ("Failed to switch to realtime scheduler.");
}
}
/*! ----------------------------------------------------------------------------
* @fn scheduler_standard
*
* @brief Switch the process to the regular Scheduler
*/
void scheduler_standard (void)
{
struct sched_param theSchedParam;
theSchedParam.__sched_priority = 0;
if( sched_setscheduler (0, SCHED_OTHER, &theSchedParam) == -1 ) {
perror ("Failed to switch to normal scheduler.");
}
}
/*! ----------------------------------------------------------------------------
* @fn sendBit
*
* @brief Envois d'une pulsation (passage de l'etat haut a l'etat bas)
* 1 = 310µs haut puis 1340µs bas
* 0 = 310µs haut puis 310µs bas
*/
void sendBit (bool aBit)
{
if (aBit) {
digitalWrite (gGpioPin, HIGH);
delayMicroseconds (310); //275 orinally, but tweaked.
digitalWrite (gGpioPin, LOW);
delayMicroseconds (1340); //1225 orinally, but tweaked.
}
else {
digitalWrite (gGpioPin, HIGH);
delayMicroseconds (310); //275 orinally, but tweaked.
digitalWrite (gGpioPin, LOW);
delayMicroseconds (310); //275 orinally, but tweaked.
}
}
/*! ----------------------------------------------------------------------------
* @fn power2
*
* @brief Calcul le nombre 2^chiffre indiqué, fonction utilisé par itob pour
* la conversion decimal/binaire
*/
unsigned long power2 (int aPower)
{
int i;
unsigned long theInteger = 1;
for (i = 0; i < aPower; i++) {
theInteger *= 2;
}
return theInteger;
}
/*! ----------------------------------------------------------------------------
* @fn itob
*
* @brief Convertis un nombre en binaire, nécessite le nombre, et le nombre de
* bits souhaité en sortie (ici 26)
* Stocke le résultat dans le tableau global "bit2"
*/
void itob (unsigned long anInteger, int aLength)
{
int i;
for (i = 0; i < aLength; i++) {
if ((anInteger / power2 (aLength - 1 - i)) == 1) {
anInteger -= power2 (aLength - 1 - i);
gBit2[i] = 1;
}
else {
gBit2[i]=0;
}
}
}
/*! ----------------------------------------------------------------------------
* @fn itobInterruptor
*
* @brief TODO
*/
void itobInterruptor (unsigned long anInteger, int aLength)
{
int i;
for (i = 0; i < aLength; i++) {
if ((anInteger / power2 (aLength - 1 - i)) == 1) {
anInteger -= power2 (aLength - 1 - i);
gBit2Interruptor[i] = 1;
}
else {
gBit2Interruptor[i] = 0;
}
}
}
/*! ----------------------------------------------------------------------------
* @fn sendPair
*
* @brief Envoie d'une paire de pulsation radio qui definissent 1 bit réel :
* 0 =01 et 1 =10
* c'est le codage de manchester qui necessite ce petit bouzin, ceci permet
* entre autres de dissocier les données des parasites
*/
void sendPair (bool aBit)
{
if (aBit) {
sendBit (true);
sendBit (false);
}
else {
sendBit (false);
sendBit (true);
}
}
/*! ----------------------------------------------------------------------------
* @fn transmit
*
* @brief Fonction d'envois du signal
* recoit en parametre un booleen définissant l'arret ou la marche du matos
* (true = on, false = off)
*/
void transmit (bool aState)
{
int i;
// Sequence de verrou anoncant le départ du signal au recepeteur
digitalWrite (gGpioPin, HIGH);
delayMicroseconds (275); // un bit de bruit avant de commencer pour remettre les delais du recepteur a 0
digitalWrite (gGpioPin, LOW);
delayMicroseconds (9900); // premier verrou de 9900µs
digitalWrite (gGpioPin, HIGH); // high again
delayMicroseconds (275); // attente de 275µs entre les deux verrous
digitalWrite (gGpioPin, LOW); // second verrou de 2675µs
delayMicroseconds (2675);
digitalWrite (gGpioPin, HIGH); // On reviens en état haut pour bien couper les verrous des données
// Envoie du code emetteur (272946 = 1000010101000110010 en binaire)
for (i = 0; i < 26; i++) {
sendPair (gBit2[i]);
}
// Envoie du bit définissant si c'est une commande de groupe ou non (26em bit)
sendPair (false);
// Envoie du bit définissant si c'est allumé ou eteint 27em bit)
sendPair (aState);
// Envoie des 4 derniers bits, qui représentent le code interrupteur, ici 0 (encode sur 4 bit donc 0000)
// nb: sur les télécommandes officielle chacon, les interrupteurs sont logiquement nommés de 0 à x
// interrupteur 1 = 0 (donc 0000) , interrupteur 2 = 1 (1000) , interrupteur 3 = 2 (0100) etc...
for (i = 0; i < 4; i++) {
if (gBit2Interruptor[i] == 0) {
sendPair (false);
} else {
sendPair (true);
}
}
digitalWrite (gGpioPin, HIGH); // coupure données, verrou
delayMicroseconds(275); // attendre 275µs
digitalWrite (gGpioPin, LOW); // verrou 2 de 2675µs pour signaler la fermeture du signal
}

167
deprecated/src/chacond/src/UBusModel.c
View File

@@ -1,167 +0,0 @@
/*!
* UBusModel.c
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 26/02/2015
*
*/
/*-------------------------------- INCLUDES ---------------------------------*/
#include <unistd.h>
#include <signal.h>
#include <libubox/blobmsg_json.h>
#include <libubus.h>
/*------------------------------- DECLARATION -------------------------------*/
static int gChacon_set (struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg);
/*--------------------------------- GLOBALS ---------------------------------*/
static struct ubus_context *gCtx;
static struct blob_buf gBuffer;
enum {
SET_SENDER,
SET_INTERRUPTOR,
SET_STATE,
__CHACON_MAX
};
static const struct blobmsg_policy set_chacon_policy[] = {
[SET_SENDER] = { .name = "sender", .type = BLOBMSG_TYPE_INT32 },
[SET_INTERRUPTOR] = { .name = "interruptor", .type = BLOBMSG_TYPE_INT32 },
[SET_STATE] = { .name = "state", .type = BLOBMSG_TYPE_BOOL },
};
static const struct ubus_method gChacon_methods[] = {
UBUS_METHOD("set", gChacon_set, set_chacon_policy),
};
static struct ubus_object_type gChacon_object_type =
UBUS_OBJECT_TYPE ("chacon", gChacon_methods);
static struct ubus_object gChacon_object = {
.name = "chacon",
.type = &gChacon_object_type,
.methods = gChacon_methods,
.n_methods = ARRAY_SIZE (gChacon_methods),
};
/*! ----------------------------------------------------------------------------
* @fn gChacon_set
*
* @brief Method to send a chacon DIO command to a specific device.
*/
static int gChacon_set (struct ubus_context *aCtx, struct ubus_object *anObj,
struct ubus_request_data *aReq, const char *aMethod,
struct blob_attr *aMsg)
{
struct blob_attr *theParams[__CHACON_MAX];
uint32_t theSender;
uint32_t theInterruptor;
bool theState;
/* Parse the Message */
blobmsg_parse (set_chacon_policy, __CHACON_MAX, theParams, blob_data (aMsg), blob_len(aMsg));
/* Sanity Checks. */
if (!theParams[SET_SENDER] || !theParams[SET_INTERRUPTOR]|| !theParams[SET_STATE]) {
printf ("Chacon Set Invalid arguments.\n");
return UBUS_STATUS_INVALID_ARGUMENT;
}
/* Get Parameters. */
theSender = blobmsg_get_u32 (theParams[SET_SENDER]);
theInterruptor = blobmsg_get_u32 (theParams[SET_INTERRUPTOR]);
theState = blobmsg_get_bool (theParams[SET_STATE]);
return Chacon_SetInterruptorState (theSender, theInterruptor, theState);
}
/*! ----------------------------------------------------------------------------
* @fn SetupUbus
*
* @brief Setup the UBus Mechanism.
*/
int SetupUbus (void)
{
uloop_init ();
signal (SIGPIPE, SIG_IGN);
gCtx = ubus_connect (NULL);
if (!gCtx) {
fprintf (stderr, "Failed to connect to ubus\n");
return -1;
}
ubus_add_uloop (gCtx);
return 0;
}
/*! ----------------------------------------------------------------------------
* @fn UBusMain
*
* @brief Main function of the UBus Loop.
*/
int UBusMain (void)
{
int theRet;
theRet = ubus_add_object (gCtx, &gChacon_object);
if (theRet) {
fprintf (stderr, "Failed to add object: %s\n", ubus_strerror (theRet));
}
uloop_run ();
return 0;
}
/*! ----------------------------------------------------------------------------
* @fn TerminateUBus
*
* @brief This function terminate the Ubus mechanisme.
*/
int TerminateUBus (void)
{
ubus_free (gCtx);
uloop_done ();
return 0;
}

35
deprecated/src/chacond/src/UbusModel.h
View File

@@ -1,35 +0,0 @@
/*!
* UBusModel.h
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 26/02/2015
*
*/
#ifndef __UBUSMODEL_H
#define __UBUSMODEL_H
int SetupUbus (void);
int TerminateUBus (void);
int UBusMain (void);
#endif /* __UBUSMODEL_H */

43
deprecated/src/chacond/src/chacon.h
View File

@@ -1,43 +0,0 @@
/*!
* chacon.h
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 20/03/2015
*
*/
#ifndef __CHACON_H
#define __CHACON_H
/*-------------------------------- INCLUDES ---------------------------------*/
#include <stdint.h>
#include <stdbool.h>
/*-------------------------------- METHODS ---------------------------------*/
int SetupChacon (int aGpioPin);
int Chacon_SetInterruptorState (uint32_t aSender, uint32_t anInterruptor, bool aState);
void scheduler_realtime (void);
void scheduler_standard (void);
#endif /* __CHACON_H */

83
deprecated/src/chacond/src/main.c
View File

@@ -1,83 +0,0 @@
/*!
* main.c
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 09/12/2014
*
*/
/*-------------------------------- INCLUDES ---------------------------------*/
#include <stdio.h>
#include <unistd.h>
#include "UbusModel.h"
#include "chacon.h"
/*! ----------------------------------------------------------------------------
* @fn main
*
* @brief Main function of Chacon Daemon.
*/
int main (int argc, char **argv)
{
int thePin;
int theRet = 0;
if (argc != 2) {
fprintf (stderr, "You should specify a WiringPI Pin ID\n");
return -1;
}
thePin = atoi (argv[1]);
if (setuid (0)) {
perror ("setuid");
return 1;
}
scheduler_realtime();
/* Setup UBus. */
theRet = SetupUbus ();
if (theRet != 0) {
fprintf (stderr, "Impossible to Setup the UBUS Environment.\n");
return theRet;
}
/* Setup Chacon. */
theRet = SetupChacon (thePin);
if (theRet != 0) {
fprintf (stderr, "Impossible to Setup the Chacon Environment.\n");
return theRet;
}
/* Main loop */
UBusMain ();
scheduler_standard();
return TerminateUBus();
}

187
deprecated/src/chacond/wiringPi.h
View File

@@ -1,187 +0,0 @@
/*
* wiringPi:
* Arduino compatable (ish) Wiring library for the Raspberry Pi
* Copyright (c) 2012 Gordon Henderson
***********************************************************************
* This file is part of wiringPi:
* https://projects.drogon.net/raspberry-pi/wiringpi/
*
* wiringPi is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* wiringPi is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with wiringPi. If not, see <http://www.gnu.org/licenses/>.
***********************************************************************
*/
#ifndef __WIRING_PI_H__
#define __WIRING_PI_H__
// Handy defines
// Deprecated
#define NUM_PINS 17
#define WPI_MODE_PINS 0
#define WPI_MODE_GPIO 1
#define WPI_MODE_GPIO_SYS 2
#define WPI_MODE_PHYS 3
#define WPI_MODE_PIFACE 4
#define WPI_MODE_UNINITIALISED -1
// Pin modes
#define INPUT 0
#define OUTPUT 1
#define PWM_OUTPUT 2
#define GPIO_CLOCK 3
#define LOW 0
#define HIGH 1
// Pull up/down/none
#define PUD_OFF 0
#define PUD_DOWN 1
#define PUD_UP 2
// PWM
#define PWM_MODE_MS 0
#define PWM_MODE_BAL 1
// Interrupt levels
#define INT_EDGE_SETUP 0
#define INT_EDGE_FALLING 1
#define INT_EDGE_RISING 2
#define INT_EDGE_BOTH 3
// Threads
#define PI_THREAD(X) void *X (void *dummy)
// Failure modes
#define WPI_FATAL (1==1)
#define WPI_ALMOST (1==2)
// wiringPiNodeStruct:
// This describes additional device nodes in the extended wiringPi
// 2.0 scheme of things.
// It's a simple linked list for now, but will hopefully migrate to
// a binary tree for efficiency reasons - but then again, the chances
// of more than 1 or 2 devices being added are fairly slim, so who
// knows....
struct wiringPiNodeStruct
{
int pinBase ;
int pinMax ;
int fd ; // Node specific
unsigned int data0 ; // ditto
unsigned int data1 ; // ditto
unsigned int data2 ; // ditto
unsigned int data3 ; // ditto
void (*pinMode) (struct wiringPiNodeStruct *node, int pin, int mode) ;
void (*pullUpDnControl) (struct wiringPiNodeStruct *node, int pin, int mode) ;
int (*digitalRead) (struct wiringPiNodeStruct *node, int pin) ;
void (*digitalWrite) (struct wiringPiNodeStruct *node, int pin, int value) ;
void (*pwmWrite) (struct wiringPiNodeStruct *node, int pin, int value) ;
int (*analogRead) (struct wiringPiNodeStruct *node, int pin) ;
void (*analogWrite) (struct wiringPiNodeStruct *node, int pin, int value) ;
struct wiringPiNodeStruct *next ;
} ;
extern struct wiringPiNodeStruct *wiringPiNodes ;
// Function prototypes
// c++ wrappers thanks to a comment by Nick Lott
// (and others on the Raspberry Pi forums)
#ifdef __cplusplus
extern "C" {
#endif
// Internal
extern int wiringPiFailure (int fatal, const char *message, ...) ;
// Core wiringPi functions
extern struct wiringPiNodeStruct *wiringPiFindNode (int pin) ;
extern struct wiringPiNodeStruct *wiringPiNewNode (int pinBase, int numPins) ;
extern int wiringPiSetup (void) ;
extern int wiringPiSetupSys (void) ;
extern int wiringPiSetupGpio (void) ;
extern int wiringPiSetupPhys (void) ;
extern void pinModeAlt (int pin, int mode) ;
extern void pinMode (int pin, int mode) ;
extern void pullUpDnControl (int pin, int pud) ;
extern int digitalRead (int pin) ;
extern void digitalWrite (int pin, int value) ;
extern void pwmWrite (int pin, int value) ;
extern int analogRead (int pin) ;
extern void analogWrite (int pin, int value) ;
// PiFace specifics
// (Deprecated)
extern int wiringPiSetupPiFace (void) ;
extern int wiringPiSetupPiFaceForGpioProg (void) ; // Don't use this - for gpio program only
// On-Board Raspberry Pi hardware specific stuff
extern int piBoardRev (void) ;
extern int wpiPinToGpio (int wpiPin) ;
extern int physPinToGpio (int physPin) ;
extern void setPadDrive (int group, int value) ;
extern int getAlt (int pin) ;
extern void digitalWriteByte (int value) ;
extern void pwmSetMode (int mode) ;
extern void pwmSetRange (unsigned int range) ;
extern void pwmSetClock (int divisor) ;
extern void gpioClockSet (int pin, int freq) ;
// Interrupts
// (Also Pi hardware specific)
extern int waitForInterrupt (int pin, int mS) ;
extern int wiringPiISR (int pin, int mode, void (*function)(void)) ;
// Threads
extern int piThreadCreate (void *(*fn)(void *)) ;
extern void piLock (int key) ;
extern void piUnlock (int key) ;
// Schedulling priority
extern int piHiPri (const int pri) ;
// Extras from arduino land
extern void delay (unsigned int howLong) ;
extern void delayMicroseconds (unsigned int howLong) ;
extern unsigned int millis (void) ;
extern unsigned int micros (void) ;
#ifdef __cplusplus
}
#endif
#endif

20
deprecated/src/sprinklersd/Readme.md
View File

@@ -1,20 +0,0 @@
exemple de commande du opensprinker PI
https://github.com/rayshobby/opensprinkler
Bonne appli on peut s'en inspirer
https://opensprinkler.com/forums/topic/sprinklers_pi-an-alternative-sprinkler-control-program/
https://github.com/rszimm/sprinklers_pi/
## Command used to activate or not a Sprinkler.
>
>./bin/ucli call sprinkers set "{ \"station\": 7,\"state\": true}"
>
>./bin/ucli call sprinkers set "{ \"station\": 7,\"state\": false}"
>

32
deprecated/src/sprinklersd/builders/cmake/CMakeLists.txt
View File

@@ -1,32 +0,0 @@
cmake_minimum_required(VERSION 2.8.11)
project(sprinklersd)
include (libubus)
include (libubox)
include (libubuscpp)
include (libjsoncpp)
include_directories(../../src)
set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wextra -pedantic -Werror=strict-aliasing")
file(
GLOB_RECURSE
source_files
../../src/main.cpp
../../src/UbusSprinklerModel.cpp
../../src/sprinklers.cpp
)
add_executable (
sprinklersd
${source_files}
)
target_link_libraries (sprinklersd
LINK_PUBLIC
jsoncpp
ubuscpp
rt
)

172
deprecated/src/sprinklersd/src/UbusSprinklerModel.cpp
View File

@@ -1,172 +0,0 @@
/*!
* UBusSprinkerModel.cpp
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 30/04/2015
*
*/
/*-------------------------------- INCLUDES ---------------------------------*/
#include <fstream>
#include <string>
#include <sstream>
#include <jsoncpp/json.h>
extern "C" {
#include <libubox/blobmsg_json.h>
}
#include "sprinklers.h"
#include "UbusSprinklerModel.h"
namespace {
using namespace UBus;
static ObjectType gSprinklerModelUbus_types(
"sprinklers",
Method("get", UBUS_CPP(SprinkerModel, Get)),
Method("set", UBUS_CPP(SprinkerModel, Set))
);
}
/*! ----------------------------------------------------------------------------
* @fn SprinkerModel
*
* @brief Constructor of the UBus Mixer Volume.
*/
SprinkerModel::SprinkerModel (void) :
UBusObject (gSprinklerModelUbus_types, "sprinklers")
{
}
/*! ----------------------------------------------------------------------------
* @fn ~SprinkerModel
*
* @brief Destructor of the UBus Mixer Volume.
*/
SprinkerModel::~SprinkerModel (void)
{
}
/*! ----------------------------------------------------------------------------
* @fn Get
*
* @brief Get the State of a Sprinkler Station.
*/
int SprinkerModel::Get (struct ubus_context *aCtx, struct ubus_request_data *aReq,
struct blob_attr *aMsg)
{
int theResult = 0;
struct blob_buf theBuf = {0};
char *theString = blobmsg_format_json (aMsg, true);
Json::Reader theReader;
Json::StyledWriter theWriter;
Json::Value theRoot;
Json::Value theOutput;
uint32_t theStation = 0;
bool theState = false;
if (!theReader.parse (theString, theRoot)) {
fprintf (stderr, "Failed parse the parameters.\n");
return UBUS_STATUS_INVALID_ARGUMENT;
}
theStation = theRoot["station"].asInt();
if (theStation == 0) {
fprintf (stderr, "Station ID is missing.\n");
return UBUS_STATUS_INVALID_ARGUMENT;
}
theResult = sprinklers_get_station (theStation, theState);
if (theResult != 0) {
fprintf (stderr, "Wrong Station ID (%d).\n", theStation);
return UBUS_STATUS_INVALID_ARGUMENT;
}
printf ("aState: %d\n", theState);
theOutput ["station"] = theStation;
theOutput ["state"] = theState;
blob_buf_init (&theBuf, 0);
blobmsg_add_json_from_string (&theBuf, theWriter.write (theOutput).c_str());
theResult = ubus_send_reply (aCtx, aReq, theBuf.head);
blob_buf_free (&theBuf);
return theResult;
}
/*! ----------------------------------------------------------------------------
* @fn Set
*
* @brief Set a new State for a Sprinkler Station.
*/
int SprinkerModel::Set (struct ubus_context *aCtx, struct ubus_request_data *aReq,
struct blob_attr *aMsg)
{
int theResult;
char *theString = blobmsg_format_json (aMsg, true);
Json::Reader theReader;
Json::Value theRoot;
uint32_t theStation = 0;
bool theState = false;
if (!theReader.parse (theString, theRoot)) {
fprintf (stderr, "Failed parse the parameters.\n");
return UBUS_STATUS_INVALID_ARGUMENT;
}
theStation = theRoot["station"].asInt();
theState = theRoot["state"].asBool();
if (theStation == 0) {
fprintf (stderr, "Station ID is missing.\n");
return UBUS_STATUS_INVALID_ARGUMENT;
}
theResult = sprinklers_set_station (theStation, theState);
if (theResult != 0) {
fprintf (stderr, "Wrong Station ID (%d).\n", theStation);
return UBUS_STATUS_INVALID_ARGUMENT;
}
return theResult;
}

49
deprecated/src/sprinklersd/src/UbusSprinklerModel.h
View File

@@ -1,49 +0,0 @@
/*!
* UBusModel.h
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 30/04/2015
*
*/
#ifndef _UBUS_SPRINKLER_MODEL_H
#define _UBUS_SPRINKLER_MODEL_H
/*------------------------------- INCLUDES ----------------------------------*/
#include <stdint.h>
#include <ubuscpp/UBusObject.h>
/*--------------------------------- Define ----------------------------------*/
/*--------------------------------- CLASS ----------------------------------*/
class SprinkerModel : public UBusObject {
public:
SprinkerModel (void);
~SprinkerModel (void);
int Get (struct ubus_context*, struct ubus_request_data*, struct blob_attr*);
int Set (struct ubus_context*, struct ubus_request_data*, struct blob_attr*);
};
#endif /* _UBUS_SPRINKLER_MODEL_H */

120
deprecated/src/sprinklersd/src/main.cpp
View File

@@ -1,120 +0,0 @@
/*!
* main.c
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 30/04/2015
*
*/
/*-------------------------------- INCLUDES ---------------------------------*/
#include <cstdio>
#include <unistd.h>
extern "C" {
#include <libubus.h>
}
#include "UbusSprinklerModel.h"
#include "sprinklers.h"
/*--------------------------------- GLOBALS ---------------------------------*/
/*! ----------------------------------------------------------------------------
* @fn setupUbus
*
* @brief Setup the UBus Mechanism.
*/
extern "C" {
static struct ubus_context *setupUbus (void)
{
ubus_context *theCtx;
if (uloop_init () !=0) {
fprintf (stderr, "Failed to init Uloop.\n");
return NULL;
}
signal (SIGPIPE, SIG_IGN);
theCtx = ubus_connect (NULL);
if (!theCtx) {
fprintf (stderr, "Failed to connect to ubus\n");
return NULL;
}
ubus_add_uloop (theCtx);
return theCtx;
}
} // SetupUbus.
/*! ----------------------------------------------------------------------------
* @fn main
*
* @brief Main function of Domo Daemon.
*/
int main (void)
{
int theRet = 0;
SprinkerModel theSprinklersModel;
struct ubus_context *theCtx = NULL;
if (setuid (0)) {
perror ("setuid");
return 1;
}
/* Setup the Ubus context. */
theCtx = setupUbus ();
if (theCtx == NULL) {
return -1;
}
/* Setup the sprinklers. */
theRet = sprinklers_setup ();
if (theRet != 0) {
fprintf (stderr, "Impossible to Setup the Sprinkers.\n");
return theRet;
}
/* Add the UBus to the model exposed. */
ubus_add_object (theCtx, &theSprinklersModel);
/* Main Event Loop. */
uloop_run ();
ubus_free (theCtx);
uloop_done ();
return theRet;
}

180
deprecated/src/sprinklersd/src/sprinklers.cpp
View File

@@ -1,180 +0,0 @@
/*!
* sprinklers.c
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 30/04/2015
*
*/
/*-------------------------------- INCLUDES ---------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <jsoncpp/json.h>
#include <string>
#include <ubuscpp/UBusCall.h>
#include "sprinklers.h"
/*-------------------------------- GLOBALES ---------------------------------*/
/*! ----------------------------------------------------------------------------
* @fn sprinklers_setup
*
* @brief this function setup the OSPI environement.
*/
int sprinklers_setup (void)
{
UBusCall theCmd;
std::string theResult;
int theIDVal;
fprintf (stderr, "Setup the Gpios used by the Sprinklers.\n");
if (theCmd.Exec ("domo.capabilities.sprinklers", "get", "", theResult) == 0){
// We get the the sprinklers. Get the IDs.
Json::Reader theReader;
Json::Value theRoot;
Json::Value theElement;
if (!theReader.parse (theResult, theRoot)) {
fprintf (stderr, "Failed parse the List of Sprinklers.\n");
return -1;
}
for (const Json::Value& theElement : theRoot["Sprinklers"]) {
theIDVal = theElement["id"].asInt();
sprinkler_setup_station (theIDVal);
}
}
return 0;
}
/*! ----------------------------------------------------------------------------
* @fn sprinkler_setup_station
*
* @brief This function change the State of an Ospi Station.
*/
int sprinkler_setup_station (int aStation)
{
char theCommand[255];
printf (" Setup the Station: %d\n", aStation);
// Activate the Gpio
sprintf (theCommand, "echo %d > /sys/class/gpio/export", aStation);
system (theCommand);
// Select the Direction of the Gpio
sprintf (theCommand, "echo out > /sys/class/gpio/gpio%d/direction", aStation);
system (theCommand);
// Select the Direction of the Gpio
sprintf (theCommand, "echo 1 > /sys/class/gpio/gpio%d/value", aStation);
system (theCommand);
return 0;
}
/*! ----------------------------------------------------------------------------
* @fn sprinkler_set_station
*
* @brief This function change the State of an Ospi Station.
*/
int sprinklers_set_station (uint32_t aStation, bool aState)
{
FILE *theFp;
char theGpioPath[255];
sprintf (theGpioPath, "/sys/class/gpio/gpio%d/value", aStation);
theFp = fopen (theGpioPath, "w");
if (theFp == NULL) {
fprintf (stderr, "Impossible to open: <%s>\n", theGpioPath);
return -1;
}
if (aState) {
fwrite ("0", 1, 1, theFp);
}
else {
fwrite ("1", 1, 1, theFp);
}
fclose (theFp);
return 0;
}
/*! ----------------------------------------------------------------------------
* @fn sprinkler_get_station
*
* @brief This function change the State of an Ospi Station.
*/
int sprinklers_get_station (uint32_t aStation, bool &aState)
{
FILE *theFp;
char theGpioPath[255];
char theData[5];
fprintf (stdout, "get station state (%d)\n", aStation);
sprintf (theGpioPath, "/sys/class/gpio/gpio%d/value", aStation);
theFp = fopen (theGpioPath, "r");
if (theFp == NULL) {
fprintf (stderr, "Impossible to open: <%s>\n", theGpioPath);
return -1;
}
fread (theData, 1, 1, theFp);
//printf ("theData: %s\n", theData);
if (theData[0] == '0') {
aState = true;
}
else {
aState = false;
}
fclose (theFp);
return 0;
}

42
deprecated/src/sprinklersd/src/sprinklers.h
View File

@@ -1,42 +0,0 @@
/*!
* sprinklers.h
*
* Copyright (c) 2015, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 30/04/2015
*
*/
#ifndef __SPRINKLERS_H
#define __SPRINKLERS_H
/*-------------------------------- INCLUDES ---------------------------------*/
#include <stdint.h>
/*-------------------------------- METHODS ---------------------------------*/
int sprinklers_setup (void);
int sprinkler_setup_station (int aStation);
int sprinklers_set_station (uint32_t aStation, bool aState);
int sprinklers_get_station (uint32_t aStation, bool &aState);
#endif /* __SPRINKLERS_H */