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;
}
