int main(int argc, char **argv) { int g,rep, i; // Set up gpi pointer for direct register access wiringPiSetupGpio (); setup_io(); for (i = 0; i < 28; i++) { INP_GPIO(i); printf("%d", GET_GPIO(i)); } printf("\n"); //exit(0); OUT_GPIO(INT); GPIO_SET(INT); OUT_GPIO(NMI); GPIO_SET(NMI); OUT_GPIO(CLK); GPIO_SET(CLK); OUT_GPIO(WAIT); GPIO_SET(WAIT); OUT_GPIO(BUSRQ); GPIO_SET(BUSRQ); OUT_GPIO(RESET); GPIO_SET(RESET); OUT_GPIO(SI); GPIO_SET(SI); OUT_GPIO(CP); GPIO_SET(CP); OUT_GPIO(CS_16); GPIO_SET(CS_16); OUT_GPIO(M); ResetSimulationVars(); WriteControlPins(); DoReset(); while(1) loop(); }
void initMotor(OUT_MOTOR* motor, char * n1, char* n2, char * file, int pinPWM, int pinIN1, int pinIN2, int pinSTBY, double vitesse){ motor->cap = fopen(file,"r"); motor->pinSTBY = pinSTBY; motor->pinIN1 = pinIN1; motor->pinIN2= pinIN2; motor->pinPWM=pinPWM; INP_GPIO(pinIN1); INP_GPIO(pinIN2); INP_GPIO(pinSTBY); INP_GPIO(pinPWM); OUT_GPIO(pinIN1); OUT_GPIO(pinIN2); OUT_GPIO(pinSTBY); OUT_GPIO(pinPWM); GPIO_SET = 1 << pinSTBY; GPIO_CLR = 1 << pinIN1 | 1 << pinIN2 | 1<< pinPWM; motor->vitesse=vitesse; int err = rt_task_create(&(motor->task),n1, TASK_STKSZ, TASK_PRIO, TASK_MODE); err |= rt_alarm_create(&(motor->alarm),n2); err |= rt_task_set_periodic(&(motor->task), TM_NOW, PERIODE_MOTOR); if (!err) { rt_task_start(&(motor->task),&taskMotor,motor); } }
int main(int argc, char **argv) { //int rep; // Set up gpi pointer for direct register access setup_io(); // GPIO23 - NTX2 enable INP_GPIO(23); // must use INP_GPIO before we can use OUT_GPIO OUT_GPIO(23); // GPIO18 - NTX2 Data INP_GPIO(18); // must use INP_GPIO before we can use OUT_GPIO OUT_GPIO(18); GPIO_SET = 1<<23; char send[]="I'm growing a beard\n"; //for (rep=0; rep<8; rep++) { int i; for (i=0; i<strlen(send); i++){ domex_txbyte(send[i]); } //} GPIO_CLR = 1<<23; return 0; }
static int bcm2835gpio_init(void) { bitbang_interface = &bcm2835gpio_bitbang; if (!is_gpio_valid(tdo_gpio) || !is_gpio_valid(tdi_gpio) || !is_gpio_valid(tck_gpio) || !is_gpio_valid(tms_gpio) || (trst_gpio != -1 && !is_gpio_valid(trst_gpio)) || (srst_gpio != -1 && !is_gpio_valid(srst_gpio))) return ERROR_JTAG_INIT_FAILED; dev_mem_fd = open("/dev/mem", O_RDWR | O_SYNC); if (dev_mem_fd < 0) { perror("open"); return ERROR_JTAG_INIT_FAILED; } pio_base = mmap(NULL, sysconf(_SC_PAGE_SIZE), PROT_READ | PROT_WRITE, MAP_SHARED, dev_mem_fd, BCM2835_GPIO_BASE); if (pio_base == MAP_FAILED) { perror("mmap"); close(dev_mem_fd); return ERROR_JTAG_INIT_FAILED; } tdo_gpio_mode = MODE_GPIO(tdo_gpio); tdi_gpio_mode = MODE_GPIO(tdi_gpio); tck_gpio_mode = MODE_GPIO(tck_gpio); tms_gpio_mode = MODE_GPIO(tms_gpio); /* * Configure TDO as an input, and TDI, TCK, TMS, TRST, SRST * as outputs. Drive TDI and TCK low, and TMS/TRST/SRST high. */ INP_GPIO(tdo_gpio); GPIO_CLR = 1<<tdi_gpio | 1<<tck_gpio; GPIO_SET = 1<<tms_gpio; OUT_GPIO(tdi_gpio); OUT_GPIO(tck_gpio); OUT_GPIO(tms_gpio); if (trst_gpio != -1) { trst_gpio_mode = MODE_GPIO(trst_gpio); GPIO_SET = 1 << trst_gpio; OUT_GPIO(trst_gpio); } if (srst_gpio != -1) { srst_gpio_mode = MODE_GPIO(srst_gpio); GPIO_SET = 1 << srst_gpio; OUT_GPIO(srst_gpio); } LOG_DEBUG("saved pinmux settings: tck %d tms %d tdi %d " "tdo %d trst %d srst %d", tck_gpio_mode, tms_gpio_mode, tdi_gpio_mode, tdo_gpio_mode, trst_gpio_mode, srst_gpio_mode); return ERROR_OK; }
// Initialize pins/SPI for output static PyObject *begin(DotStarObject *self) { if(self->dataPin == 0xFF) { // Use hardware SPI if((self->fd = open("/dev/spidev0.0", O_RDWR)) < 0) { printf("Can't open /dev/spidev0.0 (try 'sudo')\n"); return NULL; } uint8_t mode = SPI_MODE_0 | SPI_NO_CS; ioctl(self->fd, SPI_IOC_WR_MODE, &mode); // The actual data rate may be less than requested. // Hardware SPI speed is a function of the system core // frequency and the smallest power-of-two prescaler // that will not exceed the requested rate. // e.g. 8 MHz request: 250 MHz / 32 = 7.8125 MHz. ioctl(self->fd, SPI_IOC_WR_MAX_SPEED_HZ, self->bitrate); xfer[0].tx_buf = (unsigned long)header; xfer[2].tx_buf = (unsigned long)footer; xfer[0].speed_hz = xfer[1].speed_hz = xfer[2].speed_hz = self->bitrate; } else { // Use bitbang "soft" SPI (any 2 pins) if(gpio == NULL) { // First time accessing GPIO? int fd; if((fd = open("/dev/mem", O_RDWR | O_SYNC)) < 0) { printf("Can't open /dev/mem (try 'sudo')\n"); return NULL; } isPi2 = (boardType() == 2); gpio = (volatile unsigned *)mmap( // Memory-map I/O NULL, // Any adddress will do BLOCK_SIZE, // Mapped block length PROT_READ|PROT_WRITE, // Enable read+write MAP_SHARED, // Shared w/other processes fd, // File to map isPi2 ? PI2_GPIO_BASE : // -> GPIO registers PI1_GPIO_BASE); close(fd); // Not needed after mmap() if(gpio == MAP_FAILED) { err("Can't mmap()"); return NULL; } gpioSet = &gpio[7]; gpioClr = &gpio[10]; } self->dataMask = 1 << self->dataPin; self->clockMask = 1 << self->clockPin; // Set 2 pins as outputs. Must use INP before OUT. INP_GPIO(self->dataPin); OUT_GPIO(self->dataPin); INP_GPIO(self->clockPin); OUT_GPIO(self->clockPin); *gpioClr = self->dataMask | self->clockMask; // data+clock LOW } Py_INCREF(Py_None); return Py_None; }
void init(uint8_t dataPin, uint8_t clockPin) { setup_io(); INP_GPIO(dataPin); // must use INP_GPIO before we can use OUT_GPIO OUT_GPIO(dataPin); INP_GPIO(clockPin); // must use INP_GPIO before we can use OUT_GPIO OUT_GPIO(clockPin); }
void userApp1(void * args) { int n_pin; // set all the seg not to illume for (n_pin = 0; n_pin < 8; ++n_pin){ INP_GPIO(pin[n_pin]); OUT_GPIO(pin[n_pin]); digitalWrite(pin[n_pin], HIGH); } // set all the node not to off for(n_pin = 0; n_pin < 4; ++n_pin){ INP_GPIO(node[n_pin]); OUT_GPIO(node[n_pin]); digitalWrite(node[n_pin], LOW); } INP_GPIO(16); OUT_GPIO(16); int i_node = 0; int disp_buffer[4] = {5, 0, 5, 0}; int disp_num = 0; int last_dht11_dat0 = dht11_dat[0], last_dht11_dat2 = dht11_dat[2]; int i, update_flag; while(1) { if(last_dht11_dat0 != dht11_dat[0] || last_dht11_dat2 != dht11_dat[2]){ disp_buffer[1] = dht11_dat[0]%10; disp_buffer[0] = dht11_dat[0]/10; disp_buffer[3] = dht11_dat[2]%10; disp_buffer[2] = dht11_dat[2]/10; } last_dht11_dat0 = dht11_dat[0]; last_dht11_dat2 = dht11_dat[2]; digitalWrite(node[i_node], LOW); i_node = (i_node+1) % 4; disp_num = disp_buffer[i_node]; for(n_pin = 0; n_pin < 8; ++n_pin){ digitalWrite(pin[n_pin], digit[disp_num][n_pin]); } digitalWrite(node[i_node], HIGH); //wtf_delay(100); OSTimeDly(1); } }
void setup_shiftreg() { // set SER to output INP_GPIO(SER); OUT_GPIO(SER); // set SCLK to output INP_GPIO(SCLK); OUT_GPIO(SCLK); // set RCLK to output INP_GPIO(RCLK); OUT_GPIO(RCLK); }
int main(int argc, char **argv) { #ifdef DEMO_ENABLED int g,rep; #endif /* Set up gpi pointer for direct register access */ setup_io(); #ifndef DEMO_ENABLED /* Set GPIO pin 4 to output */ INP_GPIO(pin); OUT_GPIO(pin); #else /* Set all exposed GPIO pins to output */ for (g = 0; g <= 32; g++) { if( ((1<<g) & 0x3e6cf93) != 0) { INP_GPIO(g); OUT_GPIO(g); } } GPIO_CLR = 0x3e6cf93; //clear all output pins #endif #ifdef DEMO_ENABLED while (1) { for (rep = 0; rep < 14; rep++) { GPIO_SET = 1<<pins[rep]; printf("Set pin: %d\n", pins[rep]); sleep(1); GPIO_CLR = 1<<pins[rep]; printf("Clear pin: %d\n", pins[rep]); sleep(1); } } #else while (1) { GPIO_SET = 1<<pin; printf("Set pin: %d\n", pin); sleep(1); GPIO_CLR = 1<<pin; printf("Clear pin: %d\n", pin); sleep(1); } #endif return 0; }
int main() { int g,rep; setup_io(); /*Direct Register access*/ #if 0 /*Set gpio 7..11 to outpu mode*/ for(g=7; g <= 18; g++) { INP_GPIO(g); OUT_GPIO(g); } #endif INP_GPIO(17); OUT_GPIO(17); while(1) { GPIO_SET = 1 << 17; //delay(500); sleep(1); GPIO_CLR = 1 << 17; //delay(500); sleep(1); } #if 0 for (rep=0; rep=10; rep++) { for(g=7; g <= 11; g++) { GPIO_SET = 1 << g; sleep(1); } for(g=7; g<= 11; g++) { GPIO_CLR = 1 << g; sleep(1); } } #endif }
int rpi_gpio_open(struct rtdm_dev_context *context, rtdm_user_info_t *user_info, int oflags) { struct rpi_gpio_context *ctx; ctx = (struct rpi_gpio_context *) context->dev_private; ctx->gpio_addr = virt_addr; ctx->gpio_rt = gpio_rt; ctx->gpio_nrt = gpio_nrt; OUT_GPIO(ctx->gpio_addr, ctx->gpio_rt); OUT_GPIO(ctx->gpio_addr, ctx->gpio_nrt); return 0; }
/** * init_module() - This function is called when the module is loaded * * Return: On succes the function retuns a 0 (SUCCES). Otherwise a * negative number is returned. */ int init_module(void) { Major = register_chrdev(0, DEVICE_NAME, &fops); if (Major < 0) { printk(KERN_ALERT "Registering char device failed with %d\n", Major); return Major; } printk(KERN_INFO "I was assigned major number %d. To talk to\n", Major); printk(KERN_INFO "the driver, create a device file with\n"); printk(KERN_INFO "'mknod /dev/%s c %d 0'.\n", DEVICE_NAME, Major); printk(KERN_INFO "Try various minor numbers. Try to cat and echo to\n"); printk(KERN_INFO "the device file.\n"); printk(KERN_INFO "Remove the device file and module when done.\n"); // Map GPIO gpio.map = ioremap(GPIO_BASE, 1); //Gives a pointer to the first GPIO register gpio.addr = (volatile unsigned int *)gpio.map; // Set pin directions for the LED INP_GPIO(GPIO_LED); OUT_GPIO(GPIO_LED); return SUCCESS; }
// // Configure GPIOs as input or output // void gpioSetPin(uint8_t pin, uint8_t dir) { // Set pin number to given direction INP_GPIO(pin); // Must make pin an input first, even for output if (dir == GPIO_OUTPUT) OUT_GPIO(pin); }
int main() { if(init_gpio() == -1) { printf("Failed to map the physical GPIO registers into the virtual memory space.\n"); return (-1); } printf("Helloblink is started with GIOP%d at pin number 8.\n", LED_PIN); // Define gpio 4 (LED) as output INP_GPIO(LED_PIN); OUT_GPIO(LED_PIN); while(1) { GPIO_SET(LED_PIN); usleep(100 * 1000); GPIO_CLR(LED_PIN); usleep(100 * 1000); } return 0; }
bool HWAbstraction::setupIO() { int memFd; /* open /dev/mem */ if ((memFd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) { printf("can't open /dev/mem \n"); return false; } /* mmap GPIO */ m_gpioMap = mmap( NULL, //Any adddress in our space will do BLOCK_SIZE, //Map length PROT_READ|PROT_WRITE,// Enable reading & writting to mapped memory MAP_SHARED, //Shared with other processes memFd, //File to map GPIO_BASE //Offset to GPIO peripheral ); close(memFd); //No need to keep mem_fd open after mmap if (m_gpioMap == MAP_FAILED) { printf("mmap error %p\n", m_gpioMap);//errno also set! return false; } // Always use volatile pointer! m_gpio = (volatile unsigned *)m_gpioMap; INP_GPIO(25); OUT_GPIO(25); return true; } // setup_io
int main() { int ch; if (map_peripheral(&gpio) == -1) { printf("Failed to map the physical GPIO registers into the virtual memory space.\n"); return -1; } // Define pin as output INP_GPIO(PIN); OUT_GPIO(PIN); BIT1(); while((ch = getchar()) != EOF) { short bit; usleep(4000); BIT0(); // start usleep(BITLEN); for (bit = 1; bit != 0x100; bit <<= 1) { if (bit & ch) BIT1(); else BIT0(); usleep(BITLEN); } BIT1(); // stop usleep(BITLEN); } return 0; }
inline void pinMode(int g, int dir) { if (dir == OUTPUT) OUT_GPIO(g); else INP_GPIO(g); }
void WriteByte(unsigned char value) { unsigned char Mask=1; int loop; for(loop=0;loop<8;loop++) { INP_GPIO(DS_PIN); OUT_GPIO(DS_PIN); GPIO_CLR= 1 <<DS_PIN; if((value & Mask)!=0) { DELAY1US INP_GPIO(DS_PIN); DelayMicrosecondsNoSleep(60); } else { DelayMicrosecondsNoSleep(60); INP_GPIO(DS_PIN); DelayMicrosecondsNoSleep(1); } Mask*=2; DelayMicrosecondsNoSleep(60); } usleep(100); }
unsigned char ReadByte(void) { unsigned char Mask=1; int loop; unsigned char data=0; int loop2; for(loop=0;loop<8;loop++) { // set output INP_GPIO(DS_PIN); OUT_GPIO(DS_PIN); // PIN LOW GPIO_CLR= 1<<DS_PIN; DELAY1US // set input INP_GPIO(DS_PIN); // Wait 2 us DelayMicrosecondsNoSleep(2); if(GPIO_READ(DS_PIN)!=0) data |= Mask; Mask*=2; DelayMicrosecondsNoSleep(60); } return data; }
int buzzer_main(int argc, const char* argv[]) { if(map_peripheral(&g_gpio) == -1) { printf("Failed to map the physical GPIO registers into the virtual memory space.\n"); return -1; } s_pin = 4; INP_GPIO(s_pin); OUT_GPIO(s_pin); size_t len = 64; char* line = (char*)malloc(len); int fre = 0; int elapsed = 0; while (getline(&line, &len, stdin) != -1) { int r = sscanf(line, "%d %d\n", &fre, &elapsed); if (r == 2) { if (fre < 20) { // no sound usleep(elapsed*1000); } else { playSound(fre, elapsed); } } else { fprintf(stderr, "skip, invalid line: %s", line); } } printf("sound count = %lld, high = %lld, low = %lld\n", s_count, s_high, s_low); free(line); return 0; }
int gpio_direction_output(unsigned gpio, int value) { INP_GPIO(gpio); OUT_GPIO(gpio); gpio_set_value(gpio, value); return 0; }
int main(int argc, char *argv[]) { int g, rep; // Setup the gpio pointer setup_io(); // Swtich GPIOs 7 though 11 to output mode for (g = 5; g <= 6; g++) { INP_GPIO(g); OUT_GPIO(g); GPIO_CLR = 1 << g; // SET it LOW } // Toggle the GPIOs for (rep = 0; rep < 5; rep++) { printf("Repetition: %i\n", rep); for (g = 5; g <= 6; g++) { GPIO_SET = 1 << g; printf(" HIGH: %i\n", g); // sleep(1); usleep(500000); GPIO_CLR = 1 << g; printf(" LOW: %i\n", g); // sleep(1); usleep(500000); } } // Ran file return 0; }
int main() { int value; if(map_peripheral(&gpio) == -1) { printf("Failed to map the physical GPIO registers into the virtual memory space.\n"); return -1; } // Define pin 17 as output INP_GPIO(2); OUT_GPIO(17); while(1) { // Toggle pin 17 (blink a led!) GPIO_SET = 1 << 17; sleep(1); value = GPIO_READ(2); while(!value) { // delay(20); value = GPIO_READ(2); } GPIO_CLR = 1 << 17; sleep(1); } return 0; }
JNIEXPORT jboolean JNICALL Java_javaforce_pi_GPIO_configOutput (JNIEnv *env, jclass obj, jint bit) { INP_GPIO(bit); //Always use INP_GPIO before OUT_GPIO -- why??? OUT_GPIO(bit); return JNI_TRUE; }
int initGPIO() { // Map the GPIO and Aux memory mGPIO = mapMem ( GPIO_BASE, 0x1000 ); // UART1 = Mini-UART, UART0 - PL011 // Set GPIO15 and 16 for UART1 to ALT5 Mini-Uart INP_GPIO ( kBufferDirectionPin ); OUT_GPIO ( kBufferDirectionPin ); INP_GPIO ( kScopeTriggerPin ); OUT_GPIO ( kScopeTriggerPin ); INP_GPIO ( kUART1TxPin ); SET_GPIO_ALT ( kUART1TxPin, 5 ); INP_GPIO ( kUART1RxPin ); SET_GPIO_ALT ( kUART1RxPin, 5 ); INP_GPIO ( kUART1RTSPin); SET_GPIO_ALT ( kUART1RTSPin, 5 ); }
/** * init_module() - This function is called when the module is loaded * * Return: On succes the function retuns a 0 (SUCCES). Otherwise a * negative number is returned. */ int init_module(void) { Major = register_chrdev(0, DEVICE_NAME, &fops); if (Major < 0) { printk(KERN_ALERT "Registering char device failed with %d\n", Major); return Major; } printk(KERN_INFO "I was assigned major number %d. To talk to\n", Major); printk(KERN_INFO "the driver, create a device file with\n"); printk(KERN_INFO "'mknod /dev/%s c %d 0'.\n", DEVICE_NAME, Major); printk(KERN_INFO "Try various minor numbers. Try to echo to\n"); printk(KERN_INFO "the device file.\n"); printk(KERN_INFO "Remove the device file and module when done.\n"); gpio = (volatile unsigned int *)ioremap(GPIO_BASE, 1024); pwm = (volatile unsigned int *)ioremap(PWM_BASE, 1024); clk = (volatile unsigned int *)ioremap(CLOCK_BASE, 1024); // Set pin directions for the output INP_GPIO(GPIO_OUTP); OUT_GPIO(GPIO_OUTP); // PWM and clock settings SET_GPIO_ALT(GPIO_PWM1, GPIO_ALT); // stop clock and waiting for busy flag doesn't work, so kill clock *(clk + CLK_CTL) = CLK_PASSWD | CLK_CTL_KILL; udelay(10); // Set clock divider *(clk + CLK_DIV) = CLK_PASSWD | CLK_DIV_DIVI(96); // source=osc and enable clock *(clk + CLK_CTL) = CLK_PASSWD | CLK_CTL_ENAB | CLK_CTL_SRC(CLK_CTL_SRC_OSC); // disable PWM and start with a clean register *(pwm + PWM_CTL) = 0; // needs some time until the PWM module gets disabled, without the delay the PWM module crashes udelay(10); // Set the PWM range *(pwm + PWM_RNG2) = 4000; // Initialize with a 50% dutycycle setServo(50); // start PWM in M/S transmission mode *(pwm + PWM_CTL) = PWM_CTL_MSEN2 | PWM_CTL_PWEN2; interrupt_config(); return SUCCESS; }
// // Set GPIO pins to the right mode // DEMO GPIO mapping: // Function Mode // GPIO0= LED Output // GPIO1= LED Output // GPIO4= PWM channel-B Output // GPIO7= SPI chip select B Funct. 0 // GPIO8= SPI chip select A Funct. 0 // GPIO9= SPI MISO Funct. 0 // GPIO10= SPI MOSI Funct. 0 // GPIO11= SPI CLK Funct. 0 // GPIO14= UART TXD (Funct. 0) // GPIO15= UART RXD (Funct. 0) // GPIO17= LED Output // GPIO18= PWM channel-A Funct. 5 // GPIO21= LED Output // GPIO22= LED Output // GPIO23= LED Output // GPIO24= Pushbutton Input // GPIO25= Pushbutton Input // // Always call INP_GPIO(x) first // as that is how the macros work void setup_gpio() { INP_GPIO(0); OUT_GPIO(0); INP_GPIO(1); OUT_GPIO(1); INP_GPIO(4); OUT_GPIO(4); INP_GPIO(7); SET_GPIO_ALT(7,0); INP_GPIO(8); SET_GPIO_ALT(8,0); INP_GPIO(9); SET_GPIO_ALT(9,0); INP_GPIO(10); SET_GPIO_ALT(10,0); INP_GPIO(11); SET_GPIO_ALT(11,0); // 14 and 15 are already set to UART mode // by Linux. Best if we don't touch them // INP_GPIO(14); SET_GPIO_ALT(14,0); // INP_GPIO(54); SET_GPIO_ALT(15,0); INP_GPIO(17); OUT_GPIO(17); INP_GPIO(18); SET_GPIO_ALT(18,5); INP_GPIO(21); OUT_GPIO(21); INP_GPIO(22); OUT_GPIO(22); INP_GPIO(23); OUT_GPIO(23); INP_GPIO(24); INP_GPIO(25); // enable pull-up on GPIO24&25 GPIO_PULL = 2; short_wait(); // clock on GPIO 24 & 25 (bit 24 & 25 set) GPIO_PULLCLK0 = 0x03000000; short_wait(); GPIO_PULL = 0; GPIO_PULLCLK0 = 0; } // setup_gpio
static unsigned char* PinMode(struct uState* S, unsigned char* pc, number* res) { if (!res) return skip(S, skip(S, pc)); number pin; pc = eval(S, pc, &pin); pc = eval(S, pc, res); INP_GPIO(pin); if (*res) OUT_GPIO(pin); return pc; }
void gpio_setout(int g) { #ifndef GPIO_SIMULATED /* always INP_GPIO before OUT_GPIO */ //INP_GPIO(g); #### this causes glitching OUT_GPIO(g); #else printf("gpio:out:%d\n", g); #endif }
int setup_io() { /* open /dev/mem */ if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) { printf("can't open /dev/mem \n"); return -1; } /* mmap GPIO */ gpio_map = mmap( NULL, //Any adddress in our space will do BLOCK_SIZE, //Map length PROT_READ|PROT_WRITE,// Enable reading & writting to mapped memory MAP_SHARED, //Shared with other processes mem_fd, //File to map GPIO_BASE); close(mem_fd); //No need to keep mem_fd open after mmap if (gpio_map == MAP_FAILED) { printf("mmap error %d\n", (int)gpio_map); return -2; } // Always use volatile pointer! gpio = (volatile unsigned *)gpio_map; INP_GPIO(JTAG_TCK); INP_GPIO(JTAG_TMS); INP_GPIO(JTAG_TDI); INP_GPIO(JTAG_TDO); //Receive output from Device to rpi nop_sleep(WAIT); OUT_GPIO(JTAG_TDI); //Send data from rpi to Device OUT_GPIO(JTAG_TMS); OUT_GPIO(JTAG_TCK); nop_sleep(WAIT); return 0; }