コード例 #1
0
ファイル: bno055.c プロジェクト: g-vidal/upm
upm_result_t bno055_install_isr(const bno055_context dev,
                                int gpio, mraa_gpio_edge_t level,
                                void (*isr)(void *), void *arg)
{
    assert(dev != NULL);

    // delete any existing ISR and GPIO context
    bno055_uninstall_isr(dev);

    // create gpio context
    if (!(dev->gpio = mraa_gpio_init(gpio)))
    {
        printf("%s: mraa_gpio_init() failed.\n", __FUNCTION__);
        return UPM_ERROR_OPERATION_FAILED;
    }

    mraa_gpio_dir(dev->gpio, MRAA_GPIO_IN);

    if (mraa_gpio_isr(dev->gpio, level, isr, arg))
    {
        mraa_gpio_close(dev->gpio);
        dev->gpio = NULL;
        printf("%s: mraa_gpio_isr() failed.\n", __FUNCTION__);
        return UPM_ERROR_OPERATION_FAILED;
    }

    return UPM_SUCCESS;
}
コード例 #2
0
ファイル: dhtreader.c プロジェクト: nage-son/pi-test
int main(int argc, char* argv[]) {
    int i, pin;

    if (argc != 2) {
        printf("Input GPIO number...");
        exit(1);
    }

    pin = atoi(argv[1]);

    printf("GPIO >>> %d\n", pin);

    mraa_gpio_context gpio;

    gpio = mraa_gpio_init(pin);

    mraa_gpio_dir(gpio, MRAA_GPIO_OUT);

    while (1) {
        mraa_gpio_write(gpio, 0);
        printf("Off\n");
        sleep(1);

        mraa_gpio_write(gpio, 1);
        printf("On\n");
        sleep(1);
    }

    mraa_gpio_close(gpio);

    return 0;
}
コード例 #3
0
ファイル: mraa.c プロジェクト: alexandruradovici/mraa
mraa_pin_t*
mraa_setup_pwm(int pin)
{
    if (plat == NULL)
        return NULL;

    if (plat->pins[pin].capabilites.pwm != 1)
        return NULL;

    if (plat->pins[pin].capabilites.gpio == 1) {
        mraa_gpio_context mux_i;
        mux_i = mraa_gpio_init_raw(plat->pins[pin].gpio.pinmap);
        if (mux_i == NULL)
            return NULL;
        if (mraa_gpio_dir(mux_i, MRAA_GPIO_OUT) != MRAA_SUCCESS)
            return NULL;
        // Current REV D quirk. //TODO GEN 2
        if (mraa_gpio_write(mux_i, 1) != MRAA_SUCCESS)
            return NULL;
        if (mraa_gpio_close(mux_i) != MRAA_SUCCESS)
            return NULL;
    }

    if (plat->pins[pin].pwm.mux_total > 0)
       if (mraa_setup_mux_mapped(plat->pins[pin].pwm) != MRAA_SUCCESS)
            return NULL;

    mraa_pin_t *ret;
    ret = (mraa_pin_t*) malloc(sizeof(mraa_pin_t));
    ret->pinmap = plat->pins[pin].pwm.pinmap;
    ret->parent_id = plat->pins[pin].pwm.parent_id;
    return ret;
}
コード例 #4
0
ファイル: kx122.c プロジェクト: g-vidal/upm
upm_result_t kx122_install_isr(const kx122_context dev, mraa_gpio_edge_t edge,KX122_INTERRUPT_PIN_T intp, int pin, void (*isr)(void *), void *arg)
{
  assert(dev != NULL);
  mraa_gpio_context isr_gpio = NULL;

  if (!(isr_gpio = mraa_gpio_init(pin))){
    printf("%s: mraa_gpio_init() failed.\n", __FUNCTION__);
    return UPM_ERROR_OPERATION_FAILED;
  }

  mraa_gpio_dir(isr_gpio, MRAA_GPIO_IN);

  if (mraa_gpio_isr(isr_gpio, edge, isr, arg)){
    mraa_gpio_close(isr_gpio);
    printf("%s: mraa_gpio_isr() failed.\n", __FUNCTION__);
    return UPM_ERROR_OPERATION_FAILED;
  }

  if(intp == INT1){
    dev->gpio1 = isr_gpio;
  }
  else{
    dev->gpio2 = isr_gpio;
  }

  return UPM_SUCCESS;
}
コード例 #5
0
ファイル: intel_galileo_rev_d.c プロジェクト: Hbrinj/mraa
mraa_result_t
mraa_intel_galileo_g1_pwm_init_pre(int pin)
{
    // Gen1 galileo has no kernel muxing for GPIOs/PWM so ends up with leakage
    // on the PWM pins from the GPIO pins if not set to output high
    if (plat->pins[pin].capabilities.gpio == 1) {
        mraa_gpio_context mux_i;
        mux_i = mraa_gpio_init_raw(plat->pins[pin].gpio.pinmap);
        if (mux_i == NULL) {
            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_init", pin);
            return MRAA_ERROR_INVALID_RESOURCE;
        }
        if (mraa_gpio_dir(mux_i, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_dir", pin);
            return MRAA_ERROR_INVALID_RESOURCE;
        }
        if (mraa_gpio_write(mux_i, 1) != MRAA_SUCCESS) {
            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_write", pin);
            return MRAA_ERROR_INVALID_RESOURCE;
        }
        if (mraa_gpio_close(mux_i) != MRAA_SUCCESS) {
            syslog(LOG_ERR, "pwm_init: error in gpio->pwm%i transition. gpio_close", pin);
            return MRAA_ERROR_INVALID_RESOURCE;
        }
    }
    return MRAA_SUCCESS;
}
コード例 #6
0
void mraaDigitalDispose(FskPinDigital pin)
{
	mraaDigital md = (mraaDigital)pin;

	if (md->context)
		mraa_gpio_close(md->context);

	FskMemPtrDispose(pin);
}
コード例 #7
0
ファイル: led.c プロジェクト: mihaitghstefanescu/upm
void led_close(led_context dev){
    if (dev->gpio) {
        mraa_gpio_close(dev->gpio);
    }
    if (dev->gpioled) {
        mraa_led_close(dev->gpioled);
    }
    free(dev);
}
コード例 #8
0
ファイル: ppd42ns.c プロジェクト: mihaitghstefanescu/upm
void ppd42ns_close(ppd42ns_context dev)
{
    assert(dev != NULL);

    if (dev->gpio)
        mraa_gpio_close(dev->gpio);

    free(dev);
}
コード例 #9
0
void Adafruit_STMPE610::end(void) {
    // hardware SPI
    if (SPI)
        mraa_spi_stop(SPI);
    if (_gpioCS)
        mraa_gpio_close(_gpioCS);
    DestroyTransaction();

}
コード例 #10
0
ファイル: intel_edison_fab_c.c プロジェクト: neuroidss/mraa
mraa_result_t
mraa_intel_edison_pwm_init_pre(int pin)
{
    if (miniboard == 1) {
        return mraa_intel_edison_pinmode_change(plat->pins[pin].gpio.pinmap, 1);
    }
    if (pin < 0 || pin > 19) {
        return MRAA_ERROR_INVALID_RESOURCE;
    }

    if (!plat->pins[pin].capabilites.pwm) {
        return MRAA_ERROR_INVALID_RESOURCE;
    }

    mraa_gpio_context output_e;
    output_e = mraa_gpio_init_raw(outputen[pin]);
    if (output_e == NULL) {
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    if (mraa_gpio_dir(output_e, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
        mraa_gpio_close(output_e);
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    if (mraa_gpio_write(output_e, 1) != MRAA_SUCCESS) {
        mraa_gpio_close(output_e);
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    mraa_gpio_close(output_e);

    mraa_gpio_context pullup_pin;
    pullup_pin = mraa_gpio_init_raw(pullup_map[pin]);
    if (pullup_pin == NULL) {
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    if (mraa_gpio_dir(pullup_pin, MRAA_GPIO_IN) != MRAA_SUCCESS) {
        mraa_gpio_close(pullup_pin);
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    mraa_gpio_close(pullup_pin);
    mraa_intel_edison_pinmode_change(plat->pins[pin].gpio.pinmap, 1);

    return MRAA_SUCCESS;
}
コード例 #11
0
ファイル: bno055.c プロジェクト: chihchun/upm
void bno055_uninstall_isr(const bno055_context dev)
{
    assert(dev != NULL);

    if (dev->gpio)
    {
        mraa_gpio_isr_exit(dev->gpio);
        mraa_gpio_close(dev->gpio);
        dev->gpio = NULL;
    }
}
コード例 #12
0
ファイル: intel_galileo_rev_g.c プロジェクト: 8devices/mraa
mraa_result_t
mraa_intel_galileo_gen2_gpio_close_pre(mraa_gpio_context dev)
{
    if (dev->phy_pin >= 0) {
        int pin = dev->phy_pin;
        if (agpioOutputen[pin]) {
            mraa_gpio_close(agpioOutputen[pin]);
            agpioOutputen[pin] = NULL;
        }
    }
    return MRAA_SUCCESS;
}
コード例 #13
0
ファイル: io.c プロジェクト: adhoc-dtn/electroSwitch
int main(int argc, char *argv[])
{
    mraa_init();

    fprintf(stdout, "Hello mraa.\nVersion: %s\n", mraa_get_version());

    // LED
    out = mraa_gpio_init(20);
    if(out == NULL){
        printf("Error: init out.\r\n");
        return 1;
    }
    mraa_gpio_dir(out, MRAA_GPIO_OUT);

    // Switch
    mraa_gpio_context in = mraa_gpio_init(14);
    if(in == NULL){
        printf("Error: init in.\r\n");
        return 1;
    }
    mraa_gpio_dir(in, MRAA_GPIO_IN);
    mraa_gpio_mode(in, MRAA_GPIO_PULLUP);

    // 割込関数の登録
    mraa_gpio_isr(in, MRAA_GPIO_EDGE_BOTH, interrupt_in, (void *)in);

    while(1) {}




    mraa_gpio_isr_exit(in);
    mraa_gpio_close(in);
    mraa_gpio_close(out);

    mraa_deinit();

    return 0;
}
コード例 #14
0
mraa_result_t
mraa_intel_edison_spi_init_pre(int bus)
{
    if (miniboard == 1) {
        mraa_intel_edison_pinmode_change(111, 1);
        mraa_intel_edison_pinmode_change(115, 1);
        mraa_intel_edison_pinmode_change(114, 1);
        mraa_intel_edison_pinmode_change(109, 1);
        return MRAA_SUCCESS;
    }
    mraa_gpio_write(tristate, 0);

    mraa_gpio_context io10_out = mraa_gpio_init_raw(258);
    mraa_gpio_context io11_out = mraa_gpio_init_raw(259);
    mraa_gpio_context io12_out = mraa_gpio_init_raw(260);
    mraa_gpio_context io13_out = mraa_gpio_init_raw(261);
    mraa_gpio_dir(io10_out, MRAA_GPIO_OUT);
    mraa_gpio_dir(io11_out, MRAA_GPIO_OUT);
    mraa_gpio_dir(io12_out, MRAA_GPIO_OUT);
    mraa_gpio_dir(io13_out, MRAA_GPIO_OUT);

    mraa_gpio_write(io10_out, 1);
    mraa_gpio_write(io11_out, 1);
    mraa_gpio_write(io12_out, 0);
    mraa_gpio_write(io13_out, 1);

    mraa_gpio_close(io10_out);
    mraa_gpio_close(io11_out);
    mraa_gpio_close(io12_out);
    mraa_gpio_close(io13_out);

    mraa_gpio_context io10_pull = mraa_gpio_init_raw(226);
    mraa_gpio_context io11_pull = mraa_gpio_init_raw(227);
    mraa_gpio_context io12_pull = mraa_gpio_init_raw(228);
    mraa_gpio_context io13_pull = mraa_gpio_init_raw(229);

    mraa_gpio_dir(io10_pull, MRAA_GPIO_IN);
    mraa_gpio_dir(io11_pull, MRAA_GPIO_IN);
    mraa_gpio_dir(io12_pull, MRAA_GPIO_IN);
    mraa_gpio_dir(io13_pull, MRAA_GPIO_IN);

    mraa_gpio_close(io10_pull);
    mraa_gpio_close(io11_pull);
    mraa_gpio_close(io12_pull);
    mraa_gpio_close(io13_pull);

    return MRAA_SUCCESS;
}
コード例 #15
0
ファイル: lis3dh.c プロジェクト: g-vidal/upm
void
lis3dh_uninstall_isr(const lis3dh_context dev, LIS3DH_INTERRUPT_PINS_T intr)
{
    assert(dev != NULL);

    switch (intr) {
        case LIS3DH_INTERRUPT_INT1:
            if (dev->gpioINT1) {
                mraa_gpio_isr_exit(dev->gpioINT1);
                mraa_gpio_close(dev->gpioINT1);
                dev->gpioINT1 = NULL;
            }
            break;

        case LIS3DH_INTERRUPT_INT2:
            if (dev->gpioINT2) {
                mraa_gpio_isr_exit(dev->gpioINT2);
                mraa_gpio_close(dev->gpioINT2);
                dev->gpioINT2 = NULL;
            }
            break;
    }
}
コード例 #16
0
ファイル: intel_edison_fab_c.c プロジェクト: neuroidss/mraa
mraa_result_t
mraa_intel_edison_aio_init_pre(unsigned int aio)
{
    if (aio > plat->aio_count) {
        syslog(LOG_ERR, "edison: Invalid analog input channel");
        return MRAA_ERROR_INVALID_RESOURCE;
    }

    int pin = 14 + aio;
    mraa_gpio_context output_e;
    output_e = mraa_gpio_init_raw(outputen[pin]);
    if (output_e == NULL) {
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    if (mraa_gpio_dir(output_e, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
        mraa_gpio_close(output_e);
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    if (mraa_gpio_write(output_e, 0) != MRAA_SUCCESS) {
        mraa_gpio_close(output_e);
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    mraa_gpio_close(output_e);

    mraa_gpio_context pullup_pin;
    pullup_pin = mraa_gpio_init_raw(pullup_map[pin]);
    if (pullup_pin == NULL) {
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    if (mraa_gpio_dir(pullup_pin, MRAA_GPIO_IN) != MRAA_SUCCESS) {
        mraa_gpio_close(pullup_pin);
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    mraa_gpio_close(pullup_pin);

    return MRAA_SUCCESS;
}
コード例 #17
0
ファイル: speaker.c プロジェクト: chihchun/upm
void speaker_close(speaker_context dev)
{
    assert(dev != NULL);

    if (dev->gpio)
        mraa_gpio_close(dev->gpio);

    if (dev->pwm)
    {
        speaker_off(dev);
        mraa_pwm_close(dev->pwm);
    }

    free(dev);
}
コード例 #18
0
ファイル: mma7361.c プロジェクト: stefan-andritoiu/upm
void mma7361_close(mma7361_context dev)
{
  assert(dev != NULL);

  // analogs
  if (dev->aio_x)
    mraa_aio_close(dev->aio_x);
  if (dev->aio_y)
    mraa_aio_close(dev->aio_y);
  if (dev->aio_z)
    mraa_aio_close(dev->aio_z);

  // gpios
  if (dev->gpio_selftest)
    mraa_gpio_close(dev->gpio_selftest);
  if (dev->gpio_sleep)
    mraa_gpio_close(dev->gpio_sleep);
  if (dev->gpio_freefall)
    mraa_gpio_close(dev->gpio_freefall);
  if (dev->gpio_range)
    mraa_gpio_close(dev->gpio_range);

  free(dev);
}
コード例 #19
0
ファイル: mraa.c プロジェクト: chenyiran/mraa
mraa_result_t
mraa_setup_mux_mapped(mraa_pin_t meta)
{
    int mi;

    for (mi = 0; mi < meta.mux_total; mi++) {
        mraa_gpio_context mux_i;
        mux_i = mraa_gpio_init_raw(meta.mux[mi].pin);
        if (mux_i == NULL) {
            return MRAA_ERROR_INVALID_HANDLE;
        }
        if (mraa_gpio_dir(mux_i, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
            mraa_gpio_close(mux_i);
            return MRAA_ERROR_UNSPECIFIED;
        }
        if (mraa_gpio_write(mux_i, meta.mux[mi].value) != MRAA_SUCCESS) {
            mraa_gpio_close(mux_i);
            return MRAA_ERROR_INVALID_RESOURCE;
        }
        mraa_gpio_close(mux_i);
    }

    return MRAA_SUCCESS;
}
コード例 #20
0
ファイル: kx122.c プロジェクト: g-vidal/upm
void kx122_close(kx122_context dev)
{
  assert(dev != NULL);
  kx122_uninstall_isr(dev,INT1);
  kx122_uninstall_isr(dev,INT2);

  if(dev->i2c){
    mraa_i2c_stop(dev->i2c);
  }
  if(dev->spi){
    mraa_spi_stop(dev->spi);
  }
  if(dev->chip_select){
    mraa_gpio_close(dev->chip_select);
  }
  free(dev);
}
コード例 #21
0
ファイル: pwm.c プロジェクト: nage-son/pi-test
int main(int argc, char* argv[]) {
    mraa_gpio_context gpio;

    if (argc != 2) {
        printf("gpio [pin]\n");
        exit(1);
    }

    int pin = atoi(argv[1]);

    gpio = mraa_gpio_init(pin);

    if (gpio == NULL) {
        return 1;
    }

    // mraa_gpio_period_ms(4); // communication process is about 4ms(Data sheet)
    // Send start signal

    int readData = 0;
    int count = 0;

    printf("pin number %d\n", mraa_gpio_get_pin(gpio));
    
    while (1) {
        get_data(gpio, &readData);

        count++;

        if (count == 50) {
            printf("aaaa\n");
            break;
        }

        usleep(1000000);
    }

    mraa_gpio_close(gpio);

    printf("GPIO closed.\n");


    return 0;
}
コード例 #22
0
mraa_result_t
mraa_intel_edison_i2c_init_pre(unsigned int bus)
{
    if (miniboard == 0) {
        if(bus != 6) {
            syslog(LOG_ERR, "edison: You can't use that bus, switching to bus 6");
            bus = 6;
        }
        mraa_gpio_write(tristate, 0);
        mraa_gpio_context io18_gpio = mraa_gpio_init_raw(14);
        mraa_gpio_context io19_gpio = mraa_gpio_init_raw(165);
        mraa_gpio_dir(io18_gpio, MRAA_GPIO_IN);
        mraa_gpio_dir(io19_gpio, MRAA_GPIO_IN);
        mraa_gpio_close(io18_gpio);
        mraa_gpio_close(io19_gpio);

        mraa_gpio_context io18_enable = mraa_gpio_init_raw(236);
        mraa_gpio_context io19_enable = mraa_gpio_init_raw(237);
        mraa_gpio_dir(io18_enable, MRAA_GPIO_OUT);
        mraa_gpio_dir(io19_enable, MRAA_GPIO_OUT);
        mraa_gpio_write(io18_enable, 0);
        mraa_gpio_write(io19_enable, 0);
        mraa_gpio_close(io18_enable);
        mraa_gpio_close(io19_enable);

        mraa_gpio_context io18_pullup = mraa_gpio_init_raw(212);
        mraa_gpio_context io19_pullup = mraa_gpio_init_raw(213);
        mraa_gpio_dir(io18_pullup, MRAA_GPIO_IN);
        mraa_gpio_dir(io19_pullup, MRAA_GPIO_IN);
        mraa_gpio_close(io18_pullup);
        mraa_gpio_close(io19_pullup);

        mraa_intel_edison_pinmode_change(28, 1);
        mraa_intel_edison_pinmode_change(27, 1);

        mraa_gpio_write(tristate, 1);
    } else {
        if(bus != 6 && bus != 1) {
            syslog(LOG_ERR, "edison: You can't use that bus, switching to bus 6");
            bus = 6;
        }
        int scl = plat->pins[plat->i2c_bus[bus].scl].gpio.pinmap;
        int sda = plat->pins[plat->i2c_bus[bus].sda].gpio.pinmap;
        mraa_intel_edison_pinmode_change(sda, 1);
        mraa_intel_edison_pinmode_change(scl, 1);
    }

    return MRAA_SUCCESS;
}
コード例 #23
0
FskErr mraaDigitalNew(FskPinDigital *pin, SInt32 number, const char *name, FskPinsDigitalDirection direction)
{
	FskErr err;
	mraa_gpio_context context;
	mraaDigital md;

	context = mraa_gpio_init(number);
	if (!context) return kFskErrOperationFailed;

	err = FskMemPtrNewClear(sizeof(mraaDigitalRecord), (FskMemPtr *)&md);
	if (err) {
		mraa_gpio_close(context);
		return err;
	}

	md->context = context;

	*pin = (FskPinDigital)md;
	return mraaDigitalSetDirection(*pin, direction);
}
コード例 #24
0
ファイル: lis3dh.c プロジェクト: g-vidal/upm
upm_result_t
lis3dh_install_isr(const lis3dh_context dev,
                   LIS3DH_INTERRUPT_PINS_T intr,
                   int gpio,
                   mraa_gpio_edge_t level,
                   void (*isr)(void*),
                   void* arg)
{
    assert(dev != NULL);

    // Delete any existing ISR and GPIO context for this interrupt
    lis3dh_uninstall_isr(dev, intr);

    mraa_gpio_context gpio_isr = NULL;

    // Create GPIO context
    if (!(gpio_isr = mraa_gpio_init(gpio))) {
        printf("%s: mraa_gpio_init() failed\n", __FUNCTION__);
        return UPM_ERROR_OPERATION_FAILED;
    }

    mraa_gpio_dir(gpio_isr, MRAA_GPIO_IN);

    if (mraa_gpio_isr(gpio_isr, level, isr, arg)) {
        mraa_gpio_close(gpio_isr);
        printf("%s: mraa_gpio_isr() failed\n", __FUNCTION__);
        return UPM_ERROR_OPERATION_FAILED;
    }

    switch (intr) {
        case LIS3DH_INTERRUPT_INT1:
            dev->gpioINT1 = gpio_isr;
            break;

        case LIS3DH_INTERRUPT_INT2:
            dev->gpioINT2 = gpio_isr;
            break;
    }

    return UPM_SUCCESS;
}
コード例 #25
0
ファイル: lis3dh.c プロジェクト: g-vidal/upm
void
lis3dh_close(lis3dh_context dev)
{
    assert(dev != NULL);

    lis3dh_uninstall_isr(dev, LIS3DH_INTERRUPT_INT1);
    lis3dh_uninstall_isr(dev, LIS3DH_INTERRUPT_INT2);

    if (dev->i2c) {
        mraa_i2c_stop(dev->i2c);
    }

    if (dev->spi) {
        mraa_spi_stop(dev->spi);
    }

    if (dev->gpioCS) {
        mraa_gpio_close(dev->gpioCS);
    }

    free(dev);
}
コード例 #26
0
static mraa_result_t
mraa_intel_edison_misc_spi()
{
    mraa_gpio_write(tristate, 0);

    mraa_gpio_context io10_p1 = mraa_gpio_init_raw(263);
    mraa_gpio_context io10_p2 = mraa_gpio_init_raw(240);
    mraa_gpio_context io11_p1 = mraa_gpio_init_raw(262);
    mraa_gpio_context io11_p2 = mraa_gpio_init_raw(241);
    mraa_gpio_context io12_p1 = mraa_gpio_init_raw(242);
    mraa_gpio_context io13_p1 = mraa_gpio_init_raw(243);
    mraa_gpio_dir(io10_p1, MRAA_GPIO_OUT);
    mraa_gpio_dir(io10_p2, MRAA_GPIO_OUT);
    mraa_gpio_dir(io11_p1, MRAA_GPIO_OUT);
    mraa_gpio_dir(io11_p2, MRAA_GPIO_OUT);
    mraa_gpio_dir(io12_p1, MRAA_GPIO_OUT);
    mraa_gpio_dir(io13_p1, MRAA_GPIO_OUT);

    mraa_gpio_write(io10_p1, 1);
    mraa_gpio_write(io10_p2, 0);
    mraa_gpio_write(io11_p1, 1);
    mraa_gpio_write(io11_p2, 0);
    mraa_gpio_write(io12_p1, 0);
    mraa_gpio_write(io13_p1, 0);

    mraa_gpio_close(io10_p1);
    mraa_gpio_close(io10_p2);
    mraa_gpio_close(io11_p1);
    mraa_gpio_close(io11_p2);
    mraa_gpio_close(io12_p1);
    mraa_gpio_close(io13_p1);

    mraa_intel_edison_pinmode_change(111, 1);
    mraa_intel_edison_pinmode_change(115, 1);
    mraa_intel_edison_pinmode_change(114, 1);
    mraa_intel_edison_pinmode_change(109, 1);
    mraa_gpio_write(tristate, 1);

    return MRAA_SUCCESS;
}
コード例 #27
0
ファイル: lcm1602.c プロジェクト: chihchun/upm
void lcm1602_close(lcm1602_context dev)
{
    assert(dev != NULL);

    if (dev->i2c)
        mraa_i2c_stop(dev->i2c);

    if (dev->gpioRS)
        mraa_gpio_close(dev->gpioRS);
    if (dev->gpioEN)
        mraa_gpio_close(dev->gpioEN);
    if (dev->gpioD0)
        mraa_gpio_close(dev->gpioD0);
    if (dev->gpioD1)
        mraa_gpio_close(dev->gpioD1);
    if (dev->gpioD2)
        mraa_gpio_close(dev->gpioD2);
    if (dev->gpioD3)
        mraa_gpio_close(dev->gpioD3);

    free(dev);
}
コード例 #28
0
ファイル: intel_edison_fab_c.c プロジェクト: evinrude/mraa
mraa_result_t
mraa_intel_edison_i2c_init_pre(unsigned int bus)
{
    if(bus != 6) {
        syslog(LOG_ERR, "Edison: You can't use that bus :/");
        return MRAA_ERROR_INVALID_RESOURCE;
    }
    mraa_gpio_write(tristate, 0);
    mraa_gpio_context io18_gpio = mraa_gpio_init_raw(14);
    mraa_gpio_context io19_gpio = mraa_gpio_init_raw(165);
    mraa_gpio_dir(io18_gpio, MRAA_GPIO_IN);
    mraa_gpio_dir(io19_gpio, MRAA_GPIO_IN);
    mraa_gpio_close(io18_gpio);
    mraa_gpio_close(io19_gpio);

    mraa_gpio_context io18_enable = mraa_gpio_init_raw(236);
    mraa_gpio_context io19_enable = mraa_gpio_init_raw(237);
    mraa_gpio_dir(io18_enable, MRAA_GPIO_OUT);
    mraa_gpio_dir(io19_enable, MRAA_GPIO_OUT);
    mraa_gpio_write(io18_enable, 0);
    mraa_gpio_write(io19_enable, 0);
    mraa_gpio_close(io18_enable);
    mraa_gpio_close(io19_enable);

    mraa_gpio_context io18_pullup = mraa_gpio_init_raw(212);
    mraa_gpio_context io19_pullup = mraa_gpio_init_raw(213);
    mraa_gpio_dir(io18_pullup, MRAA_GPIO_IN);
    mraa_gpio_dir(io19_pullup, MRAA_GPIO_IN);
    mraa_gpio_close(io18_pullup);
    mraa_gpio_close(io19_pullup);

    mraa_intel_edison_pinmode_change(28, 1);
    mraa_intel_edison_pinmode_change(27, 1);

    mraa_gpio_write(tristate, 1);
    return MRAA_SUCCESS;
}
コード例 #29
0
ファイル: gpio.hpp プロジェクト: jontrulson/mraa
 /**
  * Gpio object destructor, this will only unexport the gpio if we where
  * the owner
  */
 ~Gpio()
 {
     mraa_gpio_close(m_gpio);
 }
コード例 #30
0
ファイル: mraa.c プロジェクト: MFALHI/mraa
mraa_result_t
mraa_setup_mux_mapped(mraa_pin_t meta)
{
    unsigned int mi;
    mraa_result_t ret;
    mraa_gpio_context mux_i = NULL;
    // avoids the unsigned comparison and we should never have a pin that is UINT_MAX!
    unsigned int last_pin = UINT_MAX;

    for (mi = 0; mi < meta.mux_total; mi++) {

        switch(meta.mux[mi].pincmd) {
            case PINCMD_UNDEFINED:              // used for backward compatibility
                if(meta.mux[mi].pin != last_pin) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    mux_i = mraa_gpio_init_raw(meta.mux[mi].pin);
                    if (mux_i == NULL) return MRAA_ERROR_INVALID_HANDLE;
                    last_pin = meta.mux[mi].pin;
                }
                // this function will sometimes fail, however this is not critical as
                // long as the write succeeds - Test case galileo gen2 pin2
                mraa_gpio_dir(mux_i, MRAA_GPIO_OUT);
                ret = mraa_gpio_write(mux_i, meta.mux[mi].value);
                if(ret != MRAA_SUCCESS) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    return MRAA_ERROR_INVALID_RESOURCE;
                }
                break;

            case PINCMD_SET_VALUE:
                if(meta.mux[mi].pin != last_pin) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    mux_i = mraa_gpio_init_raw(meta.mux[mi].pin);
                    if (mux_i == NULL) return MRAA_ERROR_INVALID_HANDLE;
                    last_pin = meta.mux[mi].pin;
                }

                ret = mraa_gpio_write(mux_i, meta.mux[mi].value);

                if(ret != MRAA_SUCCESS) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    return MRAA_ERROR_INVALID_RESOURCE;
                }
                break;

            case PINCMD_SET_DIRECTION:
                if(meta.mux[mi].pin != last_pin) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    mux_i = mraa_gpio_init_raw(meta.mux[mi].pin);
                    if (mux_i == NULL) return MRAA_ERROR_INVALID_HANDLE;
                    last_pin = meta.mux[mi].pin;
                }

                ret = mraa_gpio_dir(mux_i, meta.mux[mi].value);

                if(ret != MRAA_SUCCESS) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    return MRAA_ERROR_INVALID_RESOURCE;
                }
                break;

            case PINCMD_SET_IN_VALUE:
                if(meta.mux[mi].pin != last_pin) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    mux_i = mraa_gpio_init_raw(meta.mux[mi].pin);
                    if (mux_i == NULL) return MRAA_ERROR_INVALID_HANDLE;
                    last_pin = meta.mux[mi].pin;
                }

                ret = mraa_gpio_dir(mux_i, MRAA_GPIO_IN);

                if(ret == MRAA_SUCCESS)
                    ret = mraa_gpio_write(mux_i, meta.mux[mi].value);

                if(ret != MRAA_SUCCESS) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    return MRAA_ERROR_INVALID_RESOURCE;
                }
                break;

            case PINCMD_SET_OUT_VALUE:
                if(meta.mux[mi].pin != last_pin) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    mux_i = mraa_gpio_init_raw(meta.mux[mi].pin);
                    if (mux_i == NULL) return MRAA_ERROR_INVALID_HANDLE;
                    last_pin = meta.mux[mi].pin;
                }

                ret = mraa_gpio_dir(mux_i, MRAA_GPIO_OUT);

                if(ret == MRAA_SUCCESS)
                    ret = mraa_gpio_write(mux_i, meta.mux[mi].value);

                if(ret != MRAA_SUCCESS) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    return MRAA_ERROR_INVALID_RESOURCE;
                }
                break;

            case PINCMD_SET_MODE:
                if(meta.mux[mi].pin != last_pin) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    mux_i = mraa_gpio_init_raw(meta.mux[mi].pin);
                    if (mux_i == NULL) return MRAA_ERROR_INVALID_HANDLE;
                    last_pin = meta.mux[mi].pin;
                }

                ret = mraa_gpio_mode(mux_i, meta.mux[mi].value);

                if(ret != MRAA_SUCCESS) {
                    if (mux_i != NULL) {
                        mraa_gpio_owner(mux_i, 0);
                        mraa_gpio_close(mux_i);
                    }
                    return MRAA_ERROR_INVALID_RESOURCE;
                }
                break;

            case PINCMD_SKIP:
                break;

            default:
                syslog(LOG_NOTICE, "mraa_setup_mux_mapped: wrong command %d on pin %d with value %d", meta.mux[mi].pincmd, meta.mux[mi].pin, meta.mux[mi].value);
                break;
        }
    }

    if (mux_i != NULL) {
        mraa_gpio_owner(mux_i, 0);
        mraa_gpio_close(mux_i);
    }

    return MRAA_SUCCESS;
}