gpio.cpp

/* OpenSprinkler Unified (AVR/RPI/BBB/LINUX) Firmware
 * Copyright (C) 2014 by Ray Wang (ray@opensprinkler.com)
 *
 * GPIO functions
 * Feb 2015 @ OpenSprinkler.com
 *
 * This file is part of the OpenSprinkler library
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see
 * <http://www.gnu.org/licenses/>. 
 */
 
#include "gpio.h"

#if defined(ARDUINO)

#if defined(ESP8266)

#include <Wire.h>
#include "defines.h"

byte IOEXP::detectType(uint8_t address) {
	Wire.beginTransmission(address);
	if(Wire.endTransmission()!=0) return IOEXP_TYPE_NONEXIST; // this I2C address does not exist
	
	Wire.beginTransmission(address);
	Wire.write(NXP_INVERT_REG); // ask for polarity register
	Wire.endTransmission();
	
	if(Wire.requestFrom(address, (uint8_t)2) != 2) return IOEXP_TYPE_UNKNOWN;
	uint8_t low = Wire.read();
	uint8_t high = Wire.read();
	if(low==0x00 && high==0x00) {
		return IOEXP_TYPE_9555; // PCA9555 has polarity register which inits to 0
	}
	return IOEXP_TYPE_8575;  
}

void PCA9555::pinMode(uint8_t pin, uint8_t IOMode) {
	uint16_t config = i2c_read(NXP_CONFIG_REG);
	if(IOMode == OUTPUT) {
			config &= ~(1 << pin); // config bit set to 0 for output pin
	} else {
			config |= (1 << pin);  // config bit set to 1 for input pin
	}
	i2c_write(NXP_CONFIG_REG, config);
}

uint16_t PCA9555::i2c_read(uint8_t reg) {
	if(address==255)	return 0xFFFF;
	Wire.beginTransmission(address);
	Wire.write(reg);
	Wire.endTransmission();
	if(Wire.requestFrom(address, (uint8_t)2) != 2) {DEBUG_PRINTLN("GPIO error"); return 0xFFFF;}
	uint16_t data0 = Wire.read();
	uint16_t data1 = Wire.read();
	return data0+(data1<<8);
}

void PCA9555::i2c_write(uint8_t reg, uint16_t v){
	if(address==255)	return;
	Wire.beginTransmission(address);
	Wire.write(reg);
	Wire.write(v&0xff);
	Wire.write(v>>8);
	Wire.endTransmission();
}

uint16_t PCF8575::i2c_read(uint8_t reg) {
	if(address==255)	return 0xFFFF;
	Wire.beginTransmission(address);
	if(Wire.requestFrom(address, (uint8_t)2) != 2) return 0xFFFF;
	uint16_t data0 = Wire.read();
	uint16_t data1 = Wire.read();
	Wire.endTransmission();
	return data0+(data1<<8);
}

void PCF8575::i2c_write(uint8_t reg, uint16_t v) {
	if(address==255)	return;
	Wire.beginTransmission(address);
	// todo: handle inputmask (not necessary unless if using any pin as input)
	Wire.write(v&0xff);
	Wire.write(v>>8);
	Wire.endTransmission();
}

uint16_t PCF8574::i2c_read(uint8_t reg) {
	if(address==255)	return 0xFFFF;
	Wire.beginTransmission(address);
	if(Wire.requestFrom(address, (uint8_t)1) != 1) return 0xFFFF;
	uint16_t data = Wire.read();
	Wire.endTransmission();
	return data; 
}

void PCF8574::i2c_write(uint8_t reg, uint16_t v) {
	if(address==255)	return;
	Wire.beginTransmission(address);
	Wire.write((uint8_t)(v&0xFF) | inputmask);
	Wire.endTransmission();  
}

#include "OpenSprinkler.h"

extern OpenSprinkler os;

void pinModeExt(byte pin, byte mode) {
	if(pin==255) return;
	if(pin>=IOEXP_PIN) {
		os.mainio->pinMode(pin-IOEXP_PIN, mode);
	} else {
		pinMode(pin, mode);
	}
}

void digitalWriteExt(byte pin, byte value) {
	if(pin==255) return;
	if(pin>=IOEXP_PIN) {

		os.mainio->digitalWrite(pin-IOEXP_PIN, value);
	/*
		// a pin on IO expander
		byte data=pcf_read(MAIN_I2CADDR);
		if(value) data|=(1<<(pin-IOEXP_PIN));
		else		 data&=~(1<<(pin-IOEXP_PIN));
		data |= MAIN_INPUTMASK; // make sure to enforce 1 for input pins
		pcf_write(MAIN_I2CADDR, data);*/
	} else {
		digitalWrite(pin, value);
	}
}

byte digitalReadExt(byte pin) {
	if(pin==255) return HIGH;
	if(pin>=IOEXP_PIN) {
		return os.mainio->digitalRead(pin-IOEXP_PIN);
		// a pin on IO expander
		//return pcf_read(MAIN_I2CADDR)&(1<<(pin-IOEXP_PIN));
	} else {
		return digitalRead(pin);
	}
}
#endif

#elif defined(OSPI) || defined(OSBO)

#include <sys/types.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <poll.h>
#include <pthread.h>

#define BUFFER_MAX 64
#define GPIO_MAX	 64

// GPIO file descriptors
static int sysFds[GPIO_MAX] = {
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
} ;

// Interrupt service routine functions
static void (*isrFunctions [GPIO_MAX])(void);

static volatile int		 pinPass = -1 ;
static pthread_mutex_t pinMutex ;

/** Export gpio pin */
static byte GPIOExport(int pin) {
	char buffer[BUFFER_MAX];
	int fd, len;

	fd = open("/sys/class/gpio/export", O_WRONLY);
	if (fd < 0) {
		DEBUG_PRINTLN("failed to open export for writing");
		return 0;
	}

	len = snprintf(buffer, sizeof(buffer), "%d", pin);
	write(fd, buffer, len);
	close(fd);
	return 1;
}

/** Unexport gpio pin */
static byte GPIOUnexport(int pin) {
	char buffer[BUFFER_MAX];
	int fd, len;

	fd = open("/sys/class/gpio/unexport", O_WRONLY);
	if (fd < 0) {
		DEBUG_PRINTLN("failed to open unexport for writing");
		return 0;
	}

	len = snprintf(buffer, sizeof(buffer), "%d", pin);
	write(fd, buffer, len);
	close(fd);
	return 1;
}

/** Set interrupt edge mode */
static byte GPIOSetEdge(int pin, const char *edge) {
	char path[BUFFER_MAX];
	int fd, len;

	snprintf(path, BUFFER_MAX, "/sys/class/gpio/gpio%d/edge", pin);

	fd = open(path, O_WRONLY);
	if (fd < 0) {
		DEBUG_PRINTLN("failed to open gpio edge for writing");
		return 0;
	}
	write(fd, edge, strlen(edge)+1);
	close(fd);
	return 1;
}

/** Set pin mode, in or out */
void pinMode(int pin, byte mode) {
	static const char dir_str[]  = "in\0out";

	char path[BUFFER_MAX];
	int fd;

	snprintf(path, BUFFER_MAX, "/sys/class/gpio/gpio%d/direction", pin);

	struct stat st;
	if(stat(path, &st)) {
		if (!GPIOExport(pin)) return;
	}

	fd = open(path, O_WRONLY);
	if (fd < 0) {
		DEBUG_PRINTLN("failed to open gpio direction for writing");
		return;
	}

	if (-1 == write(fd, &dir_str[INPUT==mode?0:3], INPUT==mode?2:3)) {
		DEBUG_PRINTLN("failed to set direction");
		return;
	}

	close(fd);
	return;
}

/** Open file for digital pin */
int gpio_fd_open(int pin, int mode) {
	char path[BUFFER_MAX];
	int fd;

	snprintf(path, BUFFER_MAX, "/sys/class/gpio/gpio%d/value", pin);
	fd = open(path, mode);
	if (fd < 0) {
		DEBUG_PRINTLN("failed to open gpio");
		return -1;
	}
	return fd;
}

/** Close file */
void gpio_fd_close(int fd) {
	close(fd);
}

/** Read digital value */
byte digitalRead(int pin) {
	char value_str[3];

	int fd = gpio_fd_open(pin, O_RDONLY);
	if (fd < 0) {
		return 0;
	}

	if (read(fd, value_str, 3) < 0) {
		DEBUG_PRINTLN("failed to read value");
		return 0;
	}

	close(fd);
	return atoi(value_str);
}

/** Write digital value given file descriptor */
void gpio_write(int fd, byte value) {
	static const char value_str[] = "01";

	if (1 != write(fd, &value_str[LOW==value?0:1], 1)) {
		DEBUG_PRINT("failed to write value on pin ");
	}
}

/** Write digital value */
void digitalWrite(int pin, byte value) {
	int fd = gpio_fd_open(pin);
	if (fd < 0) {
		return;
	}
	gpio_write(fd, value);
	close(fd);
}

static int HiPri (const int pri) {
	struct sched_param sched ;

	memset (&sched, 0, sizeof(sched)) ;

	if (pri > sched_get_priority_max (SCHED_RR))
		sched.sched_priority = sched_get_priority_max (SCHED_RR) ;
	else
		sched.sched_priority = pri ;

	return sched_setscheduler (0, SCHED_RR, &sched) ;
}

static int waitForInterrupt (int pin, int mS)
{
	int fd, x ;
	uint8_t c ;
	struct pollfd polls ;

	if((fd=sysFds[pin]) < 0)
		return -2;

	polls.fd		 = fd ;
	polls.events = POLLPRI ;			// Urgent data!

	x = poll (&polls, 1, mS) ;
// Do a dummy read to clear the interrupt
//			A one character read appars to be enough.
//			Followed by a seek to reset it.

	(void)read (fd, &c, 1);
	lseek (fd, 0, SEEK_SET);

	return x ;
}

static void *interruptHandler (void *arg) {
	int myPin ;

	(void) HiPri (55) ;  // Only effective if we run as root

	myPin		= pinPass ;
	pinPass = -1 ;

	for (;;)
		if (waitForInterrupt (myPin, -1) > 0)
			isrFunctions[myPin]() ;

	return NULL ;
}

#include "utils.h"
/** Attach an interrupt function to pin */
void attachInterrupt(int pin, const char* mode, void (*isr)(void)) {
	if((pin<0)||(pin>GPIO_MAX)) {
		DEBUG_PRINTLN("pin out of range");
		return;
	}

	// set pin to INPUT mode and set interrupt edge mode
	pinMode(pin, INPUT);
	GPIOSetEdge(pin, mode);

	char path[BUFFER_MAX];
	snprintf(path, BUFFER_MAX, "/sys/class/gpio/gpio%d/value", pin);
	int fd;

	// open gpio file
	if(sysFds[pin]==-1) {
		if((sysFds[pin]=open(path, O_RDWR))<0) {
			DEBUG_PRINTLN("failed to open gpio value for reading");
			return;
		}
	}

	int count, i;
	char c;
	// clear any pending interrupts
	ioctl (sysFds[pin], FIONREAD, &count) ;
	for (i=0; i<count; i++)
		read (sysFds[pin], &c, 1) ;

	// record isr function
	isrFunctions[pin] = isr;

	pthread_t threadId ;
	pthread_mutex_lock (&pinMutex) ;
		pinPass = pin ;
		pthread_create (&threadId, NULL, interruptHandler, NULL) ;
		while (pinPass != -1)
			delay(1) ;
	pthread_mutex_unlock (&pinMutex) ;
}
#else

void pinMode(int pin, byte mode) {}
void digitalWrite(int pin, byte value) {}
byte digitalRead(int pin) {return 0;}
void attachInterrupt(int pin, const char* mode, void (*isr)(void)) {}
int gpio_fd_open(int pin, int mode) {return 0;}
void gpio_fd_close(int fd) {}
void gpio_write(int fd, byte value) {}

#endif