mraa_gpio_context setupISRO( int pinNumber, void (*isrHandler)(void *) ) {
mraa_gpio_context isro = mraa_gpio_init( pinNumber );
if ( ! isro ) {
printf( " Failed initing isro\n" );
mraa_result_print( MRAA_ERROR_UNSPECIFIED );
return 0;
// } else {
// printf( " Inited isro on pin: %d\n", pinNumber );
}
response = mraa_gpio_dir( isro, MRAA_GPIO_IN );
if (response != MRAA_SUCCESS) {
// printf( " Failed setting isro pin direction\n" );
mraa_result_print((mraa_result_t) response);
return 0;
}
// printf( " Setup isro pin direction to IN\n" );
mraa_result_t result = mraa_gpio_isr( isro, MRAA_GPIO_EDGE_BOTH, isrHandler, isro);
if ( result != MRAA_SUCCESS ) {
// printf( " Setup isro interrupt service routine failed with result: %d\n", result );
return 0;
}
// printf( " Setup isro interrupt service routine\n" );
// Init to test pin level
// lastTime = getTimeCheck();
// isr1( NULL ); // Check level
return isro;
}
mraa_pwm_context setupPWMO( int pinNumber ) {
on = 0;
mraa_pwm_context pwmo = mraa_pwm_init( pinNumber );
if ( ! pwmo ) {
printf( " Failed initing pwmo\n" );
mraa_result_print( MRAA_ERROR_UNSPECIFIED );
return 0;
}
response = mraa_pwm_enable( pwmo, 0 ); // Initially off
if (response != MRAA_SUCCESS) {
// printf( " Failed setting pwmo enable to off during setup\n" );
mraa_result_print((mraa_result_t) response);
return 0;
}
response = mraa_pwm_config_percent( pwmo, 100, 0.25 ); // Startup settings, 0.1 second, 50% duty cycle
if (response != MRAA_SUCCESS) {
// printf( " Failed setting pwmo period and duty cycle\n" );
mraa_result_print((mraa_result_t) response);
return 0;
}
response = mraa_pwm_enable( pwmo, 1 ); // Now enable it
if (response != MRAA_SUCCESS) {
// printf( " Failed setting pwmo enable to on during setup\n" );
mraa_result_print((mraa_result_t) response);
return 0;
}
// printf( " Inited pwmo for pin %d\n", pinNumber );
return pwmo;
}
/** Read multiple words from a 16-bit device register.
* @param devAddr I2C slave device address or Slave Select pin if SPI
* @param regAddr First register regAddr to read from
* @param length Number of words to read
* @param data Buffer to store read data in
* @return Number of words read (0 indicates failure)
*/
mraa_result_t I2Cdev::readWords (uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data) {
#ifdef I2CDEV_SERIAL_DEBUG
printf ("readWords: addr 0x%02X regAddr 0x%02X...", devAddr, regAddr);
#endif
mraa_result_t result;
const uint8_t dlength = length + length;
uint8_t *newData = new uint8_t[dlength];
mutex->lock();
if ((result = _i2c->address (devAddr)) != MRAA_SUCCESS) {
printf ("ERROR: ");
mraa_result_print (result);
printf (" Exit\n");
return result;
}
if ((result = _i2c->writeByte (regAddr)) != MRAA_SUCCESS) {
printf ("ERROR: ");
mraa_result_print (result);
printf (" Exit\n");
return result;
}
if ((result = _i2c->address (devAddr)) != MRAA_SUCCESS) {
printf ("ERROR: ");
mraa_result_print (result);
printf (" Exit\n");
return result;
}
if (_i2c->read (newData, dlength) != dlength) {
printf ("ERROR: received different amount of bytes\n");
return MRAA_ERROR_UNSPECIFIED;
}
for (uint8_t i = 0, j = 0; i < length; i++) {
data[i] = (uint16_t) (newData[j++] << 8);
data[i] |= (uint16_t) newData[j];
}
mutex->unlock();
delete[] newData;
#ifdef I2CDEV_SERIAL_DEBUG
printf ("Succeeded\n\r");
#endif
return MRAA_SUCCESS;
}
void mkInterface::outputPin( int offOn ) {
response = gpio->write( offOn );
if (response != MRAA_SUCCESS) {
mraa_result_print((mraa_result_t) response);
}
}
void outputPin( mraa_gpio_context gpio, int offOn ) {
response = mraa_gpio_write( gpio, offOn );
if (response != MRAA_SUCCESS) {
mraa_result_print((mraa_result_t) response);
}
}
void mkInterface::togglePin() {
response = gpio->write( on );
if (response != MRAA_SUCCESS) {
mraa_result_print((mraa_result_t) response);
}
on = ( 0 == on ) ? 1 : 0;
}
void togglePin( mraa_gpio_context gpio ) {
response = mraa_gpio_write( gpio, on );
if (response != MRAA_SUCCESS) {
// printf( "\n Failed writing to gpio pin: %p\n", gpio );
mraa_result_print((mraa_result_t) response);
}
on = ( 0 == on ) ? 1 : 0;
}
void closePWMO( mraa_pwm_context pwmo ) {
response = mraa_pwm_enable( pwmo, 0 ); // Set to off
if (response != MRAA_SUCCESS) {
// printf( " Failed setting pwmo enable to off when closing output\n" );
mraa_result_print((mraa_result_t) response);
} else {
mraa_pwm_close( pwmo );
}
}
/**
*Set the i2c bus and address of where the data will be written to.
*
*@param i2c context, pass in the i2c context that represents
*a master on the i2c bus.
*@param addr The address of the I2C device
*
*/
static int set_address(mraa_i2c_context i2c, int addr) {
mraa_result_t mraa_result = mraa_i2c_address(i2c, addr);
if (mraa_result != MRAA_SUCCESS)
{
DEBUG("set_address(): mraa_i2c_address() failure, error code: %d\n", mraa_result);
mraa_result_print(mraa_result);
}
return mraa_result;
}
mraa_aio_context setupAIO( int pinNumber ) {
mraa_aio_context aio = mraa_aio_init( pinNumber );
if ( ! aio ) {
printf( " Failed initing aio\n" );
mraa_result_print( MRAA_ERROR_UNSPECIFIED );
return 0;
// } else {
// printf( " Inited aio: %p\n", aio );
}
return aio;
}
/** Read multiple bytes from an 8-bit device register.
* @param devAddr I2C slave device address
* @param regAddr First register regAddr to read from
* @param length Number of bytes to read
* @param data Buffer to store read data in
* @return Number of bytes read (0 indicates failure)
*/
mraa_result_t I2Cdev::readBytes (uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data) {
#ifdef I2CDEV_SERIAL_DEBUG
printf ("readBytes: addr 0x%02X regAddr 0x%02X...", devAddr, regAddr);
#endif
mraa_result_t result;
mutex->lock();
if ((result = _i2c->address (devAddr)) != MRAA_SUCCESS) {
printf ("ERROR: ");
mraa_result_print (result);
printf (" Exit\n");
return result;
}
if ((result = _i2c->writeByte (regAddr)) != MRAA_SUCCESS) {
printf ("ERROR: ");
mraa_result_print (result);
printf (" Exit\n");
return result;
}
if ((result = _i2c->address (devAddr)) != MRAA_SUCCESS) {
printf ("ERROR: ");
mraa_result_print (result);
printf (" Exit\n");
return result;
}
if (_i2c->read (data, length) != length) {
printf ("ERROR: received different amount of bytes\n");
return MRAA_ERROR_UNSPECIFIED;
}
mutex->unlock();
#ifdef I2CDEV_SERIAL_DEBUG
printf ("Succeeded\n\r");
#endif
return MRAA_SUCCESS;
}
mraa_gpio_context setupGPIO( int pinNumber, int direction ) {
on = 0;
mraa_gpio_context gpio = mraa_gpio_init( pinNumber );
if ( ! gpio ) {
printf( " Failed initing gpio\n" );
mraa_result_print( MRAA_ERROR_UNSPECIFIED );
return 0;
// } else {
// printf( " Inited gpio: %p\n", gpio );
}
response = mraa_gpio_dir( gpio, direction );
if (response != MRAA_SUCCESS) {
// printf( " Failed setting gpio pin direction\n" );
mraa_result_print((mraa_result_t) response);
return 0;
}
return gpio;
}
int main(int ac, char **av)
{
int iopin;
mraa_result_t result;
mraa_gpio_context gpio;
int value;
mraa_init();
if (ac != 3) {
fprintf(stderr, "Usage: %s pin_number\n" \
"\nExample: %s 7 -> Read pin 7\n"
, av[0], av[0]);
return -1;
}
iopin = atoi(av[1]);
/* Initialisation of pin */
gpio = mraa_gpio_init(iopin);
if (gpio == NULL) {
fprintf(stderr, "[-] Initialisation of pin %d failed. Is this pin exist on your platform?\n", iopin);
return -1;
}
/* Set GPIO direction */
result = mraa_gpio_dir(gpio, MRAA_GPIO_IN);
if (result != MRAA_SUCCESS) {
mraa_result_print(result);
return -1;
}
value = mraa_gpio_read(gpio);
if (result != MRAA_SUCCESS)
mraa_result_print(result);
printf("%d", value);
return 0;
}
bool mkInterface::setupGPIO( int pinNumber ) {
on = 0;
iopin = pinNumber;
gpio = new mraa::Gpio( iopin, true, false );
fprintf(stdout, "\nHello mraa\n Version: %s", mraa_get_version());
mraa_platform_t platform = mraa_get_platform_type();
fprintf(stdout, "\n Platform type: %d\n", platform );
response = gpio->dir(mraa::DIR_OUT);
if (response != MRAA_SUCCESS) {
mraa_result_print((mraa_result_t) response);
return false;
}
return true;
}
/**
* Print a textual representation of the mraa_result_t
*
* @param result the result to print
*/
void printError(mraa_result_t result)
{
mraa_result_print(result);
}
/*
bool I2Cdev4Edison::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t* data) {
//int8_t count = 0;
uint8_t buf[128];
//int fd;
if (length > 127) {
fprintf(stderr, "Byte write count (%d) > 127\n", length);
return(FALSE);
}
//fd = open("/dev/i2c-0", O_RDWR);
//if (fd < 0) {
// fprintf(stderr, "Failed to open device: %s\n", strerror(errno));
// return(FALSE);
//}
i2c->address(devAddr);
//if (ioctl(fd, I2C_SLAVE, devAddr) < 0) {
// fprintf(stderr, "Failed to select device: %s\n", strerror(errno));
// close(fd);
// return(FALSE);
// }
buf[0] = regAddr;
memcpy(buf+1,data,length);
//count = write(fd, buf, length+1);
mraa::Result result = i2c->write(buf, length + 1);
if (result != mraa::SUCCESS){
mraa::printError(result);
return false;
}
return true;
//if (count < 0) {
// fprintf(stderr, "Failed to write device(%d): %s\n", count, ::strerror(errno));
// close(fd);
// return(FALSE);
//} else if (count != length+1) {
// fprintf(stderr, "Short write to device, expected %d, got %d\n", length+1, count);
// close(fd);
// return(FALSE);
//}
//close(fd);
}
*/
int edison_i2c_write(unsigned char slave_addr,
unsigned char reg_addr,
unsigned char length,
unsigned char const *data)
{
uint8_t buf[128];
if (length > 127) {
fprintf(stderr, "MRAA Byte write count (%d) > 127\n", length);
return(-1);
}
buf[0] = reg_addr;
memcpy(buf+1,data,length);
mraa_result_t mr = mraa_i2c_write(i2c, buf, length + 1);
if (mr != MRAA_SUCCESS){
fprintf(stderr, "MRAA Failed to write data in reg address %x on the i2c bus.\n", reg_addr);
mraa_result_print(mr);
return -1;
}
return 0;
//if (count < 0) {
// fprintf(stderr, "Failed to write device(%d): %s\n", count, ::strerror(errno));
// close(fd);
// return(FALSE);
//} else if (count != length+1) {
// fprintf(stderr, "Short write to device, expected %d, got %d\n", length+1, count);
// close(fd);
// return(FALSE);
//}
//close(fd);
/*
unsigned long start, cur;
if (!i2c.enabled)
return -1;
if (!length)
return 0;
// Populate struct.
i2c.state = STATE_WRITING;
i2c.slave_reg = reg_addr;
i2c.slave_reg_written = 0;
i2c.data = (unsigned char*)data;
i2c.length = length;
I2CSA = slave_addr;
CTL1 |= UCTR | UCTXSTT;
msp430_get_clock_ms(&start);
while (i2c.state != STATE_WAITING) {
__bis_SR_register(LPM0_bits + GIE);
msp430_get_clock_ms(&cur);
if (cur >= (start + I2C_TIMEOUT_MS)) {
CTL1 |= UCTXSTP;
i2c.state = STATE_WAITING;
msp430_i2c_disable();
msp430_delay_ms(1);
CLEAR_SCL();
CLEAR_SDA();
msp430_delay_ms(1);
SET_SCL();
SET_SDA();
msp430_i2c_enable();
return -1;
}
}
return 0;
*/
}
int main(int argc, char** argv)
{
mraa_result_t r = MRAA_SUCCESS;
/* These are Joule's onboard LED's. */
int default_joule_leds[] = {100, 101, 102, 103};
int *gpio_pins;
int num_pins;
int *input_values, *output_values;
printf("Provide int arg(s) if you want to toggle gpio pins other than Joule's onboard LED's\n");
if (argc < 2) {
gpio_pins = default_joule_leds;
num_pins = 4;
} else {
num_pins = argc - 1;
gpio_pins = malloc(num_pins * sizeof(int));
for (int i = 0; i < num_pins; ++i) {
gpio_pins[i] = strtol(argv[i+1], NULL, 10);
}
}
/* Allocate input and output values arrays. */
input_values = malloc(num_pins * sizeof(int));
output_values = malloc(num_pins * sizeof(int));
mraa_init();
fprintf(stdout, "MRAA Version: %s\nStarting program...\n", mraa_get_version());
mraa_gpio_context gpio = mraa_gpio_init_multi(gpio_pins, num_pins);
if (gpio == NULL) {
fprintf(stderr, "Error during gpio initialization\n");
exit(1);
}
r = mraa_gpio_dir(gpio, MRAA_GPIO_OUT);
if (r != MRAA_SUCCESS) {
mraa_result_print(r);
}
signal(SIGINT, sig_handler);
/* Set input values first. */
memset(input_values, 0, num_pins * sizeof(int));
while (running == 0) {
r = mraa_gpio_write_multi(gpio, input_values);
sleep(1);
if (r != MRAA_SUCCESS) {
mraa_result_print(r);
} else {
r = mraa_gpio_read_multi(gpio, output_values);
if (r != MRAA_SUCCESS) {
mraa_result_print(r);
}
}
for (int i = 0; i < num_pins; ++i) {
input_values[i] = (input_values[i] + 1) % 2;
}
}
memset(input_values, 0, num_pins * sizeof(int));
mraa_gpio_write_multi(gpio, input_values);
r = mraa_gpio_close(gpio);
if (r != MRAA_SUCCESS) {
mraa_result_print(r);
}
/* Cleanup. */
if (argc >= 2) {
free(gpio_pins);
}
free(input_values);
free(output_values);
return r;
}
int
main(int argc, char** argv)
{
mraa_platform_t platform = mraa_get_platform_type();
mraa_gpio_context gpio, gpio_in = NULL;
const char* board_name = mraa_get_platform_name();
int ledstate = 0;
mraa_result_t r = MRAA_SUCCESS;
switch (platform) {
case MRAA_INTEL_GALILEO_GEN1:
gpio = mraa_gpio_init_raw(3);
break;
case MRAA_INTEL_MINNOWBOARD_MAX:
// there is no onboard LED that we can flash on the minnowboard max
// but on the calamari lure pin 21 is an LED. If you don't have the
// lure put an LED on pin 21
gpio = mraa_gpio_init(21);
break;
case MRAA_INTEL_JOULE_EXPANSION:
gpio = mraa_gpio_init(101);
break;
default:
gpio = mraa_gpio_init(13);
}
fprintf(stdout, "Welcome to libmraa\n Version: %s\n Running on %s (Ctrl+C to exit)\n", mraa_get_version(), board_name);
if (gpio == NULL) {
fprintf(stdout, "Could not initilaize gpio\n");
return 1;
}
// on platforms with physical button use gpio_in
if (platform == MRAA_INTEL_MINNOWBOARD_MAX) {
gpio_in = mraa_gpio_init(14);
if (gpio_in != NULL) {
mraa_gpio_dir(gpio_in, MRAA_GPIO_IN);
// S1 on minnowboardmax's calamari lure maps to pin 14, SW1 != S1
fprintf(stdout, "Press and hold S1 to stop, Press SW1 to shutdown!\n");
}
}
mraa_gpio_dir(gpio, MRAA_GPIO_OUT);
signal(SIGINT, sig_handler);
while (running == 0) {
if (gpio_in != NULL && mraa_gpio_read(gpio_in) == 0) {
mraa_gpio_close(gpio_in);
return 0;
}
ledstate = !ledstate;
mraa_gpio_write(gpio, !ledstate);
sleep(1);
}
r = mraa_gpio_close(gpio);
if (r != MRAA_SUCCESS) {
mraa_result_print(r);
}
return r;
}
int
main(int argc, char** argv)
{
mraa_result_t status = MRAA_SUCCESS;
mraa_spi_context spi;
int i, j;
/* initialize mraa for the platform (not needed most of the times) */
mraa_init();
//! [Interesting]
/* initialize SPI bus */
spi = mraa_spi_init(SPI_BUS);
if (spi == NULL) {
fprintf(stderr, "Failed to initialize SPI\n");
mraa_deinit();
return EXIT_FAILURE;
}
/* set SPI frequency */
status = mraa_spi_frequency(spi, SPI_FREQ);
if (status != MRAA_SUCCESS)
goto err_exit;
/* set big endian mode */
status = mraa_spi_lsbmode(spi, 0);
if (status != MRAA_SUCCESS) {
goto err_exit;
}
/* MAX7219/21 chip needs the data in word size */
status = mraa_spi_bit_per_word(spi, 16);
if (status != MRAA_SUCCESS) {
fprintf(stdout, "Failed to set SPI Device to 16Bit mode\n");
goto err_exit;
}
/* do not decode bits */
mraa_spi_write_word(spi, 0x0900);
/* brightness of LEDs */
mraa_spi_write_word(spi, 0x0a05);
/* show all scan lines */
mraa_spi_write_word(spi, 0x0b07);
/* set display on */
mraa_spi_write_word(spi, 0x0c01);
/* testmode off */
mraa_spi_write_word(spi, 0x0f00);
while (flag) {
/* set display pattern */
mraa_spi_write_buf_word(spi, pat, 16);
sleep(2);
/* set inverted display pattern */
mraa_spi_write_buf_word(spi, pat_inv, 16);
sleep(2);
/* clear the LED's */
mraa_spi_write_buf_word(spi, pat_clear, 16);
/* cycle through all LED's */
for (i = 1; i <= 8; i++) {
for (j = 0; j < 8; j++) {
mraa_spi_write_word(spi, (i << 8) + (1 << j));
sleep(1);
}
mraa_spi_write_word(spi, i << 8);
}
}
/* stop spi */
mraa_spi_stop(spi);
//! [Interesting]
/* deinitialize mraa for the platform (not needed most of the times) */
mraa_deinit();
return EXIT_SUCCESS;
err_exit:
mraa_result_print(status);
/* stop spi */
mraa_spi_stop(spi);
/* deinitialize mraa for the platform (not needed most of the times) */
mraa_deinit();
return EXIT_FAILURE;
}