/* * Function: pud_test * Description: be used to test input pull-down and pull-up related functions */ void pud_test(void) { uint8_t value; int i; printf("--------------->Start Test Pin PUD<---------------\n"); for(i=0; i < ARRAYLEN; i++) { bcm2835_gpio_fsel(bplusGpio[i], BCM2835_GPIO_FSEL_INPT); //input } for(i=0; i< ARRAYLEN; i++) { bcm2835_gpio_set_pud(bplusGpio[i], BCM2835_GPIO_PUD_UP); bcm2835_delay(500); value = bcm2835_gpio_lev(bplusGpio[i]); if(1 != value) printf("BCM pin%d:expect value %d and actual value %d\n", bplusGpio[i], 1, value); bcm2835_gpio_set_pud(bplusGpio[i], BCM2835_GPIO_PUD_DOWN); bcm2835_delay(500); value = bcm2835_gpio_lev(bplusGpio[i]); if(0 != value) printf("BCM pin%d:expect value %d and actual value %d\n", bplusGpio[i], 0, value); } printf("--------------->Test Over Of Pin PUD<---------------\n"); }
//============================================================================== // TODO add error messages void PWM_init() { // setting PWM_PIN as pwm from channel 0 in markspace mode with range = RANGE bcm2835_gpio_fsel(PWM_PIN, BCM2835_GPIO_FSEL_ALT5); // ALT5 is pwm mode bcm2835_pwm_set_clock( BCM2835_PWM_CLOCK_DIVIDER_16); // pwm freq = 19.2 / 16 MHz bcm2835_pwm_set_mode(PWM_CHANNEL, 1, 1); // markspace mode bcm2835_pwm_set_range(PWM_CHANNEL, RANGE); bcm2835_gpio_fsel(OE_SHIFTER, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_set_pud( OE_SHIFTER, BCM2835_GPIO_PUD_DOWN); // pull-down for output enable of logic shifters bcm2835_gpio_fsel(MOTOR_D3, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_set_pud(MOTOR_D3, BCM2835_GPIO_PUD_DOWN); // pull-down for motor enable bcm2835_gpio_fsel(PA0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_set_pud(PA0, BCM2835_GPIO_PUD_UP); bcm2835_gpio_write(PA0, HIGH); bcm2835_gpio_write(OE_SHIFTER, HIGH); bcm2835_gpio_write(MOTOR_D3, LOW); }
int main(int argc, char **argv) { if (!bcm2835_init()) return 1; bcm2835_gpio_fsel(PIN0, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_fsel(PIN1, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(PIN0, BCM2835_GPIO_PUD_UP); bcm2835_gpio_set_pud(PIN1, BCM2835_GPIO_PUD_UP); bcm2835_gpio_fsel(POUT1, BCM2835_GPIO_FSEL_ALT5); bcm2835_pwm_set_clock(BCM2835_PWM_CLOCK_DIVIDER_256); bcm2835_pwm_set_mode(0, 1, 1); bcm2835_pwm_set_range(0, 1024); int data=0; while (1) { uint8_t in0 = bcm2835_gpio_lev(PIN0); uint8_t in1 = bcm2835_gpio_lev(PIN1); if (in1 == 0) break; data ++; if(data > 1023) data=0; bcm2835_pwm_set_data(0, data); bcm2835_delay(2); } bcm2835_pwm_set_data(0, 0); bcm2835_gpio_fsel(POUT1, BCM2835_GPIO_FSEL_INPT); bcm2835_close(); return 0; }
void initButtons( void ){ // Set RPI pin to be an input bcm2835_gpio_fsel ( BUTTON_0, BCM2835_GPIO_FSEL_INPT ); bcm2835_gpio_fsel ( BUTTON_1, BCM2835_GPIO_FSEL_INPT ); // with a pullup bcm2835_gpio_set_pud ( BUTTON_0, BCM2835_GPIO_PUD_OFF ); bcm2835_gpio_set_pud ( BUTTON_1, BCM2835_GPIO_PUD_OFF ); }
int main(int argc, char *argv[]) { bcm2835_init(); if(comparse(argc, argv) == EXIT_FAILURE) return 0; // setting PWM_PIN as pwm from channel 0 in markspace mode with range = RANGE bcm2835_gpio_fsel(PWM_PIN, BCM2835_GPIO_FSEL_ALT5); //ALT5 is pwm mode bcm2835_pwm_set_clock(BCM2835_PWM_CLOCK_DIVIDER_16); // pwm freq = 19.2 / 16 MHz bcm2835_pwm_set_mode(PWM_CHANNEL, 1, 1); // markspace mode bcm2835_pwm_set_range(PWM_CHANNEL, RANGE); bcm2835_gpio_fsel(OE_SHIFTER, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_set_pud(OE_SHIFTER, BCM2835_GPIO_PUD_DOWN); //pull-down for output enable of logic shifters bcm2835_gpio_fsel(MOTOR_D3, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_set_pud(MOTOR_D3, BCM2835_GPIO_PUD_DOWN); //pull-down for motor enable bcm2835_gpio_fsel(PA0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_set_pud(PA0, BCM2835_GPIO_PUD_UP); bcm2835_gpio_write(PA0, HIGH); bcm2835_gpio_write(OE_SHIFTER, HIGH); bcm2835_gpio_write(MOTOR_D3, LOW); // creating and running threads pthread_t th1, th2, th3, th4, th5, th6, th7; pthread_create(&th1, NULL, (void*)encoder_time_thread, NULL); pthread_create(&th2, NULL, (void*)magnet_time_thread, NULL); pthread_create(&th3, NULL, (void*)encoder_thread, NULL); pthread_create(&th4, NULL, (void*)magnet_thread, NULL); pthread_create(&th5, NULL, (void*)energy_time_thread, NULL); pthread_create(&th6, NULL, (void*)calculate_energy, NULL); pthread_create(&th7, NULL, (void*)calculate_I_ref, NULL); bcm2835_delay(100); // delay to make sure that all threads are initialised and iC-MU is conofigured printf("\nPress enter to start the motor."); getchar(); bcm2835_gpio_write(MOTOR_D3, HIGH); start = 1; printf("Started.\n"); printf("\nPress enter to stop the motor.\n"); getchar(); bcm2835_gpio_write(MOTOR_D3, LOW); bcm2835_spi_end(); bcm2835_close(); return 0; }
void GPIO::setPullupMode(uint16_t pin, PullupMode_e mode) { if(mode == PULLUP_ENABLED) { bcm2835_gpio_set_pud((uint8_t)pin, BCM2835_GPIO_PUD_UP); } else { bcm2835_gpio_set_pud((uint8_t)pin, BCM2835_GPIO_PUD_OFF); } }
// initialization of GPIO and SPI // ---------------------------------------------------------- void TFT_init_board ( void ) { // *************** set the pins to be an output and turn them on bcm2835_gpio_fsel( OE, BCM2835_GPIO_FSEL_OUTP ); bcm2835_gpio_write( OE, HIGH ); bcm2835_gpio_fsel( RAIO_RST, BCM2835_GPIO_FSEL_OUTP ); bcm2835_gpio_write( RAIO_RST, HIGH ); bcm2835_gpio_fsel( RAIO_CS, BCM2835_GPIO_FSEL_OUTP ); bcm2835_gpio_write( RAIO_CS, HIGH ); bcm2835_gpio_fsel( RAIO_RS, BCM2835_GPIO_FSEL_OUTP ); bcm2835_gpio_write( RAIO_RS, HIGH ); bcm2835_gpio_fsel( RAIO_WR, BCM2835_GPIO_FSEL_OUTP ); bcm2835_gpio_write( RAIO_WR, HIGH ); bcm2835_gpio_fsel( RAIO_RD, BCM2835_GPIO_FSEL_OUTP ); bcm2835_gpio_write( RAIO_RD, HIGH ); // *************** now the inputs bcm2835_gpio_fsel( RAIO_WAIT, BCM2835_GPIO_FSEL_INPT ); bcm2835_gpio_set_pud( RAIO_WAIT, BCM2835_GPIO_PUD_UP); bcm2835_gpio_fsel( RAIO_INT, BCM2835_GPIO_FSEL_INPT ); bcm2835_gpio_set_pud( RAIO_INT, BCM2835_GPIO_PUD_UP); // *************** set pins for SPI bcm2835_gpio_fsel(MISO, BCM2835_GPIO_FSEL_ALT0); bcm2835_gpio_fsel(MOSI, BCM2835_GPIO_FSEL_ALT0); bcm2835_gpio_fsel(SCLK, BCM2835_GPIO_FSEL_ALT0); bcm2835_gpio_fsel(SPI_CE1, BCM2835_GPIO_FSEL_ALT0); // set the SPI CS register to the some sensible defaults volatile uint32_t* paddr = bcm2835_spi0 + BCM2835_SPI0_CS/8; bcm2835_peri_write( paddr, 0 ); // All 0s // clear TX and RX fifos bcm2835_peri_write_nb( paddr, BCM2835_SPI0_CS_CLEAR ); bcm2835_spi_setBitOrder( BCM2835_SPI_BIT_ORDER_MSBFIRST ); bcm2835_spi_setDataMode( BCM2835_SPI_MODE0 ); bcm2835_spi_setClockDivider( BCM2835_SPI_CLOCK_DIVIDER_2 ); bcm2835_spi_chipSelect( BCM2835_SPI_CS1 ); bcm2835_spi_setChipSelectPolarity( BCM2835_SPI_CS1, LOW ); }
void UartInit () { /* Set pins 14 and 15 to alt function 0 */ bcm2835_gpio_fsel(14, BCM2835_GPIO_FSEL_ALT0); bcm2835_gpio_fsel(15, BCM2835_GPIO_FSEL_ALT0); /* Disable the uart for now */ *uart0_cr = 0; /* Disable pull up/pull down resistors on pins 14,15 */ bcm2835_gpio_set_pud(14, BCM2835_GPIO_PUD_OFF); bcm2835_gpio_set_pud(15, BCM2835_GPIO_PUD_OFF); /* Clear any interrupts */ *uart0_icr = UART_ICR_ALL; /* Set up the integer and fractional clock settings */ /* From the BCM2835 Peripherals Guide http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf (Note : this is for uart 0) GPIO pin 14 is TXD0 using alt function 0 GPIO pin 15 is RXD0 using alt function 0 "The baud rate divisor is calculated as follows: Baud rate divisor BAUDDIV = (FUARTCLK/(16 Baud rate)) where FUARTCLK is the UART reference clock frequency. The BAUDDIV is comprised of the integer value IBRD and the fractional value FBRD. NOTE: The contents of the IBRD and FBRD registers are not updated until transmission or reception of the current character is complete." FBRD is a 6 bit number (0-63) to represent the fractional divisor. The uart clock is 3MHz, and we are going to use a fixed, 115,200 baud rate. So... BAUDDIV = 3,000,000 / (16 * 115,200) = 1.628 IBRD = floor(1.628) = 1 FBRD = 0.628 * 64 = 40 */ *uart0_ibrd = 1; *uart0_fbrd = 40; /* Set the uart to 8 bits, no parity, 1 stop bit (8N1) and enable the fifos */ *uart0_lcrh = UART_LCRH_FIFO_EN | UART_LCRH_8_BITS; /* Finally, enable the uart for send and receive */ *uart0_cr = UART_CR_UART_EN | UART_CR_TX_EN | UART_CR_RX_EN; /* Flush the rx fifo in case there is anything in there */ //UartFlushRxFifo(); }
void SHT1x_InitPins( void ) { // SCK line as output but set to low first bcm2835_gpio_write(RPI_GPIO_SHT1x_SCK, LOW); bcm2835_gpio_fsel(RPI_GPIO_SHT1x_SCK, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(RPI_GPIO_SHT1x_SCK, LOW); // DATA to input. External pull up. // Set PORT to 0 => pull data line low by setting port as output bcm2835_gpio_set_pud(RPI_GPIO_SHT1x_DATA, BCM2835_GPIO_PUD_OFF); bcm2835_gpio_write(RPI_GPIO_SHT1x_DATA,LOW); bcm2835_gpio_fsel(RPI_GPIO_SHT1x_DATA, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_set_pud(RPI_GPIO_SHT1x_DATA, BCM2835_GPIO_PUD_OFF); bcm2835_gpio_write(RPI_GPIO_SHT1x_DATA,LOW); }
int main(int argc, char **argv) { if (!bcm2835_init()) return 1; bcm2835_gpio_fsel(PIN0, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_fsel(PIN1, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(PIN0, BCM2835_GPIO_PUD_UP); bcm2835_gpio_set_pud(PIN1, BCM2835_GPIO_PUD_UP); bcm2835_gpio_fsel(POUT0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(POUT1, BCM2835_GPIO_FSEL_OUTP); while (1) { uint8_t in0 = bcm2835_gpio_lev(PIN0); uint8_t in1 = bcm2835_gpio_lev(PIN1); if (in0 == 0) { bcm2835_gpio_write(POUT0, HIGH); } else { bcm2835_gpio_write(POUT0, LOW); } if (in1 == 0) break; } for (int i=0; i<5; i++) { bcm2835_gpio_write(POUT0, HIGH); bcm2835_delay(500); bcm2835_gpio_write(POUT0, LOW); bcm2835_gpio_write(POUT1, HIGH); bcm2835_delay(500); bcm2835_gpio_write(POUT0, HIGH); bcm2835_delay(500); bcm2835_gpio_write(POUT0, LOW); bcm2835_gpio_write(POUT1, LOW); bcm2835_delay(500); } bcm2835_close(); return 0; }
/* Initialize the PIR motion detection sensor on a given GPIO pin, 0 on success */ int pirmtn_init(uint8_t pin) { if (!bcm2835_init()) { return 1; } // Set PIN to be an input bcm2835_gpio_fsel(pin, BCM2835_GPIO_FSEL_INPT); // with a pulldown bcm2835_gpio_set_pud(pin, BCM2835_GPIO_PUD_DOWN); // And a rising edge detect enable bcm2835_gpio_aren(pin); // Wait little while for the init jitter on the GPIO delay(500); // Now clear the eds flag by setting it to 1 bcm2835_gpio_set_eds(pin); // Set the given pin as our static default one pirmtn_pin = pin; return 0; }
int main(int argc, char **argv) { // If you call this, it will not actually access the GPIO // Use for testing // bcm2835_set_debug(1); if (!bcm2835_init()) return 1; // Set RPI pin P1-15 to be an input bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_INPT); // with a pullup bcm2835_gpio_set_pud(PIN, BCM2835_GPIO_PUD_UP); // Blink while (1) { // Read some data uint8_t value = bcm2835_gpio_lev(PIN); printf("read from pin 15: %d\n", value); // wait a bit delay(500); } bcm2835_close(); return 0; }
int main(int argc, char **argv) { uint8_t value,i; if (!bcm2835_init()) return 1; for(i=0;i<5;i++) { bcm2835_gpio_fsel(KEY[i], BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(KEY[i], BCM2835_GPIO_PUD_UP); } while (1) { for(i=0;i<5;i++) { if(bcm2835_gpio_lev(KEY[i])==0) { printf("press the key: %d\n", i); delay(500); } } } bcm2835_close(); return 0; }
int main(int argc, char** argv){ if (!bcm2835_init()) return 1; //Set PIN_OUT to be output bcm2835_gpio_fsel(PIN_OUT, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(PIN_OUT, HIGH); // Set PIN_IN to be input with pulldown bcm2835_gpio_fsel(PIN_IN, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(PIN_IN, BCM2835_GPIO_PUD_DOWN); run = 1; counter = 0; status = LOW; while(run){ //Check if door is open or closed uint8_t value = bcm2835_gpio_lev(PIN_IN); if(value == HIGH) on_high(); else on_low(); //Sleep counter++; delay(SLEEP_TIME); } return 1; }
int main (int argc, char *argv[]) { //load GPIO and set the pin to output bcm2835_init(); bcm2835_gpio_fsel(21, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_set_pud(21, BCM2835_GPIO_PUD_UP); //write low to GPIO bcm2835_gpio_write(21, LOW); //create some tracking value timespec ts; bool ready = true; //repeat this forever while(true) { //get the current time from the system clock clock_gettime(CLOCK_REALTIME, &ts); //if we are in the first half of the second, set ready to true if(ts.tv_nsec < 500000000) ready = true; //first time we hit second half of the second else if(ready == true) { ready = false; //write HIGH to GPIO bcm2835_gpio_write(21, HIGH); //wait for a moment delay(5); //write LOW to GPIO bcm2835_gpio_write(21, LOW); } } return 0; }
int main(int argc, char **argv) { // If you call this, it will not actually access the GPIO if (!bcm2835_init()) return 1; // Set RPI pin to be an input bcm2835_gpio_fsel(RF_IRQ_PIN, BCM2835_GPIO_FSEL_INPT); // with a puldown bcm2835_gpio_set_pud(RF_IRQ_PIN, BCM2835_GPIO_PUD_DOWN); // And a rising edge detect enable bcm2835_gpio_ren(RF_IRQ_PIN); while (1) { // we got it ? if (bcm2835_gpio_eds(RF_IRQ_PIN)) { // Now clear the eds flag by setting it to 1 bcm2835_gpio_set_eds(RF_IRQ_PIN); printf("Rising event detect for pin GPIO%d\n", RF_IRQ_PIN); } // wait a bit bcm2835_delay(5); } bcm2835_close(); return 0; }
int main(int argc, char **argv) { if (!bcm2835_init()) { return 1; } bcm2835_gpio_fsel(LED_PIN, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(BUZ_PIN, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(TLT_PIN, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(TLT_PIN, BCM2835_GPIO_PUD_DOWN); for (int i = 0; i < 100; i++) { uint8_t value = bcm2835_gpio_lev(TLT_PIN); printf("read from pin %d : %d\n", TLT_PIN, value); if (value == 0) { bcm2835_gpio_write(LED_PIN, HIGH); bcm2835_gpio_write(BUZ_PIN, LOW); } else { bcm2835_gpio_write(LED_PIN, LOW); bcm2835_gpio_write(BUZ_PIN, HIGH); } bcm2835_delay(500); } bcm2835_gpio_write(LED_PIN, LOW); bcm2835_close(); return 0; }
int main(int argc, char **argv) { // If you call this, it will not actually access the GPIO // Use for testing // bcm2835_set_debug(1); if (!bcm2835_init()) return 1; // Set RPI pin P1-15 to be an input bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_INPT); // with a pullup bcm2835_gpio_set_pud(PIN, BCM2835_GPIO_PUD_UP); // And a low detect enable bcm2835_gpio_len(PIN); while (1) { if (bcm2835_gpio_eds(PIN)) { // Now clear the eds flag by setting it to 1 bcm2835_gpio_set_eds(PIN); printf("low event detect for pin 15\n"); } // wait a bit delay(500); } bcm2835_close(); return 0; }
/** * @brief Configures the pins as input and returns the pin status. * @param pin Pin to be configured, Available pin definitons are defined in the Utitlies.h * @return status Pin level can be HIGH or LOW. */ PinLevel_t ReadPinStatus(PIN_t pin) { bcm2835_gpio_fsel(pin,BCM2835_GPIO_FSEL_INPT); // Set the pin to be an input bcm2835_gpio_set_pud(pin, BCM2835_GPIO_PUD_DOWN); // Enable pull up. PinLevel_t pinLevel = (PinLevel_t)bcm2835_gpio_lev(pin); //read voltage level on MFP pin return pinLevel; }
int main(){ time_t mytime; printf("Start at "); mytime = time(NULL); printf(ctime(&mytime), "\n\n"); // Чисто отладочная запись в консоль, когда была запущена программа bcm2835_close(); // Это надо на всякий случай ибо процесс прекращается по ctrl+c и до этой функции дело не доходит if (!bcm2835_init()) // Инициализация GPIO и выход с кодом "1" при неудаче return 1; bcm2835_gpio_set_pud(PIR_SIGNAL, BCM2835_GPIO_PUD_DOWN); // Подтяжка ножки к нулю bcm2835_gpio_fsel(PIR_SIGNAL, BCM2835_GPIO_FSEL_INPT); // Установка ножки для PIR на прием //printf("%u\n", bcm2835_gpio_lev(PIR_SIGNAL)); // Вывод значения ножки /////////Начало цикла слежения///////// while (1) { // Бесконечный цикл... Надо почитать про прерывания... while(!bcm2835_gpio_lev(PIR_SIGNAL)) {/* Ждем первого срабатывания */} time_to_file_first(); // см. выше printf("PIR activated at "); mytime = time(NULL); printf(ctime(&mytime), "\n\n"); // То было в файл, а это в консоль // Пауза в мс. Аналог чувствительности датчика. Нужна чтобы отсечь ложные срабатывания bcm2835_delay(2000); // Проверяем сигнал после паузы (PIR либо потухнет, либо останется активен) // Если сигнал остался, то в консоль выводим время и ждем пока на ножке не появится ноль if(bcm2835_gpio_lev(PIR_SIGNAL)) { printf("Movement detected at "); mytime = time(NULL); printf(ctime(&mytime), "\n"); //Вывод даты и времени time_to_file_on(); // А заодно и в файл while (bcm2835_gpio_lev(PIR_SIGNAL)) {/* ждем пока сигнал не прекратится */} printf("Movement stopped at "); mytime = time(NULL); printf(ctime(&mytime), "\n"); printf("\n\n"); //Вывод даты и времени time_to_file_off(); // И опять в файл } } // До сюда обычно дело не доходит. Но пусть пока останется. printf("End\n"); return (bcm2835_close()); }
int main() { bcm2835_init(); bcm2835_gpio_fsel(SW_g, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_fsel(SW_w1, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_fsel(SW_w2, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_fsel(SW_b1, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_fsel(SW_b2, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(SW_g, BCM2835_GPIO_PUD_UP); bcm2835_gpio_set_pud(SW_w1, BCM2835_GPIO_PUD_UP); bcm2835_gpio_set_pud(SW_w2, BCM2835_GPIO_PUD_UP); bcm2835_gpio_set_pud(SW_b1, BCM2835_GPIO_PUD_UP); bcm2835_gpio_set_pud(SW_b2, BCM2835_GPIO_PUD_UP); while(true) { lcd.SendData_RGB565(fb.GetFrameAddress(),128*128*2); usleep(50000);//50ms if(!bcm2835_gpio_lev(SW_b1)) { //FB_Func(); Tetris_Func(); } else if(!bcm2835_gpio_lev(SW_b2)) { Tetris_Func(); } else if(!bcm2835_gpio_lev(SW_w1)) { Tetris_Func(); } else if(!bcm2835_gpio_lev(SW_w2)) { Tetris_Func(); } else if(!bcm2835_gpio_lev(SW_g)) { shutdown(); } } }
void bcm2835_uart_begin(void) { BCM2835_UART1->ENABLE = 0x01; BCM2835_UART1->CNTL = 0x00; BCM2835_UART1->LCR = 0x03; BCM2835_UART1->MCR = 0x00; BCM2835_UART1->IER = 0x05; BCM2835_UART1->IIR = 0xC6; BCM2835_UART1->BAUD = 270; // Set the GPI0 pins to the Alt 5 function to enable UART1 access on them bcm2835_gpio_fsel(RPI_V2_GPIO_P1_08, BCM2835_GPIO_FSEL_ALT5); // UART1_TXD bcm2835_gpio_fsel(RPI_V2_GPIO_P1_10, BCM2835_GPIO_FSEL_ALT5); // UART1_RXD // Disable pull-up/down bcm2835_gpio_set_pud(RPI_V2_GPIO_P1_08, BCM2835_GPIO_PUD_OFF); bcm2835_gpio_set_pud(RPI_V2_GPIO_P1_10, BCM2835_GPIO_PUD_OFF); // turn on the uart for send and receive BCM2835_UART1->CNTL = 3; }
/* * Function: edge_test * Description: be used to test edge detect related functions */ void edge_test(void) { printf("--------------->Start Test dege detect<---------------\n"); bcm2835_gpio_set_pud(EDGE_PIN, BCM2835_GPIO_PUD_UP); //enable pull-up bcm2835_gpio_fsel(EDGE_PIN, BCM2835_GPIO_FSEL_INPT); //set input edge_detect_test(EDGE_PIN, LOW_MODE); edge_detect_test(EDGE_PIN, HIGH_MODE); edge_detect_test(EDGE_PIN, FALLING_MODE); edge_detect_test(EDGE_PIN, RISING_MODE); printf("--------------->Test Over Of Edge Detect<---------------\n"); }
int initTurntable(Turntable_t *t) { printf("initTurntable start\r\n"); if(!bcm2835_init()) return 1; // Set the pin modes bcm2835_gpio_fsel(MOTOR_A, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(MOTOR_B, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(ENCODER, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(ENCODER, BCM2835_GPIO_PUD_UP); bcm2835_gpio_fsel(SWITCH, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(SWITCH, BCM2835_GPIO_PUD_UP); // Initialise members t->maxEncoder = 0; t->currentEncoder = 0; t->encoder = 0; t->limitSW = 0; t->ttdriver = 0; printf("initTurntable end\r\n"); return 0; }
//-------------------------------------------------------------------------------------------------- // Name: HalInit // Function: Setup GPIO for Raspi_LCD // // Parameter: - // Return: - //-------------------------------------------------------------------------------------------------- int RaspiLcdHwInit(void) { int HwRev; HwRev = GetRaspberryHwRevision(); if (!bcm2835_init()) return 0; // Buttons PinButton[0] = 17; PinButton[1] = (HwRev < 2) ? 21 : 27; PinButton[2] = 22; PinButton[3] = 23; PinButton[4] = 24; bcm2835_gpio_fsel(PinButton[0],BCM2835_GPIO_FSEL_INPT) ; // Set GPIO Pin to Input bcm2835_gpio_fsel(PinButton[1],BCM2835_GPIO_FSEL_INPT) ; // Set GPIO Pin to Input bcm2835_gpio_fsel(PinButton[2],BCM2835_GPIO_FSEL_INPT) ; // Set GPIO Pin to Input bcm2835_gpio_fsel(PinButton[3],BCM2835_GPIO_FSEL_INPT) ; // Set GPIO Pin to Input bcm2835_gpio_fsel(PinButton[4],BCM2835_GPIO_FSEL_INPT) ; // Set GPIO Pin to Input bcm2835_gpio_set_pud(PinButton[0],BCM2835_GPIO_PUD_UP); // Enable Pullup bcm2835_gpio_set_pud(PinButton[1],BCM2835_GPIO_PUD_UP); // Enable Pullup bcm2835_gpio_set_pud(PinButton[2],BCM2835_GPIO_PUD_UP); // Enable Pullup bcm2835_gpio_set_pud(PinButton[3],BCM2835_GPIO_PUD_UP); // Enable Pullup bcm2835_gpio_set_pud(PinButton[4],BCM2835_GPIO_PUD_UP); // Enable Pullup // LCD Display bcm2835_gpio_fsel(PIN_LCD_MOSI, BCM2835_GPIO_FSEL_OUTP); // GPIO10 Output: MOSI bcm2835_gpio_fsel(PIN_LCD_SCLK, BCM2835_GPIO_FSEL_OUTP); // GPIO11 Output: SCLK bcm2835_gpio_fsel(PIN_LCD_RST, BCM2835_GPIO_FSEL_OUTP); // GPIO25 Output: RST bcm2835_gpio_fsel(PIN_LCD_CS , BCM2835_GPIO_FSEL_OUTP); // GPIO8 Output: CS bcm2835_gpio_fsel(PIN_LCD_RS, BCM2835_GPIO_FSEL_OUTP); // GPIO7 Output: RS bcm2835_gpio_fsel(PIN_LCD_BACKLIGHT,BCM2835_GPIO_FSEL_OUTP); // GPIO18 Output: Backlight Button = ButtonMem = ButtonPressed = 0; return 1; }
void i2c_pins_setup(void) { bcm2835_init(); bcm2835_gpio_fsel(0,BCM2835_FSEL_INPT); bcm2835_gpio_fsel(1,BCM2835_FSEL_INPT); bcm2835_gpio_fsel(2,BCM2835_FSEL_INPT); bcm2835_gpio_fsel(3,BCM2835_FSEL_INPT); bcm2835_gpio_fsel(28,BCM2835_FSEL_INPT); bcm2835_gpio_fsel(29,BCM2835_FSEL_INPT); // Set bus i2c 0 bcm2835_gpio_fsel(2,BCM2835_FSEL_ALT0); bcm2835_gpio_set_pud(2,BCM2835_GPIO_PUD_UP); bcm2835_gpio_fsel(3,BCM2835_FSEL_ALT0); bcm2835_gpio_set_pud(3,BCM2835_GPIO_PUD_UP); // Set bus i2c 1 bcm2835_gpio_fsel(28,BCM2835_FSEL_ALT0); bcm2835_gpio_set_pud(28,BCM2835_GPIO_PUD_UP); bcm2835_gpio_fsel(29,BCM2835_FSEL_ALT0); bcm2835_gpio_set_pud(29,BCM2835_GPIO_PUD_UP); }
static PyObject * PyBCM2835_gpio_set_pud(PyObject *self, PyObject *args) { uint8_t pin; uint8_t pud; if (!PyArg_ParseTuple(args,"ii",&pin,&pud)) { return NULL; } bcm2835_gpio_set_pud(pin,pud); Py_RETURN_NONE; }
int main(int argc, char **argv) { if (!bcm2835_init()) return 1; bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_set_pud(PIN, BCM2835_GPIO_PUD_UP); printf("irm test start: \n"); char turn; char n,p,result; unsigned long i; unsigned long buff[33]; while (1) { i++;delayMicroseconds(60); if(bcm2835_gpio_lev(PIN)==1) { turn=1; } else { if(turn==1) { if((n>0)&&(n<=33)) { buff[n-1]=i; } n++;i=0; if(n==34) { n=0; //for(p=0;p<33;p++){printf("%d-%d;",p,buff[p]);} if(buff[0]>180 && buff[0]<250 && buff[1]<25 && buff[2]<25 && buff[3]<25 && buff[4]<25 && buff[5]<25 && buff[6]<25 && buff[7]<25 && buff[8]<25 && buff[9]>25 && buff[10]>25 && buff[11]>25 && buff[12]>25 && buff[13]>25) { for(p=0;p<8;p++) { result>>=1; if(buff[25+p]>25) {result|=0x80;} } printf("get the irm key code-hex ox%x \n",result); } bcm2835_delay(200); } } turn=0; } }
void GpioPlateformImplementation::internalPinSetupInput( GPioInputType type ) { if ( _inputType == InputPullUp ) bcm2835_gpio_set_pud( _pin, BCM2835_GPIO_PUD_UP); else if ( _inputType == InputPullDown ) bcm2835_gpio_fsel( _pin, BCM2835_GPIO_PUD_DOWN ); else if ( _inputType == InputDirect ) bcm2835_gpio_fsel( _pin, BCM2835_GPIO_FSEL_INPT); }
// Writes an number of bytes to SPI void spi_uart_tx(char c) { volatile uint32_t* paddr = bcm2835_spi0 + BCM2835_SPI0_CS/4; volatile uint32_t* fifo = bcm2835_spi0 + BCM2835_SPI0_FIFO/4; bcm2835_gpio_fsel(RPI_GPIO_P1_19, BCM2835_GPIO_FSEL_ALT0); //BUG: The start bit is always 1.5 periods long, probably unfixable // This is Polled transfer as per section 10.6.1 // BUG ALERT: what happens if we get interupted in this section, and someone else // accesses a different peripheral? // Clear TX and RX fifos bcm2835_peri_set_bits(paddr, BCM2835_SPI0_CS_CLEAR, BCM2835_SPI0_CS_CLEAR); // Set TA = 1 bcm2835_peri_set_bits(paddr, BCM2835_SPI0_CS_TA, BCM2835_SPI0_CS_TA); // Maybe wait for TXD while (!(bcm2835_peri_read(paddr) & BCM2835_SPI0_CS_TXD)) ; // Write to FIFO, no barrier bcm2835_peri_write_nb(fifo, reverse_bits(c)); // Read from FIFO to prevent stalling while (bcm2835_peri_read(paddr) & BCM2835_SPI0_CS_RXD) (void) bcm2835_peri_read_nb(fifo); // bcm2835_gpio_fsel(RPI_GPIO_P1_19, BCM2835_GPIO_FSEL_ALT0); // Wait for DONE to be set while (!(bcm2835_peri_read_nb(paddr) & BCM2835_SPI0_CS_DONE)) { // while (bcm2835_peri_read(paddr) & BCM2835_SPI0_CS_RXD) // (void) bcm2835_peri_read_nb(fifo); } // bcm2835_delayMicroseconds(10); // Set TA = 0, and also set the barrier bcm2835_peri_set_bits(paddr, 0, BCM2835_SPI0_CS_TA); //TODO: THe program might be interrupted in here, corrupting the character. bcm2835_gpio_fsel(RPI_GPIO_P1_19, BCM2835_GPIO_FSEL_OUTP); // MOSI bcm2835_gpio_set(RPI_GPIO_P1_19); //idle high bcm2835_gpio_set_pud(RPI_GPIO_P1_19,BCM2835_GPIO_PUD_UP); bcm2835_delayMicroseconds(40); }