// The main function for the example program int main() { // Handles ctrl-c or other orderly exits signal(SIGINT, exit_handler); // check that we are running on Galileo or Edison mraa_platform_t platform = mraa_get_platform_type(); if ((platform != MRAA_INTEL_GALILEO_GEN1) && (platform != MRAA_INTEL_GALILEO_GEN2) && (platform != MRAA_INTEL_EDISON_FAB_C)) { std::cerr << "ERROR: Unsupported platform" << std::endl; return MRAA_ERROR_INVALID_PLATFORM; } // create and initialize UPM devices devices.init(); // start worker thread for device communication std::thread t1(runner, std::ref(devices)); // define web server & routes crow::SimpleApp app; CROW_ROUTE(app, "/") ([]() { std::stringstream text; text << index_html; return text.str(); }); CROW_ROUTE(app, "/data.json") ([](const crow::request& req) { crow::json::wvalue result; for (int i = 0; i < 360; i++) { result[i] = degrees[i]; } return crow::response{result}; }); CROW_ROUTE(app, "/styles.css") ([]() { std::stringstream text; text << styles_css; return text.str(); }); // start web server app.port(3000).multithreaded().run(); // wait forever for the thread to exit t1.join(); return MRAA_SUCCESS; }
int mraa_get_platform_combined_type() { int type = mraa_get_platform_type(); int sub_type = mraa_has_sub_platform() ? plat->sub_platform->platform_type : MRAA_UNKNOWN_PLATFORM; return type | (sub_type << 8); }
int main(int argc, char **argv) { mraa_platform_t platform = mraa_get_platform_type(); mraa_gpio_context gpio; char board_name[] = "Some weird devboard that isn't recognised..."; int ledstate = 0; switch (platform) { case MRAA_INTEL_GALILEO_GEN1: strcpy(board_name, "Intel Galileo Gen1"); gpio = mraa_gpio_init_raw(3); break; case MRAA_INTEL_GALILEO_GEN2: strcpy(board_name, "Intel Galileo Gen2"); default: gpio = mraa_gpio_init(13); } fprintf(stdout, "Welcome to libmraa\n Version: %s\n Running on %s\n", mraa_get_version(), board_name); mraa_gpio_dir(gpio, MRAA_GPIO_OUT); for (;;) { ledstate = !ledstate; mraa_gpio_write(gpio, !ledstate); sleep(1); } return 0; }
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; 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\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); for (;;) { if (gpio_in != NULL && mraa_gpio_read(gpio_in) == 0) { return 0; } ledstate = !ledstate; mraa_gpio_write(gpio, !ledstate); sleep(1); } return 0; }
void startMRAA( void ) { // printf( "\n I/O is enabled\n" ); mraa_init(); printf( " MRAA library Version: %s\n", mraa_get_version() ); mraa_platform_t platformType = mraa_get_platform_type(); printf( " Platform type: %d\n", platformType ); char *platformName = mraa_get_platform_name(); printf( " Platform name: %s\n", platformName ); }
int main(int argc, char **argv) { mraa_platform_t platform = mraa_get_platform_type(); mraa_gpio_context gpio, gpio_in = NULL; char* board_name = mraa_get_platform_name(); int ledstate = 0; switch (platform) { case MRAA_INTEL_GALILEO_GEN1: gpio = mraa_gpio_init_raw(3); break; case MRAA_INTEL_MINNOWBOARD_MAX: gpio = mraa_gpio_init(21); break; default: gpio = mraa_gpio_init(13); } fprintf(stdout, "Welcome to libmraa\n Version: %s\n Running on %s\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); fprintf(stdout, "Press and hold S1 to stop\n"); } } mraa_gpio_dir(gpio, MRAA_GPIO_OUT); for (;;) { if (gpio_in != NULL && mraa_gpio_read(gpio_in) == 0) { return 0; } ledstate = !ledstate; mraa_gpio_write(gpio, !ledstate); sleep(1); } 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; }
/** * Whilst the actual mraa init function is now called imraa_init, it's only * callable externally if IMRAA is enabled */ mraa_result_t imraa_init() { if (plat != NULL) { return MRAA_SUCCESS; } uid_t proc_euid = geteuid(); struct passwd* proc_user = getpwuid(proc_euid); #ifdef DEBUG setlogmask(LOG_UPTO(LOG_DEBUG)); #else setlogmask(LOG_UPTO(LOG_NOTICE)); #endif openlog("libmraa", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); syslog(LOG_NOTICE, "libmraa version %s initialised by user '%s' with EUID %d", mraa_get_version(), (proc_user != NULL) ? proc_user->pw_name : "<unknown>", proc_euid); mraa_platform_t platform_type; #if defined(X86PLAT) // Use runtime x86 platform detection platform_type = mraa_x86_platform(); #elif defined(ARMPLAT) // Use runtime ARM platform detection platform_type = mraa_arm_platform(); #elif defined(MOCKPLAT) // Use mock platform platform_type = mraa_mock_platform(); #else #error mraa_ARCH NOTHING #endif if (plat != NULL) { plat->platform_type = platform_type; } else { platform_name = NULL; } // Create null base platform if one doesn't already exist if (plat == NULL) { plat = (mraa_board_t*) calloc(1, sizeof(mraa_board_t)); if (plat != NULL) { plat->platform_type = MRAA_NULL_PLATFORM; plat->platform_name = "Unknown platform"; } } #if defined(USBPLAT) // Now detect sub platform, note this is not an else since we could be in // an error case and fall through to MRAA_ERROR_PLATFORM_NOT_INITIALISED if (plat != NULL) { mraa_platform_t usb_platform_type = mraa_usb_platform_extender(plat); // if we have no known platform just replace usb platform with platform if (plat->platform_type == MRAA_UNKNOWN_PLATFORM && usb_platform_type != MRAA_UNKNOWN_PLATFORM) { plat->platform_type = usb_platform_type; } } if (plat == NULL) { printf("mraa: FATAL error, failed to initialise platform\n"); return MRAA_ERROR_PLATFORM_NOT_INITIALISED; } #endif #if defined(IMRAA) const char* subplatform_lockfile = "/tmp/imraa.lock"; mraa_add_from_lockfile(subplatform_lockfile); #endif // Look for IIO devices mraa_iio_detect(); if (plat != NULL) { int length = strlen(plat->platform_name) + 1; if (mraa_has_sub_platform()) { // Account for ' + ' chars length += strlen(plat->sub_platform->platform_name) + 3; } platform_name = calloc(length, sizeof(char)); if (mraa_has_sub_platform()) { snprintf(platform_name, length, "%s + %s", plat->platform_name, plat->sub_platform->platform_name); } else { strncpy(platform_name, plat->platform_name, length); } } lang_func = (mraa_lang_func_t*) calloc(1, sizeof(mraa_lang_func_t)); if (lang_func == NULL) { return MRAA_ERROR_NO_RESOURCES; } syslog(LOG_NOTICE, "libmraa initialised for platform '%s' of type %d", mraa_get_platform_name(), mraa_get_platform_type()); return MRAA_SUCCESS; }
int main(int argc, char** argv) { mraa_platform_t platform; /* Type of platform we are on */ mraa_gpio_context gpio_led = NULL; /* LED GPIO descriptor */ mraa_gpio_context gpio_button = NULL; /* BUTTON GPIO descriptor */ mraa_aio_context adc_a0 = NULL; /* Analog-Digital descriptor */ uint32_t adc_val; /* ADC value */ float delay; /* Delay between blinks */ int ledstate = 0; /* LED state, 0=off, 1=on */ /* * Print banner. */ platform = mraa_get_platform_type(); fprintf(stdout, "MRAA C Demonstration\n"); fprintf(stdout, "LIBMRAA Version: %s\n", mraa_get_version()); fprintf(stdout, "Board: %s\n", mraa_get_platform_name()); /* * Check that we are running on the correct board */ platform = mraa_get_platform_type(); if (platform != MRAA_INTEL_GALILEO_GEN2) { fprintf(stderr, "ERROR: This program is for a Intel Galileo Gen 2 Board\n"); exit (-1); } /* * Initialize the LED gpio pin and set it as an output */ gpio_led = mraa_gpio_init(LED); if (gpio_led == NULL) { fprintf(stderr, "Could not initialize LED gpio\n"); exit (-1); } mraa_gpio_dir(gpio_led, MRAA_GPIO_OUT); /* * Initialize the Button gpio pin and set it as an input */ gpio_button = mraa_gpio_init(BUTTON); if (gpio_button == NULL) { fprintf(stderr, "Could not initialize BUTTON gpio\n"); } mraa_gpio_dir(gpio_button, MRAA_GPIO_IN); /* * Initialize the Analog-Digital converter channel 0 */ adc_a0 = mraa_aio_init(0); if (adc_a0 == NULL) { fprintf(stderr, "Failed to initalize ADC channel A0\n"); exit (-1); } printf("Vary the rate of blink by turning the poteniometer on A0\n"); printf("Exit the program by pressing the button on D%d\n\n", BUTTON); /* * Run the loop until the BUTTON is held down. * Each time through the loop, read the potentiometer on A0 and * adjust the blink rate. */ while (1) { if (mraa_gpio_read(gpio_button) == 1) break; if (adc_a0 != NULL) { adc_val = mraa_aio_read(adc_a0); /* fprintf(stdout, "ADC A0 = %d\n", adc_val); */ if (adc_val != 0) delay = 1000000 * ((float)adc_val/1024); else delay = 1000000 * (1/1024); } ledstate = !ledstate; mraa_gpio_write(gpio_led, ledstate); usleep((long)delay); } /* * Clean up and exit */ (void)mraa_gpio_close(gpio_led); (void)mraa_gpio_close(gpio_button); (void)mraa_aio_close(adc_a0); exit(0); }
int main() { // check that we are running on Galileo or Edison mraa_platform_t platform = mraa_get_platform_type(); if ((platform != MRAA_INTEL_EDISON_FAB_C)) { std::cerr << "Unsupported platform, exiting" << std::endl; return MRAA_ERROR_INVALID_PLATFORM; } // temperature sensor connected to A0 (analog in) upm::GroveLoudness* loudness = new upm::GroveLoudness(0); // LCD connected to the default I2C bus upm::Jhd1313m1* lcd = new upm::Jhd1313m1(0); //word count int word_count = 0; const int LOUDNESS_THRESHOLD = 200; const int BUFFER_SIZE = 1100; // other helper variables uint8_t r, g, b; // resulting LCD backlight color components [0 .. 255] std::stringstream row_1, row_2; // LCD rows // simple error checking if ((loudness == NULL) || (lcd == NULL)) { std::cerr << "Can't create all objects, exiting" << std::endl; return MRAA_ERROR_UNSPECIFIED; } while (true) { bool word_found = false; long average = 0; while(true) { for (int i = 0; i < BUFFER_SIZE; i++) { average += loudness->value(); } average /= BUFFER_SIZE; if (average > LOUDNESS_THRESHOLD) { word_count++; word_found = true; // row_1 << "Word Found! "; // row_2 << "Wordcount " << word_count; //color is someone is talking r = (int)(0); g = (int)(255); b = (int)(0); // apply the calculated result lcd->setColor(r, g, b); } if (average < LOUDNESS_THRESHOLD) { if (word_found == true) word_count++; r = 255; g = 0; b = 0; // apply the calculated result lcd->setColor(r, g, b); } } } return MRAA_SUCCESS; }
/* * main */ int main(int argc, char *argv[]) { // vector with dispense events std::vector<DispenseEvent> dispense_events; mraa::Result response; // check command line arguments if (argc != 2) { std::cerr << "Usage: " << argv[0] << " <sqlite3_events_file> " << std::endl; exit(1); } events_file = argv[1]; #if GALILEO == 1 // check that we are running on Galileo mraa_platform_t platform = mraa_get_platform_type(); if ((platform != MRAA_INTEL_GALILEO_GEN1) && (platform != MRAA_INTEL_GALILEO_GEN2)) { std::cerr << "Unsupported platform, exiting" << std::endl; return MRAA_ERROR_INVALID_PLATFORM; } #endif #if PROTOTYPE == 1 // temperature sensor connected to A0 (analog in) upm::GroveTemp* temp_sensor = new upm::GroveTemp(TEMP_SENSOR_PIN); // Grove kit stepper motor upm::ULN200XA* motor = new upm::ULN200XA(4096, MOTOR_A1_PIN, MOTOR_A2_PIN, MOTOR_B1_PIN, MOTOR_B2_PIN); mraa::Gpio* motor_sense = new mraa::Gpio(MOTOR_SENSE_PIN); if (motor_sense == NULL) { return mraa::ERROR_UNSPECIFIED; } response = motor_sense->dir(mraa::DIR_IN); if (response != mraa::SUCCESS) { mraa::printError(response); return 1; } #else // AM2315 temperature sensor std::cout << "Initializing temperature sensor" << std::endl; upm::AM2315 *temp_sensor = new upm::AM2315(MRAA_OFFSET); temp_sensor->testSensor(); std::cout << "Temperature: " << temp_sensor->getTemperature() << std::endl; // Quadstepper Motor Driver + sense switches mraa::Gpio* motor_enable[NUM_MOTORS]; mraa::Gpio* motor_sense[NUM_MOTORS]; int motor_enable_gpios[] = { MOTOR_ENA1_PIN, MOTOR_ENA2_PIN, MOTOR_ENA3_PIN }; int motor_sense_gpios[] = { MOTOR_SENSE1_PIN, MOTOR_SENSE2_PIN, MOTOR_SENSE3_PIN }; for (int i = 0; i < NUM_MOTORS; i++) { // configure motor enable GPIO motor_enable[i] = new mraa::Gpio(motor_enable_gpios[i]); if (motor_enable[i] == NULL) { return mraa::ERROR_UNSPECIFIED; } response = motor_enable[i]->dir(mraa::DIR_OUT); if (response != mraa::SUCCESS) { mraa::printError(response); return 1; } // disable motor by default response = motor_enable[i]->write(1); // configure motor sense GPIO motor_sense[i] = new mraa::Gpio(motor_sense_gpios[i]); if (motor_sense[i] == NULL) { return mraa::ERROR_UNSPECIFIED; } response = motor_sense[i]->dir(mraa::DIR_IN); if (response != mraa::SUCCESS) { mraa::printError(response); return 1; } #if GALILEO == 1 response = motor_sense[i]->mode(mraa::MODE_PULLUP); if (response != mraa::SUCCESS) { mraa::printError(response); return 1; } #endif } upm::StepMotor* motor = new upm::StepMotor( MOTOR_DIR_PIN, MOTOR_STEP_PIN, 200); #endif // machine open sensor connected to D7 (digital in) mraa::Gpio* machine_open_sensor = new mraa::Gpio(TRAY_SENSE_PIN); if (machine_open_sensor == NULL) { return mraa::ERROR_UNSPECIFIED; } response = machine_open_sensor->dir(mraa::DIR_IN); if (response != mraa::SUCCESS) { mraa::printError(response); return 1; } // Grove Button is used in prototype // it has a built-in pull-down resistor #if PROTOTYPE == 0 && GALILEO == 1 response = machine_open_sensor->mode(mraa::MODE_PULLUP); if (response != mraa::SUCCESS) { mraa::printError(response); return 1; } #endif // red led connected to D2 (digital out) upm::GroveLed* red_led = new upm::GroveLed(RED_LED_PIN); // green led connected to D3 (digital out) upm::GroveLed* green_led = new upm::GroveLed(GREEN_LED_PIN); if (NULL == green_led) { std::cerr << "Unable to initialize the Green LED" << std::endl; return MRAA_ERROR_UNSPECIFIED; } // LCD connected to the default I2C bus upm::Jhd1313m1* lcd = new upm::Jhd1313m1(MRAA_OFFSET); // check for errors if (motor == NULL || red_led == NULL || temp_sensor == NULL || lcd == NULL) { std::cerr << "Unable to create all UPM objects, exiting" << std::endl; return MRAA_ERROR_UNSPECIFIED; } #if PROTOTYPE != 1 for (int i = 0; i < NUM_MOTORS; i++) { if (reset_motor(motor, motor_enable[i], motor_sense[i])) { std::cerr << "Error resetting motor " << i + 1 << std::endl; } } #endif // loop forever int previous_temperature = TEMPERATURE_RANGE_MIN_VAL + 1; for (;;) { // measure temperature #if PROTOTYPE == 1 int temperature = temp_sensor->value(); #else int temperature = temp_sensor->getTemperature(); #endif // avoid temperature glitches if (temperature != 0 && temperature < 150) { previous_temperature = temperature; } else { temperature = previous_temperature; } // monitor the machine for failures monitor_machine(machine_open_sensor, temperature, red_led, green_led, lcd); // get dispense events from the database db_get_dispence_events(dispense_events); // check if any dispense events available while (dispense_events.size() > 0) { // process the first event from the vector #if PROTOTYPE == 1 int result = dispense_product(motor, motor_sense, lcd, dispense_events[0].get_tray()); #else int result = dispense_product_stepper(motor, motor_enable, motor_sense, lcd, dispense_events[0].get_tray()); #endif dispense_events[0].dispensed(result); dispense_events.erase(dispense_events.begin()); } sleep(1); } return 0; }
/** * Get platform type, board must be initialised. * * @return mraa_platform_t Platform type enum */ mraa_platform_t getPlatformType() { return mraa_get_platform_type(); }
int main() { // check that we are running on Galileo or Edison mraa_platform_t platform = mraa_get_platform_type(); if ((platform != MRAA_INTEL_GALILEO_GEN1) && (platform != MRAA_INTEL_GALILEO_GEN2) && (platform != MRAA_INTEL_EDISON_FAB_C)) { std::cerr << "Unsupported platform, exiting" << std::endl; return MRAA_ERROR_INVALID_PLATFORM; } // temperature sensor connected to A0 (analog in) upm::GroveTemp* temp_sensor = new upm::GroveTemp(0); // LCD connected to the default I2C bus upm::Jhd1313m1* lcd = new upm::Jhd1313m1(0); std::stringstream row_1, row_2; upm::GroveRelay* relay = new upm::GroveRelay(4); // simple error checking if ((temp_sensor == NULL) || (lcd == NULL) || (relay == NULL)) { std::cerr << "Can't create all objects, exiting" << std::endl; return MRAA_ERROR_UNSPECIFIED; } // loop forever updating the temperature values every second for (;;) { float temperature = MySensors::load_temperature(0); float humidity = MySensors::load_humidity(1); row_1.str(std::string()); row_2.str(std::string()); row_2 << "Temperature " << std::fixed << std::setprecision(2) <<temperature << "Cº"; row_1 << "Humidity "<< std::fixed << std::setprecision(0) << humidity << "\%"; //write in the LCD lcd->setCursor(0,0); lcd->write(row_1.str()); lcd->setCursor(1,0); lcd->write(row_2.str()); //clear LCD row_1.str(std::string()); row_2.str(std::string()); Check_pump_status(humidity,relay); //Prepare data to upload to Fi-Ware FiWareConnector::Table measures = prepareData(humidity,temperature,relay->isOn()); //Upload data to Fi-Ware FiWareConnector::post_measures(measures); sleep(20); } return MRAA_SUCCESS; }