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; }
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; }
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; }
int main () { // Right Trigger Data bool rightTrigger; // Initialize Controller ds4_client_t* controller = ds4_client_new(); const ds4_controls_t* controllerData; // HIT LED SETUP mraa::Gpio* hitLED = new mraa::Gpio(47); if (hitLED == NULL) { fprintf(stdout, "ERROR WITH HITLED\n"); return MRAA_ERROR_UNSPECIFIED; } hitLED->dir(mraa::DIR_OUT); // INITIALIZING INTERRUPTS mraa_gpio_context x; x = mraa_gpio_init(46); if (x == NULL) { fprintf(stdout, "ERROR WITH GPIO\n"); return MRAA_ERROR_UNSPECIFIED; } mraa_gpio_dir(x,MRAA_GPIO_IN); gpio_edge_t rising = MRAA_GPIO_EDGE_FALLING; mraa_gpio_isr(x, rising, &edge, &x); // Initializing PWM's mraa::Pwm* pwm; pwm = new mraa::Pwm(20); fprintf(stdout, "Starting ...\n"); if (pwm == NULL) { return MRAA_ERROR_UNSPECIFIED; } while (pwm->period_us(18) != MRAA_SUCCESS); fprintf(stdout, "Cycling PWM on IO20 (pwm3) \n"); pwm->enable(true); pwm->write(0.0); fall = true; //ds4_client_rgb(controller,255,0,0); while (running == 0){ if (bufferLoaded) { readBuffer(hitLED, controller); } else { // Ping every 0.1 seconds usleep(1000); //Check if right Trigger is pressed if (ds4_client_connected(controller)) { controllerData = ds4_client_controls(controller); rightTrigger = controllerData->r2; } if (rightTrigger) { fprintf(stdout, "SHOOTING\n"); writeByte(0,1,1,pwm); } } } // delete pwm; }
Result isr(Edge mode, v8::Handle<v8::Function> func) { #if NODE_MODULE_VERSION >= 0x000D m_v8isr.Reset(v8::Isolate::GetCurrent(), func); #else m_v8isr = v8::Persistent<v8::Function>::New(func); #endif return (Result) mraa_gpio_isr(m_gpio, (mraa_gpio_edge_t) mode, &uvwork, this); }
upm_result_t a110x_install_isr(a110x_context dev, mraa_gpio_edge_t edge_level, void (*isr)(void *), void *arg){ if (dev->isr_installed) a110x_uninstall_isr(dev); mraa_gpio_isr(dev->gpio, edge_level, isr, arg); dev->isr_installed = true; return UPM_SUCCESS; }
FskErr mraaDigitalRepeat(FskPinDigital pin, FskPinDigitalRepeatTriggerProc triggeredCallback, void *refCon) { mraaDigital md = (mraaDigital)pin; mraa_result_t result = MRAA_SUCCESS; md->triggeredCallback = triggeredCallback; md->refCon = refCon; mraa_gpio_isr_exit(md->context); if (triggeredCallback) result = mraa_gpio_isr(md->context, MRAA_GPIO_EDGE_BOTH, mraaDigitalCallback, md); return (MRAA_SUCCESS == result) ? kFskErrNone : kFskErrOperationFailed; }
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; }
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; }
/** * Sets a callback to be called when pin value changes * * @param mode The edge mode to set * @param fptr Function pointer to function to be called when interrupt is * triggered * @param args Arguments passed to the interrupt handler (fptr) * @return Result of operation */ Result isr(Edge mode, void (*fptr)(void*), void* args) { return (Result) mraa_gpio_isr(m_gpio, (mraa_gpio_edge_t) mode, fptr, args); }
Result isr(Edge mode, jobject runnable) { return (Result) mraa_gpio_isr(m_gpio, (mraa_gpio_edge_t) mode, mraa_java_isr_callback, runnable); }
Result isr(Edge mode, PyObject* pyfunc, PyObject* args) { return (Result) mraa_gpio_isr(m_gpio, (mraa_gpio_edge_t) mode, (void (*) (void*)) pyfunc, (void*) args); }
/** * Sets a callback to be called when pin value changes * * @param mode The edge mode to set * @param fptr Function pointer to function to be called when interupt is * triggered * @param args Arguments passed to the interrupt handler (fptr) * @return Result of operation */ mraa_result_t isr(Edge mode, void (*fptr)(void *), void * args) { return mraa_gpio_isr(m_gpio, (gpio_edge_t) mode, fptr, args); }
mraa_result_t isr(Edge mode, v8::Handle<v8::Function> func) { m_v8isr = v8::Persistent<v8::Function>::New(func); return mraa_gpio_isr(m_gpio, (gpio_edge_t) mode, &uvwork, this); }
mraa_result_t isr(Edge mode, IsrCallback* cb, void* args) { return mraa_gpio_isr(m_gpio, (gpio_edge_t) mode, generic_isr_callback, cb); }
uint8_t RF22::init() { // Wait for RF22 POR (up to 16msec) usleep (16); // Initialise the slave select pin _cs = mraa_gpio_init(_slaveSelectPin); mraa_gpio_dir(_cs, MRAA_GPIO_OUT); mraa_gpio_write(_cs, 0x1); // start the SPI library: // Note the RF22 wants mode 0, MSB first and default to 1 Mbps _spi = mraa_spi_init(0); mraa_spi_mode (_spi, MRAA_SPI_MODE0); mraa_spi_lsbmode(_spi, 0); mraa_spi_frequency(_spi, 1000000); // 1Mhz usleep (100); // Software reset the device reset(); // Get the device type and check it // This also tests whether we are really connected to a device _deviceType = spiRead(RF22_REG_00_DEVICE_TYPE); if ( _deviceType != RF22_DEVICE_TYPE_RX_TRX && _deviceType != RF22_DEVICE_TYPE_TX) return 0; _irq = mraa_gpio_init(_interrupt + 2); mraa_gpio_dir(_irq, MRAA_GPIO_IN); gpio_edge_t edge = MRAA_GPIO_EDGE_FALLING; // Set up interrupt handler if (_interrupt == 0) { _RF22ForInterrupt[0] = this; mraa_gpio_isr(_irq, edge, &RF22::isr0, NULL); } else if (_interrupt == 1) { _RF22ForInterrupt[1] = this; mraa_gpio_isr(_irq, edge, &RF22::isr1, NULL); } else return 0; clearTxBuf(); clearRxBuf(); // Most of these are the POR default spiWrite(RF22_REG_7D_TX_FIFO_CONTROL2, RF22_TXFFAEM_THRESHOLD); spiWrite(RF22_REG_7E_RX_FIFO_CONTROL, RF22_RXFFAFULL_THRESHOLD); spiWrite(RF22_REG_30_DATA_ACCESS_CONTROL, RF22_ENPACRX | RF22_ENPACTX | RF22_ENCRC | RF22_CRC_CRC_16_IBM); // Configure the message headers // Here we set up the standard packet format for use by the RF22 library // 8 nibbles preamble // 2 SYNC words 2d, d4 // Header length 4 (to, from, id, flags) // 1 octet of data length (0 to 255) // 0 to 255 octets data // 2 CRC octets as CRC16(IBM), computed on the header, length and data // On reception the to address is check for validity against RF22_REG_3F_CHECK_HEADER3 // or the broadcast address of 0xff // If no changes are made after this, the transmitted // to address will be 0xff, the from address will be 0xff // and all such messages will be accepted. This permits the out-of the box // RF22 config to act as an unaddresed, unreliable datagram service spiWrite(RF22_REG_32_HEADER_CONTROL1, RF22_BCEN_HEADER3 | RF22_HDCH_HEADER3); spiWrite(RF22_REG_33_HEADER_CONTROL2, RF22_HDLEN_4 | RF22_SYNCLEN_2); setPreambleLength(8); uint8_t syncwords[] = { 0x2d, 0xd4 }; setSyncWords(syncwords, sizeof(syncwords)); setPromiscuous(0); // Check the TO header against RF22_DEFAULT_NODE_ADDRESS spiWrite(RF22_REG_3F_CHECK_HEADER3, RF22_DEFAULT_NODE_ADDRESS); // Set the default transmit header values setHeaderTo(RF22_DEFAULT_NODE_ADDRESS); setHeaderFrom(RF22_DEFAULT_NODE_ADDRESS); setHeaderId(0); setHeaderFlags(0); // Ensure the antenna can be switched automatically according to transmit and receive // This assumes GPIO0(out) is connected to TX_ANT(in) to enable tx antenna during transmit // This assumes GPIO1(out) is connected to RX_ANT(in) to enable rx antenna during receive spiWrite (RF22_REG_0B_GPIO_CONFIGURATION0, 0x12) ; // TX state spiWrite (RF22_REG_0C_GPIO_CONFIGURATION1, 0x15) ; // RX state // Enable interrupts spiWrite(RF22_REG_05_INTERRUPT_ENABLE1, RF22_ENTXFFAEM | RF22_ENRXFFAFULL | RF22_ENPKSENT | RF22_ENPKVALID | RF22_ENCRCERROR | RF22_ENFFERR); spiWrite(RF22_REG_06_INTERRUPT_ENABLE2, RF22_ENPREAVAL); // Set some defaults. An innocuous ISM frequency, and reasonable pull-in setFrequency(434.0, 0.05); // setFrequency(900.0); // Some slow, reliable default speed and modulation setModemConfig(FSK_Rb2_4Fd36); // setModemConfig(FSK_Rb125Fd125); // Minimum power setTxPower(RF22_TXPOW_8DBM); // setTxPower(RF22_TXPOW_17DBM); return 1; }