mbed API for Raspberry Pi boards.

mbedPi

This is an attempt to implement a limited number of mbed APIs for Raspberry Pi single-board computers. The project was inspired by and based on the arduPi library developed for the Arduino by Cooking Hacks .

/media/uploads/hudakz/board01.jpg

Specifications

  • Chip: Broadcom BCM2836 SoC
  • Core architecture: Quad-core ARM Cortex-A7
  • CPU frequency: 900 MHz
  • GPU: Dual Core VideoCore IV® Multimedia Co-Processor
  • Memory: 1GB LPDDR2
  • Operating System: Boots from Micro SD card, running a version of the Linux operating system
  • Power: Micro USB socket 5V, 2A

Connectors

  • Ethernet: 10/100 BaseT Ethernet socket
  • Video Output: HDMI (rev 1.3 & 1.4)
  • Audio Output: 3.5mm jack, HDMI
  • USB: 4 x USB 2.0 Connector
  • GPIO Connector: 40-pin 2.54 mm (100 mil) expansion header: 2x20 strip providing 27 GPIO pins as well as +3.3 V, +5 V and GND supply lines
  • Camera Connector: 15-pin MIPI Camera Serial Interface (CSI-2)
  • JTAG: Not populated
  • Display Connector: Display Serial Interface (DSI) 15 way flat flex cable connector with two data lanes and a clock lane
  • Memory Card Slot: Micro SDIO

GPIO connector pinout

Zoom in /media/uploads/hudakz/mbedpi_pinout02.png

Information

Only the labels printed in blue/white or green/white (i.e. p3, gpio2 ...) must be used in your code. The other labels are given as information (alternate-functions, power pins, ...).


Building programs for the Raspberry Pi with mbedPi

I use Qt Creator for development, however you can use any other IDE available on the Raspberry Pi (e.g. Geany) if you like. For a quick try:

  • Install Qt and the Qt Creator onto your Raspberry Pi. Then create a new "Blinky" Plain non-Qt C++ Project as follows: /media/uploads/hudakz/newproject.png

  • Change the main code as below:

main.cpp

#include "mbedPi.h"

int main()
{
    DigitalOut  myled(p7);

    while(1) {
        myled = 1; // LED is ON
        wait(0.2); // 200 ms
        myled = 0; // LED is OFF
        wait(1.0); // 1 sec
        printf("Blink\r\n");
    }
}


  • Copy the mbedPi.zip file into your project's folder and unzip.
  • Add the mbedPi.h and mbedPi.cpp files to your project by right clicking on the "Blinky" project and then clicking on the "Add Existing Files..." option in the local menu:

    /media/uploads/hudakz/addfiles.png

    /media/uploads/hudakz/addfiles02.png

  • Double click on Blinky.pro to open it for editing and add new libraries by inserting a new line as follows:

    /media/uploads/hudakz/libs.png

  • Compile the project.

  • Connect an LED through a 1k resistor to pin 7 and the ground on the Raspberry Pi GPIO connector.

  • Run the binary as sudo (sudo ./Blinky) and you should see the LED blinking. /media/uploads/hudakz/mbedpi_run.png

  • Press Ctrl+c to stop running the application.
Committer:
hudakz
Date:
Tue Dec 20 12:16:18 2022 +0000
Revision:
2:131555dc6fb7
Parent:
1:1f2d9982fa8c
Mbed API for Raspberry Pi boards equipped with BCM2836 SoC.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
hudakz 1:1f2d9982fa8c 1 //#include "mbed.h"
hudakz 1:1f2d9982fa8c 2 #include "BCM2835.h"
hudakz 1:1f2d9982fa8c 3 #include "Thread.h"
hudakz 1:1f2d9982fa8c 4 #include "ThisThread.h"
hudakz 1:1f2d9982fa8c 5 #include "Peripheral.h"
hudakz 1:1f2d9982fa8c 6
hudakz 1:1f2d9982fa8c 7 struct bcm2835_peripheral bsc_rev1 = { BCM2835_PERI_BASE + 0X205000, 0, 0, 0 };
hudakz 1:1f2d9982fa8c 8 struct bcm2835_peripheral bsc_rev2 = { BCM2835_PERI_BASE + 0X804000, 0, 0, 0 };
hudakz 1:1f2d9982fa8c 9 struct bcm2835_peripheral bsc0;
hudakz 1:1f2d9982fa8c 10 struct bcm2835_peripheral gpio = { BCM2835_PERI_BASE + 0x200000, 0, 0, 0 };
hudakz 1:1f2d9982fa8c 11
hudakz 1:1f2d9982fa8c 12 timeval start_program, end_point;
hudakz 1:1f2d9982fa8c 13
hudakz 1:1f2d9982fa8c 14 off_t bcm2835_peripherals_base = BCM2835_PERI_BASE;
hudakz 1:1f2d9982fa8c 15 size_t bcm2835_peripherals_size = BCM2835_PERI_SIZE;
hudakz 1:1f2d9982fa8c 16 volatile uint32_t* bcm2835_peripherals;
hudakz 1:1f2d9982fa8c 17 volatile uint32_t* bcm2835_pwm = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 18 volatile uint32_t* bcm2835_clk = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 19 volatile uint32_t* bcm2835_bsc1 = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 20 volatile uint32_t* bcm2835_spi0 = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 21 volatile uint32_t* bcm2835_st = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 22
hudakz 1:1f2d9982fa8c 23
hudakz 1:1f2d9982fa8c 24 //Constructor
hudakz 1:1f2d9982fa8c 25 Peripheral::Peripheral()
hudakz 1:1f2d9982fa8c 26 {
hudakz 1:1f2d9982fa8c 27 REV = getBoardRev();
hudakz 1:1f2d9982fa8c 28 if (map_peripheral(&gpio) == -1) {
hudakz 1:1f2d9982fa8c 29 printf("Failed to map the physical GPIO registers into the virtual memory space.\n");
hudakz 1:1f2d9982fa8c 30 }
hudakz 1:1f2d9982fa8c 31
hudakz 1:1f2d9982fa8c 32 memfd = -1;
hudakz 1:1f2d9982fa8c 33
hudakz 1:1f2d9982fa8c 34 // Open the master /dev/memory device
hudakz 1:1f2d9982fa8c 35 if ((memfd = open("/dev/mem", O_RDWR | O_SYNC)) < 0) {
hudakz 1:1f2d9982fa8c 36 fprintf(stderr, "bcm2835_init: Unable to open /dev/mem: %s\n", strerror(errno));
hudakz 1:1f2d9982fa8c 37 exit(1);
hudakz 1:1f2d9982fa8c 38 }
hudakz 1:1f2d9982fa8c 39
hudakz 1:1f2d9982fa8c 40 bcm2835_peripherals = mapmem("gpio", bcm2835_peripherals_size, memfd, bcm2835_peripherals_base);
hudakz 1:1f2d9982fa8c 41 if (bcm2835_peripherals == MAP_FAILED)
hudakz 1:1f2d9982fa8c 42 exit(1);
hudakz 1:1f2d9982fa8c 43
hudakz 1:1f2d9982fa8c 44 /* Now compute the base addresses of various peripherals,
hudakz 1:1f2d9982fa8c 45 // which are at fixed offsets within the mapped peripherals block
hudakz 1:1f2d9982fa8c 46 // Caution: bcm2835_peripherals is uint32_t*, so divide offsets by 4
hudakz 1:1f2d9982fa8c 47 */
hudakz 1:1f2d9982fa8c 48 bcm2835_pwm = bcm2835_peripherals + BCM2835_GPIO_PWM/4;
hudakz 1:1f2d9982fa8c 49 bcm2835_clk = bcm2835_peripherals + BCM2835_CLOCK_BASE/4;
hudakz 1:1f2d9982fa8c 50 bcm2835_spi0 = bcm2835_peripherals + BCM2835_SPI0_BASE/4;
hudakz 1:1f2d9982fa8c 51 bcm2835_bsc1 = bcm2835_peripherals + BCM2835_BSC1_BASE/4; /* I2C */
hudakz 1:1f2d9982fa8c 52 bcm2835_st = bcm2835_peripherals + BCM2835_ST_BASE/4;
hudakz 1:1f2d9982fa8c 53
hudakz 1:1f2d9982fa8c 54 // start timer
hudakz 1:1f2d9982fa8c 55 gettimeofday(&start_program, NULL);
hudakz 1:1f2d9982fa8c 56 }
hudakz 1:1f2d9982fa8c 57
hudakz 1:1f2d9982fa8c 58 //Destructor
hudakz 1:1f2d9982fa8c 59 Peripheral::~Peripheral()
hudakz 1:1f2d9982fa8c 60 {
hudakz 1:1f2d9982fa8c 61 unmap_peripheral(&gpio);
hudakz 1:1f2d9982fa8c 62
hudakz 1:1f2d9982fa8c 63 bcm2835_pwm = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 64 bcm2835_clk = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 65 bcm2835_spi0 = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 66 bcm2835_bsc1 = (uint32_t *)MAP_FAILED;
hudakz 1:1f2d9982fa8c 67 }
hudakz 1:1f2d9982fa8c 68
hudakz 1:1f2d9982fa8c 69 /*******************
hudakz 1:1f2d9982fa8c 70 * Private methods *
hudakz 1:1f2d9982fa8c 71 *******************/
hudakz 1:1f2d9982fa8c 72
hudakz 1:1f2d9982fa8c 73 // Exposes the physical address defined in the passed structure using mmap on /dev/mem
hudakz 1:1f2d9982fa8c 74 int Peripheral::map_peripheral(struct bcm2835_peripheral* p)
hudakz 1:1f2d9982fa8c 75 {
hudakz 1:1f2d9982fa8c 76 // Open /dev/mem
hudakz 1:1f2d9982fa8c 77
hudakz 1:1f2d9982fa8c 78 if ((p->mem_fd = open("/dev/mem", O_RDWR | O_SYNC)) < 0) {
hudakz 1:1f2d9982fa8c 79 printf("Failed to open /dev/mem, try checking permissions.\n");
hudakz 1:1f2d9982fa8c 80 return -1;
hudakz 1:1f2d9982fa8c 81 }
hudakz 1:1f2d9982fa8c 82
hudakz 1:1f2d9982fa8c 83 p->map = mmap
hudakz 1:1f2d9982fa8c 84 (
hudakz 1:1f2d9982fa8c 85 NULL,
hudakz 1:1f2d9982fa8c 86 BLOCK_SIZE,
hudakz 1:1f2d9982fa8c 87 PROT_READ | PROT_WRITE,
hudakz 1:1f2d9982fa8c 88 MAP_SHARED,
hudakz 1:1f2d9982fa8c 89 p->mem_fd, // File descriptor to physical memory virtual file '/dev/mem'
hudakz 1:1f2d9982fa8c 90 p->addr_p // Address in physical map that we want this memory block to expose
hudakz 1:1f2d9982fa8c 91 );
hudakz 1:1f2d9982fa8c 92
hudakz 1:1f2d9982fa8c 93 if (p->map == MAP_FAILED) {
hudakz 1:1f2d9982fa8c 94 perror("mmap");
hudakz 1:1f2d9982fa8c 95 return -1;
hudakz 1:1f2d9982fa8c 96 }
hudakz 1:1f2d9982fa8c 97
hudakz 1:1f2d9982fa8c 98 p->addr = (volatile unsigned int*)p->map;
hudakz 1:1f2d9982fa8c 99
hudakz 1:1f2d9982fa8c 100 return 0;
hudakz 1:1f2d9982fa8c 101 }
hudakz 1:1f2d9982fa8c 102
hudakz 1:1f2d9982fa8c 103 /**
hudakz 1:1f2d9982fa8c 104 * @brief
hudakz 1:1f2d9982fa8c 105 * @note
hudakz 1:1f2d9982fa8c 106 * @param
hudakz 1:1f2d9982fa8c 107 * @retval
hudakz 1:1f2d9982fa8c 108 */
hudakz 1:1f2d9982fa8c 109 void Peripheral::unmap_peripheral(struct bcm2835_peripheral* p)
hudakz 1:1f2d9982fa8c 110 {
hudakz 1:1f2d9982fa8c 111 munmap(p->map, BLOCK_SIZE);
hudakz 1:1f2d9982fa8c 112 unistd::close(p->mem_fd);
hudakz 1:1f2d9982fa8c 113 }
hudakz 1:1f2d9982fa8c 114
hudakz 1:1f2d9982fa8c 115 //
hudakz 1:1f2d9982fa8c 116 // Low level convenience functions
hudakz 1:1f2d9982fa8c 117 //
hudakz 1:1f2d9982fa8c 118
hudakz 1:1f2d9982fa8c 119 /**
hudakz 1:1f2d9982fa8c 120 * @brief
hudakz 1:1f2d9982fa8c 121 * @note
hudakz 1:1f2d9982fa8c 122 * @param
hudakz 1:1f2d9982fa8c 123 * @retval
hudakz 1:1f2d9982fa8c 124 */
hudakz 1:1f2d9982fa8c 125 uint32_t* mapmem(const char* msg, size_t size, int fd, off_t off)
hudakz 1:1f2d9982fa8c 126 {
hudakz 1:1f2d9982fa8c 127 uint32_t* map = (uint32_t*)mmap(NULL, size, (PROT_READ | PROT_WRITE), MAP_SHARED, fd, off);
hudakz 1:1f2d9982fa8c 128 if (MAP_FAILED == map)
hudakz 1:1f2d9982fa8c 129 fprintf(stderr, "bcm2835_init: %s mmap failed: %s\n", msg, strerror(errno));
hudakz 1:1f2d9982fa8c 130 return map;
hudakz 1:1f2d9982fa8c 131 }
hudakz 1:1f2d9982fa8c 132
hudakz 1:1f2d9982fa8c 133 // safe read from peripheral
hudakz 1:1f2d9982fa8c 134 uint32_t bcm2835_peri_read(volatile uint32_t* paddr)
hudakz 1:1f2d9982fa8c 135 {
hudakz 1:1f2d9982fa8c 136 uint32_t ret = *paddr;
hudakz 1:1f2d9982fa8c 137 ret = *paddr;
hudakz 1:1f2d9982fa8c 138 return ret;
hudakz 1:1f2d9982fa8c 139 }
hudakz 1:1f2d9982fa8c 140
hudakz 1:1f2d9982fa8c 141 // read from peripheral without the read barrier
hudakz 1:1f2d9982fa8c 142 uint32_t bcm2835_peri_read_nb(volatile uint32_t* paddr)
hudakz 1:1f2d9982fa8c 143 {
hudakz 1:1f2d9982fa8c 144 return *paddr;
hudakz 1:1f2d9982fa8c 145 }
hudakz 1:1f2d9982fa8c 146
hudakz 1:1f2d9982fa8c 147 // safe write to peripheral
hudakz 1:1f2d9982fa8c 148 void bcm2835_peri_write(volatile uint32_t* paddr, uint32_t value)
hudakz 1:1f2d9982fa8c 149 {
hudakz 1:1f2d9982fa8c 150 *paddr = value;
hudakz 1:1f2d9982fa8c 151 *paddr = value;
hudakz 1:1f2d9982fa8c 152 }
hudakz 1:1f2d9982fa8c 153
hudakz 1:1f2d9982fa8c 154 // write to peripheral without the write barrier
hudakz 1:1f2d9982fa8c 155 void bcm2835_peri_write_nb(volatile uint32_t* paddr, uint32_t value)
hudakz 1:1f2d9982fa8c 156 {
hudakz 1:1f2d9982fa8c 157 *paddr = value;
hudakz 1:1f2d9982fa8c 158 }
hudakz 1:1f2d9982fa8c 159
hudakz 1:1f2d9982fa8c 160 // Set/clear only the bits in value covered by the mask
hudakz 1:1f2d9982fa8c 161 void bcm2835_peri_set_bits(volatile uint32_t* paddr, uint32_t value, uint32_t mask)
hudakz 1:1f2d9982fa8c 162 {
hudakz 1:1f2d9982fa8c 163 uint32_t v = bcm2835_peri_read(paddr);
hudakz 1:1f2d9982fa8c 164 v = (v &~mask) | (value & mask);
hudakz 1:1f2d9982fa8c 165 bcm2835_peri_write(paddr, v);
hudakz 1:1f2d9982fa8c 166 }
hudakz 1:1f2d9982fa8c 167
hudakz 1:1f2d9982fa8c 168 /**
hudakz 1:1f2d9982fa8c 169 * @brief
hudakz 1:1f2d9982fa8c 170 * @note
hudakz 1:1f2d9982fa8c 171 * @param
hudakz 1:1f2d9982fa8c 172 * @retval
hudakz 1:1f2d9982fa8c 173 */
hudakz 1:1f2d9982fa8c 174 int getBoardRev()
hudakz 1:1f2d9982fa8c 175 {
hudakz 1:1f2d9982fa8c 176 FILE* cpu_info;
hudakz 1:1f2d9982fa8c 177 char line[120];
hudakz 1:1f2d9982fa8c 178 char* c, finalChar;
hudakz 1:1f2d9982fa8c 179 //static int rev = 0;
hudakz 1:1f2d9982fa8c 180
hudakz 1:1f2d9982fa8c 181 if (REV != 0)
hudakz 1:1f2d9982fa8c 182 return REV;
hudakz 1:1f2d9982fa8c 183
hudakz 1:1f2d9982fa8c 184 if ((cpu_info = fopen("/proc/cpuinfo", "r")) == NULL) {
hudakz 1:1f2d9982fa8c 185 fprintf(stderr, "Unable to open /proc/cpuinfo. Cannot determine board reivision.\n");
hudakz 1:1f2d9982fa8c 186 exit(1);
hudakz 1:1f2d9982fa8c 187 }
hudakz 1:1f2d9982fa8c 188
hudakz 1:1f2d9982fa8c 189 while (fgets(line, 120, cpu_info) != NULL) {
hudakz 1:1f2d9982fa8c 190 if (strncmp(line, "Revision", 8) == 0)
hudakz 1:1f2d9982fa8c 191 break;
hudakz 1:1f2d9982fa8c 192 }
hudakz 1:1f2d9982fa8c 193
hudakz 1:1f2d9982fa8c 194 fclose(cpu_info);
hudakz 1:1f2d9982fa8c 195
hudakz 1:1f2d9982fa8c 196 if (line == NULL) {
hudakz 1:1f2d9982fa8c 197 fprintf(stderr, "Unable to determine board revision from /proc/cpuinfo.\n");
hudakz 1:1f2d9982fa8c 198 exit(1);
hudakz 1:1f2d9982fa8c 199 }
hudakz 1:1f2d9982fa8c 200
hudakz 1:1f2d9982fa8c 201 for (c = line; *c; ++c)
hudakz 1:1f2d9982fa8c 202 if (isdigit(*c))
hudakz 1:1f2d9982fa8c 203 break;
hudakz 1:1f2d9982fa8c 204
hudakz 1:1f2d9982fa8c 205 if (!isdigit(*c)) {
hudakz 1:1f2d9982fa8c 206 fprintf(stderr, "Unable to determine board revision from /proc/cpuinfo\n");
hudakz 1:1f2d9982fa8c 207 fprintf(stderr, " (Info not found in: %s\n", line);
hudakz 1:1f2d9982fa8c 208 exit(1);
hudakz 1:1f2d9982fa8c 209 }
hudakz 1:1f2d9982fa8c 210
hudakz 1:1f2d9982fa8c 211 finalChar = c[strlen(c) - 2];
hudakz 1:1f2d9982fa8c 212
hudakz 1:1f2d9982fa8c 213 if ((finalChar == '2') || (finalChar == '3')) {
hudakz 1:1f2d9982fa8c 214 bsc0 = bsc_rev1;
hudakz 1:1f2d9982fa8c 215 return 1;
hudakz 1:1f2d9982fa8c 216 }
hudakz 1:1f2d9982fa8c 217 else {
hudakz 1:1f2d9982fa8c 218 bsc0 = bsc_rev2;
hudakz 1:1f2d9982fa8c 219 return 2;
hudakz 1:1f2d9982fa8c 220 }
hudakz 1:1f2d9982fa8c 221 }
hudakz 1:1f2d9982fa8c 222
hudakz 1:1f2d9982fa8c 223 /**
hudakz 1:1f2d9982fa8c 224 * @brief
hudakz 1:1f2d9982fa8c 225 * @note
hudakz 1:1f2d9982fa8c 226 * @param
hudakz 1:1f2d9982fa8c 227 * @retval
hudakz 1:1f2d9982fa8c 228 */
hudakz 1:1f2d9982fa8c 229 void attachInterrupt(PinName p, void (*f) (), Digivalue m)
hudakz 1:1f2d9982fa8c 230 {
hudakz 1:1f2d9982fa8c 231 int GPIOPin = p;
hudakz 1:1f2d9982fa8c 232 pthread_t* threadId = getThreadIdFromPin(p);
hudakz 1:1f2d9982fa8c 233 struct ThreadArg* threadArgs = (ThreadArg*)malloc(sizeof(ThreadArg));
hudakz 1:1f2d9982fa8c 234 threadArgs->func = f;
hudakz 1:1f2d9982fa8c 235 threadArgs->pin = GPIOPin;
hudakz 1:1f2d9982fa8c 236
hudakz 1:1f2d9982fa8c 237 //Export pin for interrupt
hudakz 1:1f2d9982fa8c 238 FILE* fp = fopen("/sys/class/gpio/export", "w");
hudakz 1:1f2d9982fa8c 239 if (fp == NULL) {
hudakz 1:1f2d9982fa8c 240 fprintf(stderr, "Unable to export pin %d for interrupt\n", p);
hudakz 1:1f2d9982fa8c 241 exit(1);
hudakz 1:1f2d9982fa8c 242 }
hudakz 1:1f2d9982fa8c 243 else {
hudakz 1:1f2d9982fa8c 244 fprintf(fp, "%d", GPIOPin);
hudakz 1:1f2d9982fa8c 245 }
hudakz 1:1f2d9982fa8c 246
hudakz 1:1f2d9982fa8c 247 fclose(fp);
hudakz 1:1f2d9982fa8c 248
hudakz 1:1f2d9982fa8c 249 //The system to create the file /sys/class/gpio/gpio<GPIO number>
hudakz 1:1f2d9982fa8c 250 //So we wait a bit
hudakz 1:1f2d9982fa8c 251 ThisThread::sleep_for_ms(1);
hudakz 1:1f2d9982fa8c 252
hudakz 1:1f2d9982fa8c 253 char* interruptFile = NULL;
hudakz 1:1f2d9982fa8c 254 asprintf(&interruptFile, "/sys/class/gpio/gpio%d/edge", GPIOPin);
hudakz 1:1f2d9982fa8c 255
hudakz 1:1f2d9982fa8c 256 //Set detection condition
hudakz 1:1f2d9982fa8c 257 fp = fopen(interruptFile, "w");
hudakz 1:1f2d9982fa8c 258 if (fp == NULL) {
hudakz 1:1f2d9982fa8c 259 fprintf(stderr, "Unable to set detection type on pin %d\n", p);
hudakz 1:1f2d9982fa8c 260 exit(1);
hudakz 1:1f2d9982fa8c 261 }
hudakz 1:1f2d9982fa8c 262 else {
hudakz 1:1f2d9982fa8c 263 switch (m) {
hudakz 1:1f2d9982fa8c 264 case RISING:
hudakz 1:1f2d9982fa8c 265 fprintf(fp, "rising");
hudakz 1:1f2d9982fa8c 266 break;
hudakz 1:1f2d9982fa8c 267
hudakz 1:1f2d9982fa8c 268 case FALLING:
hudakz 1:1f2d9982fa8c 269 fprintf(fp, "falling");
hudakz 1:1f2d9982fa8c 270 break;
hudakz 1:1f2d9982fa8c 271
hudakz 1:1f2d9982fa8c 272 default:
hudakz 1:1f2d9982fa8c 273 fprintf(fp, "both");
hudakz 1:1f2d9982fa8c 274 break;
hudakz 1:1f2d9982fa8c 275 }
hudakz 1:1f2d9982fa8c 276 }
hudakz 1:1f2d9982fa8c 277
hudakz 1:1f2d9982fa8c 278 fclose(fp);
hudakz 1:1f2d9982fa8c 279
hudakz 1:1f2d9982fa8c 280 if (*threadId == 0) {
hudakz 1:1f2d9982fa8c 281
hudakz 1:1f2d9982fa8c 282 //Create a thread passing the pin and function
hudakz 1:1f2d9982fa8c 283 pthread_create(threadId, NULL, threadFunction, (void*)threadArgs);
hudakz 1:1f2d9982fa8c 284 }
hudakz 1:1f2d9982fa8c 285 else {
hudakz 1:1f2d9982fa8c 286
hudakz 1:1f2d9982fa8c 287 //First cancel the existing thread for that pin
hudakz 1:1f2d9982fa8c 288 pthread_cancel(*threadId);
hudakz 1:1f2d9982fa8c 289
hudakz 1:1f2d9982fa8c 290 //Create a thread passing the pin, function and mode
hudakz 1:1f2d9982fa8c 291 pthread_create(threadId, NULL, threadFunction, (void*)threadArgs);
hudakz 1:1f2d9982fa8c 292 }
hudakz 1:1f2d9982fa8c 293 }
hudakz 1:1f2d9982fa8c 294
hudakz 1:1f2d9982fa8c 295 /**
hudakz 1:1f2d9982fa8c 296 * @brief
hudakz 1:1f2d9982fa8c 297 * @note
hudakz 1:1f2d9982fa8c 298 * @param
hudakz 1:1f2d9982fa8c 299 * @retval
hudakz 1:1f2d9982fa8c 300 */
hudakz 1:1f2d9982fa8c 301 void detachInterrupt(PinName p)
hudakz 1:1f2d9982fa8c 302 {
hudakz 1:1f2d9982fa8c 303 int GPIOPin = p;
hudakz 1:1f2d9982fa8c 304
hudakz 1:1f2d9982fa8c 305 FILE* fp = fopen("/sys/class/gpio/unexport", "w");
hudakz 1:1f2d9982fa8c 306 if (fp == NULL) {
hudakz 1:1f2d9982fa8c 307 fprintf(stderr, "Unable to unexport pin %d for interrupt\n", p);
hudakz 1:1f2d9982fa8c 308 exit(1);
hudakz 1:1f2d9982fa8c 309 }
hudakz 1:1f2d9982fa8c 310 else {
hudakz 1:1f2d9982fa8c 311 fprintf(fp, "%d", GPIOPin);
hudakz 1:1f2d9982fa8c 312 }
hudakz 1:1f2d9982fa8c 313
hudakz 1:1f2d9982fa8c 314 fclose(fp);
hudakz 1:1f2d9982fa8c 315
hudakz 1:1f2d9982fa8c 316 pthread_t* threadId = getThreadIdFromPin(p);
hudakz 1:1f2d9982fa8c 317 pthread_cancel(*threadId);
hudakz 1:1f2d9982fa8c 318 }
hudakz 1:1f2d9982fa8c 319
hudakz 1:1f2d9982fa8c 320 Peripheral peripheral = Peripheral();
hudakz 1:1f2d9982fa8c 321
hudakz 1:1f2d9982fa8c 322