Raspberries/mraa
Private
Public Access
2
0
Fork 0
Code Activity

firmata: add public firmata API to support custom firmata plugins

Browse Source 
Signed-off-by: Brendan Le Foll <brendan.le.foll@intel.com>
This commit is contained in:
Brendan Le Foll
2016-03-08 12:20:08 +00:00
parent 612f566c99
commit 59107f0a29
8 changed files with 386 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/firmata/firmata.c
View File

@@ -23,6 +23,7 @@
*/
#include "firmata/firmata.h"
#include "mraa_internal.h"
#include <string.h>
#include <stdlib.h>
@@ -35,17 +36,17 @@ firmata_new(const char* name)
mraa_result_t uart_res = MRAA_ERROR_UNSPECIFIED;
printf("Opening device at: %s\n", name);
res = malloc(sizeof(t_firmata));
res = calloc(1, sizeof(t_firmata));
if (!res) {
perror("firmata_new::Failed malloc");
return (NULL);
return NULL;
}
memset(res, 0, sizeof(*res));
res->uart = mraa_uart_init_raw(name);
if (res->uart == NULL) {
fprintf(stderr, "UART failed to setup\n");
return EXIT_FAILURE;
free(res);
return NULL;
}
firmata_initPins(res);
@@ -70,15 +71,14 @@ firmata_pull(t_firmata* firmata)
if (r > 0) {
r = mraa_uart_read(firmata->uart, buff, sizeof(buff));
if (r < 0) {
return (0);
return 0;
}
if (r > 0) {
firmata_parse(firmata, buff, r);
return (r);
return r;
}
} else if (r < 0) {
return (r);
}
return r;
}
void
@@ -230,6 +230,8 @@ firmata_endParse(t_firmata* firmata)
firmata->pins[pin].value |= (firmata->parse_buff[5] << 7);
if (firmata->parse_count > 7)
firmata->pins[pin].value |= (firmata->parse_buff[6] << 14);
#if 1
// disable this to check the firmata_devs responses
} else if (firmata->parse_buff[1] == FIRMATA_I2C_REPLY) {
printf("got an i2c reply with count %d!!\n", firmata->parse_count);
int addr = (firmata->parse_buff[2] & 0x7f) | ((firmata->parse_buff[3] & 0x7f) << 7);
@@ -237,10 +239,26 @@ firmata_endParse(t_firmata* firmata)
int i = 6;
int ii = 0;
for (ii; ii < (firmata->parse_count - 7) / 2; ii++) {
firmata->i2cmsg[addr][reg+ii] = (firmata->parse_buff[i] & 0x7f) | ((firmata->parse_buff[i+1] & 0x7f) << 7);;
firmata->i2cmsg[addr][reg+ii] = (firmata->parse_buff[i] & 0x7f) | ((firmata->parse_buff[i+1] & 0x7f) << 7);
i = i+2;
}
printf("i2c reply is %d\n", firmata->i2cmsg[addr][reg]);
#endif
} else {
struct _firmata* devs = firmata->devs[0];
int i = 0;
if (devs != NULL) {
for (i; i < firmata->dev_count; i++, devs++) {
if (devs != NULL) {
if (firmata->parse_buff[1] == devs->feature) {
// call func
if (devs->isr) {
devs->isr(firmata->parse_buff, firmata->parse_count);
}
}
}
}
}
}
return;
}

77
src/firmata/firmata_mraa.c
View File

@@ -25,6 +25,7 @@
#include <stdlib.h>
#include <string.h>
#include "firmata.h"
#include "mraa_internal.h"
#include "firmata/firmata_mraa.h"
#include "firmata/firmata.h"
@@ -32,6 +33,59 @@
static t_firmata* firmata_dev;
static pthread_t thread_id;
mraa_firmata_context
mraa_firmata_init(int feature)
{
mraa_firmata_context dev = (mraa_firmata_context) calloc(1, sizeof(struct _firmata));
if (dev == NULL) {
return NULL;
}
dev->feature = (uint8_t) feature;
dev->added = 0;
return dev;
}
mraa_result_t
mraa_firmata_write_sysex(mraa_firmata_context dev, char* msg, int length)
{
return mraa_uart_write(firmata_dev->uart, msg, length);
}
mraa_result_t
mraa_firmata_response(mraa_firmata_context dev, void (*fptr)(uint8_t*, int))
{
if (dev->added == 0) {
struct _firmata** ptr;
ptr = realloc(firmata_dev->devs, (firmata_dev->dev_count+1) * sizeof(struct _firmata*));
if (ptr == NULL) {
return MRAA_ERROR_NO_RESOURCES;
}
firmata_dev->devs = ptr;
dev->index = firmata_dev->dev_count;
firmata_dev->dev_count++;
firmata_dev->devs[dev->index] = dev;
dev->added = 1;
}
dev->isr = fptr;
return MRAA_SUCCESS;
}
mraa_result_t
mraa_firmata_response_stop(mraa_firmata_context dev)
{
dev->isr = NULL;
return MRAA_SUCCESS;
}
mraa_result_t
mraa_firmata_close(mraa_firmata_context dev)
{
mraa_firmata_response_stop(dev);
free(dev);
return MRAA_SUCCESS;
}
static mraa_result_t
mraa_firmata_i2c_init_bus_replace(mraa_i2c_context dev)
{
@@ -136,6 +190,7 @@ mraa_firmata_i2c_read_byte(mraa_i2c_context dev)
}
return firmata_dev->i2cmsg[dev->addr][0];
}
return 0;
}
static uint16_t
@@ -186,6 +241,8 @@ mraa_firmata_i2c_read(mraa_i2c_context dev, uint8_t* data, int length)
}
return length;
}
return 0;
}
static uint8_t
@@ -208,6 +265,9 @@ mraa_firmata_i2c_write(mraa_i2c_context dev, const uint8_t* data, int bytesToWri
// buffer needs 5 bytes for firmata, and 2 bytes for every byte of data
int buffer_size = (bytesToWrite*2) + 5;
uint8_t* buffer = calloc(buffer_size, 0);
if (buffer == NULL) {
return MRAA_ERROR_NO_RESOURCES;
}
int i = 0;
int ii = 4;
buffer[0] = FIRMATA_START_SYSEX;
@@ -222,6 +282,7 @@ mraa_firmata_i2c_write(mraa_i2c_context dev, const uint8_t* data, int bytesToWri
}
buffer[buffer_size-1] = FIRMATA_END_SYSEX;
mraa_uart_write(firmata_dev->uart, buffer, buffer_size);
free(buffer);
return MRAA_SUCCESS;
}
@@ -229,6 +290,9 @@ static mraa_result_t
mraa_firmata_i2c_write_byte(mraa_i2c_context dev, uint8_t data)
{
uint8_t* buffer = calloc(7, 0);
if (buffer == NULL) {
return MRAA_ERROR_NO_RESOURCES;
}
buffer[0] = FIRMATA_START_SYSEX;
buffer[1] = FIRMATA_I2C_REQUEST;
buffer[2] = dev->addr;
@@ -237,6 +301,7 @@ mraa_firmata_i2c_write_byte(mraa_i2c_context dev, uint8_t data)
buffer[5] = (data >> 7) & 0x7F;
buffer[6] = FIRMATA_END_SYSEX;
mraa_uart_write(firmata_dev->uart, buffer, 7);
free(buffer);
return MRAA_SUCCESS;
}
@@ -244,6 +309,9 @@ static mraa_result_t
mraa_firmata_i2c_write_byte_data(mraa_i2c_context dev, const uint8_t data, const uint8_t command)
{
uint8_t* buffer = calloc(9, 0);
if (buffer == NULL) {
return MRAA_ERROR_NO_RESOURCES;
}
buffer[0] = FIRMATA_START_SYSEX;
buffer[1] = FIRMATA_I2C_REQUEST;
buffer[2] = dev->addr;
@@ -254,6 +322,7 @@ mraa_firmata_i2c_write_byte_data(mraa_i2c_context dev, const uint8_t data, const
buffer[7] = (data >> 7) & 0x7F;
buffer[8] = FIRMATA_END_SYSEX;
mraa_uart_write(firmata_dev->uart, buffer, 9);
free(buffer);
return MRAA_SUCCESS;
}
@@ -345,8 +414,8 @@ mraa_firmata_gpio_dir_replace(mraa_gpio_context dev, mraa_gpio_dir_t dir)
return MRAA_SUCCESS;
}
static void
mraa_firmata_pull_handler(void)
static void*
mraa_firmata_pull_handler(void* vp)
{
while(1) {
firmata_pull(firmata_dev);
@@ -355,7 +424,7 @@ mraa_firmata_pull_handler(void)
}
mraa_board_t*
mraa_firmata_init(const char* uart_dev)
mraa_firmata_plat_init(const char* uart_dev)
{
mraa_board_t* b = (mraa_board_t*) calloc(1, sizeof(mraa_board_t));
if (b == NULL) {
@@ -499,7 +568,7 @@ mraa_firmata_platform(mraa_board_t* board, const char* uart_dev)
*/
mraa_board_t* sub_plat = NULL;
sub_plat = mraa_firmata_init(uart_dev);
sub_plat = mraa_firmata_plat_init(uart_dev);
if (sub_plat != NULL) {
sub_plat->platform_type = MRAA_GENERIC_FIRMATA;
board->sub_platform = sub_plat;