lpcmanager

RTC write on set to hardware and valid output is now boolean type.

2016-12-05, dporopat
2fc2a48aee54
RTC write on set to hardware and valid output is now boolean type.
#include <native/task.h>
#include <native/mutex.h>
#include <native/timer.h>
#include <unistd.h>
#include <fcntl.h>
#include "beremiz.h"
/*------------------------- GPIO -------------------------------------*/
/* from armadeus/target/packages/as_devices/c/as_gpio* */
//#ifdef DEBUG
# define ERROR(fmt, ...) printf(fmt, ##__VA_ARGS__)
//#else
//# define ERROR(fmt, ...) /*fmt, ##__VA_ARGS__*/
//#endif
struct gpio_device {
int port_num;
int pin_file; /* pin file for 2.6.29 interface*/
};
struct gpio_device *RTU_GPIO_dev;
struct gpio_device *RUN_LED_dev;
#ifdef MC9
struct gpio_device *CAN0_EN_dev;
struct gpio_device *CAN1_EN_dev;
#endif /* MC9 */
static int write_file_bool(int fd, int value)
{
int ret;
ret = write(fd, value?"1":"0", 1);
if (ret < 0) {
ERROR("write error\n");
return ret;
}
if (lseek(fd, 0, SEEK_SET) < 0) {
ERROR("lseek error\n");
return ret;
}
return ret;
}
#define BUFF_SIZE 256
static int gpio_set_pin_value(struct gpio_device *aDev, int aValue)
{
int pin_file = aDev->pin_file;
int retval;
retval = write_file_bool(pin_file, aValue);
if (retval < 0) {
ERROR("Can't write value\n");
close(pin_file);
return -1;
}
return aValue;
}
static struct gpio_device *gpio_open(int aGpioNum)
{
struct gpio_device *dev;
int pin_file;
int export_file;
int gpio_dir_fd;
int retval;
char buf[BUFF_SIZE];
int ret = 0;
export_file = open("/sys/class/gpio/export", O_WRONLY);
if (export_file < 0) {
ERROR("Can't open /sys/class/gpio/export\nBe sure that gpiolib is under your kernel\n");
return NULL;
}
snprintf(buf, BUFF_SIZE, "%%d", aGpioNum);
retval = write(export_file, buf, strlen(buf));
close(export_file);
if (retval < 0) {
ERROR("/sys/class/gpio/export can't be written\n");
return NULL;
}
snprintf(buf, BUFF_SIZE, "/sys/class/gpio/gpio%%d/direction", aGpioNum);
gpio_dir_fd = open(buf, O_WRONLY);
if (gpio_dir_fd < 0) {
ERROR("Can't open gpio%%d direction\n", aGpioNum);
return NULL;
}
ret = write(gpio_dir_fd, "out", 3);
close(gpio_dir_fd);
if (ret < 0){
ERROR("Error writing direction\n");
return NULL;
}
snprintf(buf, BUFF_SIZE, "/sys/class/gpio/gpio%%d/value", aGpioNum);
pin_file = open(buf, O_RDWR);
if (pin_file < 0) {
ERROR("Can't export gpio number %%d\n", aGpioNum);
return NULL;
}
dev = malloc(sizeof(struct gpio_device));
if (dev == NULL) {
ERROR("Can't allocate gpio_device structure\n");
close(pin_file);
return NULL;
}
dev->port_num = aGpioNum;
dev->pin_file = pin_file;
gpio_set_pin_value(dev, 1);
return dev;
}
static int gpio_close(struct gpio_device *aDev)
{
int unexport_file;
char buf[BUFF_SIZE];
int retval;
if(aDev == NULL){
ERROR("device is NULL\n");
return -1;
}
unexport_file = open("/sys/class/gpio/unexport", O_WRONLY);
if (unexport_file < 0) {
ERROR("Can't open /sys/class/gpio/unexport\nBe sure that gpiolib is under your kernel\n");
return -1;
}
snprintf(buf, BUFF_SIZE, "%%d", aDev->port_num);
retval = write(unexport_file, buf, strlen(buf));
close(unexport_file);
if (retval < 0) {
ERROR("/sys/class/gpio/unexport can't be written\n");
return -1;
}
close(aDev->pin_file);
return 0;
}
#define REG_DISCRETE_START 0 /**< Input discrete start address */
#define REG_DISCRETE_NREGS 1024 /**< 1024 bits (type: single bit, Read only) */
#define REG_COILS_START 0 /**< Coils start address */
#define REG_COILS_NREGS 1024 /**< 1024 bits (type: single bit, Read/Write) */
#define REG_INPUT_START 0 /**< Input registers start address */
#define REG_INPUT_NREGS 1024 /**< 1024 words (type: 16-bit word, Read only) */
#define REG_HOLDING_START 0 /**< Holding registers start address */
#define REG_HOLDING_NREGS 1024 /**< 1024 words (type: 16-bit word, Read/Write) */
#define MAX_MOD_RTU_DEVICES 16
typedef struct _mbRtuRdHoldingRegs {
unsigned int use;
unsigned short startAddr;
unsigned char length;
short* buffer;
} mbRtuRdHoldingRegs;
typedef struct _mbRtuRdDiscInputs {
unsigned int use;
unsigned short startAddr;
unsigned short length;
char* buffer;
// unsigned short* buffer;
} mbRtuRdDiscInputs;
typedef struct _mbRtuRdCoils {
unsigned int use;
unsigned short startAddr;
unsigned short length;
char* buffer;
} mbRtuRdCoils;
typedef struct _mbRtuWrSingleCoil {
unsigned int use;
unsigned short startAddr;
char* buffer;
} mbRtuWrSingleCoil;
typedef struct _mbRtuWrCoils {
unsigned int use;
unsigned short startAddr;
unsigned short length;
char* buffer;
} mbRtuWrCoils;
typedef struct _mbRtuRdInputRegs {
unsigned int use;
unsigned short startAddr;
unsigned char length;
short* buffer;
} mbRtuRdInputRegs;
typedef struct _mbRtuWrSingleReg {
unsigned int use;
unsigned short startAddr;
short* buffer;
} mbRtuWrSingleReg;
typedef struct _mbRtuWrMultiRegs {
unsigned int use;
unsigned short startAddr;
unsigned char length;
short* buffer;
} mbRtuWrMultiRegs;
typedef struct _mbRtuSlaveConfig {
unsigned char slaveAddr;
mbRtuRdDiscInputs rdDiscInputs;
mbRtuRdCoils rdCoils;
mbRtuWrSingleCoil wrSingleCoil;
mbRtuWrCoils wrCoils;
mbRtuRdInputRegs rdInputRegs;
mbRtuRdHoldingRegs rdHoldingRegs;
mbRtuWrSingleReg wrSingleReg;
mbRtuWrMultiRegs wrMultiRegs;
} mbRtuSlaveConfig;
typedef enum
{
MB_PAR_ODD = 0, /**< ODD parity. */
MB_PAR_EVEN = 1, /**< Even parity. */
MB_PAR_NONE = 2 /**< No parity. */
} eMBSerialParity;
#define MAX_ONBOARD_DEVICES 2
unsigned char onBoardDev[MAX_ONBOARD_DEVICES][2]; /**< Arrays containing information about enabled on-board devices (initialized by Composer) */
mbRtuSlaveConfig mbRtuSlaveDev[MAX_MOD_RTU_DEVICES];/**< Tables containing information about connected Modbus network devices (initialized by Composer) */
commTimer mbRtuDevTim[MAX_MOD_RTU_DEVICES]; /**< Table of timers (one for each position) */
short usRegInputValue[REG_INPUT_NREGS]; /**< Array of Modbus input registers */
short usRegHoldingValue[REG_HOLDING_NREGS]; /**< Array of Modbus holding registers */
char ubCoilValue[REG_COILS_NREGS/8]; /**< Array of Modbus coils (8 coils per byte) */
char ubRegDiscreteValue[REG_DISCRETE_NREGS/8]; /**< Array of Modbus discrete inputs (8 inputs per byte) */
unsigned long mbBaudRate = 115200; /**< Modbus baud-rate setting: 9600, 19200, 38400, 57600, 115200 */
eMBSerialParity mbParity = MB_PAR_NONE; /**< Modbus parity setting: odd, even, none */
/* prototypes for functions defined in shared library */
int mbmrtu_init(unsigned long ulBaudRate, eMBSerialParity eParity);
void mbmrtu_BusUpdate(int);
int mbmrtu_cleanup(void);
static RT_TASK RTU_UART_task;
static RT_TASK RTU_task;
static RT_MUTEX RTU_BuffMutex;
void LockMBRTUBuffer(void){
while ( rt_mutex_acquire(&RTU_BuffMutex, TM_INFINITE ) == -EINTR);
}
void UnLockMBRTUBuffer(void){
rt_mutex_release(&RTU_BuffMutex);
}
typedef struct {
void*(*RTU_UART_task_proc)(void *);
void* xSerHdl;
} MB_xeno_task_adaptor_t;
static MB_xeno_task_adaptor_t MB_xeno_task_adaptor_data;
void MB_xeno_task_adaptor(void* param)
{
MB_xeno_task_adaptor_t *d = param;
d->RTU_UART_task_proc(d->xSerHdl);
}
int CreateMBRTUSerialTask(
void*(*RTU_UART_task_proc)(void *),
void* param)
{
int err;
MB_xeno_task_adaptor_data.RTU_UART_task_proc = RTU_UART_task_proc;
MB_xeno_task_adaptor_data.xSerHdl = param;
if((err = rt_task_start(&RTU_UART_task,
MB_xeno_task_adaptor,
&MB_xeno_task_adaptor_data)) != 0)
return err;
return 0;
}
#define nsTOus(ns) (ns/1000L)
#define nsTOms(ns) (ns/1000000L)
#define INVALID_RTU_ADDR 255 /* Used when no Modbus RTU slave device is present */
static void mbmrtu_BusUpdate_proc(void *param){
uint64_t actTime;
while (rt_task_sleep_until(TM_INFINITE) == -EINTR){
int i;
for(i=0;i<MAX_MOD_RTU_DEVICES;i++)
{
if(mbRtuSlaveDev[i].slaveAddr != INVALID_RTU_ADDR)
{
if(mbRtuDevTim[i].status != TIM_DISABLED)
{
actTime = (uint64_t)nsTOms(rt_timer_read());
mbRtuDevTim[i].actValue += actTime - mbRtuDevTim[i].oldTime;
mbRtuDevTim[i].oldTime = actTime;
if(mbRtuDevTim[i].actValue < mbRtuDevTim[i].toValue)
mbRtuDevTim[i].status = TIM_EN_RUNNING;
else
mbRtuDevTim[i].status = TIM_EN_EXPIRED;
}
/* Check if communication depends on timer - if it does, check timer status */
if((mbRtuDevTim[i].status == TIM_DISABLED) || (mbRtuDevTim[i].status == TIM_EN_EXPIRED))
{
mbmrtu_BusUpdate(i);
/* If timer is enabled, reset it's value, otherwise keep it disabled */
if(mbRtuDevTim[i].status != TIM_DISABLED)
{
mbRtuDevTim[i].actValue = 0; /* Reset timer value */
mbRtuDevTim[i].status = TIM_EN_RUNNING;
}
else /* Keep timer disabled */
mbRtuDevTim[i].status = TIM_DISABLED;
}
}
}
}
}
RTIME now;
void TransmitMode(void){
gpio_set_pin_value(RTU_GPIO_dev, 1);
now = rt_timer_read();
}
void RecieveMode(int us){
while(rt_task_sleep_until(
now + rt_timer_ns2ticks(1000LL*us)
) == -EINTR);
gpio_set_pin_value(RTU_GPIO_dev, 0);
}