/*
* Function: spi_test
* Description: be used to test SPI related functions by using the AT450BXX module
*
* host slave
* MISO < - > MISO
* MOSI < - > MOSI
* CLK < - > CLK
* CE0/1 < - > CS
*/
void spi_test(void)
{
int num;
unsigned char wBuf = 0x3f;
unsigned char rBuf;
printf("--------------->Test SPI With AT450BXX<--------------\n");
bcm2835_spi_begin();
bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST); // The default
bcm2835_spi_setDataMode(BCM2835_SPI_MODE0); // The default
bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_64);
//bcm2835_spi_chipSelect(BCM2835_SPI_CS0);
//bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, HIGH);
bcm2835_gpio_fsel(PIN_CS, BCM2835_GPIO_FSEL_OUTP); /*set CS, and must be called*/
printf("SPI write 0x%x\n", wBuf);
ee_write(0,wBuf);
bcm2835_delay(50);
rBuf = ee_read(0);
printf("SPI read 0x%x\n", rBuf);
if(wBuf == rBuf)
{
printf("SPI interface work well !...\n");
}
else
{
printf("SPI interface work bad !...\n");
}
bcm2835_spi_end();
}
/*
* 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");
}
void bcm2835_spi_begin(void)
{
// Set the SPI0 pins to the Alt 0 function to enable SPI0 access on them
bcm2835_gpio_fsel(RPI_GPIO_P1_26, BCM2835_GPIO_FSEL_ALT0); // CE1
bcm2835_gpio_fsel(RPI_GPIO_P1_24, BCM2835_GPIO_FSEL_ALT0); // CE0
bcm2835_gpio_fsel(RPI_GPIO_P1_21, BCM2835_GPIO_FSEL_ALT0); // MISO
bcm2835_gpio_fsel(RPI_GPIO_P1_19, BCM2835_GPIO_FSEL_ALT0); // MOSI
bcm2835_gpio_fsel(RPI_GPIO_P1_23, BCM2835_GPIO_FSEL_ALT0); // CLK
// Set the SPI CS register to the some sensible defaults
volatile uint32_t* paddr = bcm2835_spi0 + BCM2835_SPI0_CS/4;
bcm2835_peri_write(paddr, 0); // All 0s
// Clear TX and RX fifos
bcm2835_peri_write_nb(paddr, BCM2835_SPI0_CS_CLEAR);
}
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;
}
char* record_burst(int time,int rate){
sample_interval=(1000*1000/rate); //microseconds
sample_size = time*rate;
bcm2835_gpio_fsel(PIN_RX,BCM2835_GPIO_FSEL_INPT);
char* placeholder=calloc(sample_size,sizeof(char));
printf("Recording in 3\n");
fflush(stdout);
bcm2835_delay(1000);
printf("Recording in 2\n");
bcm2835_delay(1000);
printf("Recording in 1\n");
bcm2835_delay(1000);
printf("Recording for %d seconds\n",time);
printf("sample_size: %d\n",sample_size);
fflush(stdout);
for (i=0;i<sample_size;i++){
placeholder[i]=(char)bcm2835_gpio_lev(PIN_RX);
bcm2835_delayMicroseconds(sample_interval);
}
printf("record_burst returning\n");
return placeholder;
}
void close_sockets() {
if (mux >= 0)
close(mux);
bcm2835_gpio_fsel(pin, BCM2835_GPIO_FSEL_INPT);
bcm2835_close();
}
boolean ssd1306_init()
{
ssd1306_lcdwidth = 128;
ssd1306_lcdheight = 64;
_i2c_addr = 0x3C;
cursor_y = cursor_x = 0;
//textsize = 1;
// De-Allocate memory for OLED buffer if any
if (poledbuff)
free(poledbuff);
// Allocate memory for OLED buffer
poledbuff = (uint8_t *) malloc ( (ssd1306_lcdwidth * ssd1306_lcdheight / 8 ));
if (!poledbuff)
return false;
// Init Raspberry PI GPIO
if (!bcm2835_init())
return false;
// default OLED are using internal boost VCC converter
vcc_type = SSD_Internal_Vcc;
// Init & Configure Raspberry PI I2C
if (bcm2835_i2c_begin()==0)
return false;
bcm2835_i2c_setSlaveAddress(_i2c_addr) ;
// Setup reset pin direction as output
bcm2835_gpio_fsel(OLED_I2C_RESET, BCM2835_GPIO_FSEL_OUTP);
return ( true);
}
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);
}
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;
}
/**
* @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(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 the pin to be an output
bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP);
// Blink
while (1)
{
// Turn it on
bcm2835_gpio_write(PIN, HIGH);
// wait a bit
delay(500);
// turn it off
bcm2835_gpio_write(PIN, LOW);
// wait a bit
delay(500);
}
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;
}
static int pwm_init(pwm_t* pwm)
{
/* TODO: configure pwm_config (clock manager) */
size_t off;
int fd;
if (init_bcm2835() == -1) return -1;
bcm2835_gpio_fsel(CONFIG_PWM_PIN, BCM2835_GPIO_FSEL_ALT5);
close_bcm2835();
fd = open("/dev/mem", O_RDWR | O_SYNC);
if (fd == -1)
{
perror("open");
return -1;
}
pwm->size = PWM_MAP_SIZE;
pwm->addr = (uintptr_t)mmap
(NULL, PWM_MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, PWM_MAP_OFFSET);
close(fd);
if ((void*)pwm->addr == MAP_FAILED)
{
perror("mmap");
return -1;
}
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;
}
// ---------------------------------------------------------------------------
// Enables SPI function on default GPIOs.
// ---------------------------------------------------------------------------
void bcm2835_spi_open( void )
{
// This driver uses the default pins with GPFSEL alternative function ALT0.
bcm2835_gpio_fsel( SPI_GPIO_CE0, BCM2835_GPFSEL_ALT0 );
bcm2835_gpio_fsel( SPI_GPIO_CE1, BCM2835_GPFSEL_ALT0 );
bcm2835_gpio_fsel( SPI_GPIO_MISO, BCM2835_GPFSEL_ALT0 );
bcm2835_gpio_fsel( SPI_GPIO_MOSI, BCM2835_GPFSEL_ALT0 );
bcm2835_gpio_fsel( SPI_GPIO_CLK, BCM2835_GPFSEL_ALT0 );
// Set SPI CS register to default values (0).
volatile uint32_t *paddr;
paddr = bcm2835_spi0 + BCM2835_SPI0_CS / 4;
bcm2835_peri_write( paddr, 0 );
// Clear FIFOs.
bcm2835_peri_write_nb( paddr, BCM2835_SPIO_CS_CLEAR );
}
void SetupGpio(uint8_t gpioIn, uint8_t gpioOut) {
if (!bcm2835_init()) {
exit(EXIT_FAILURE);
}
// Set output pin to HIGH.
// Informs power circuit that pi is on.
bcm2835_gpio_fsel(gpioOut, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_write(gpioOut, HIGH);
// Set PIN_IN to be an input with a pull-down resistor
bcm2835_gpio_fsel(gpioIn, BCM2835_GPIO_FSEL_INPT);
bcm2835_gpio_set_pud(gpioIn, BCM2835_GPIO_PUD_DOWN);
// Wait a while
bcm2835_delay(100);
}
int wheelsInit(char* confPath) {
wheelsLoadConfig(confPath);
if (wheelsConfig == NULL) {
fprintf(stderr,"Cannot initialise wheels module. Please load configuration first!");
return 1;
}
if (!bcm2835_init()) {
return 1;
}
/* Set the mode of the pins to output */
bcm2835_gpio_fsel(wheelsConfig->leftFwd.pin, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(wheelsConfig->leftBack.pin, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(wheelsConfig->rightFwd.pin, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(wheelsConfig->rightBack.pin, BCM2835_GPIO_FSEL_OUTP);
return 0;
}
void bcmInitPin(gpioPinId gpio, bcm2835FunctionSelect fsel)
{
char printBuf[100];
sprintf(printBuf, "Initializing GPIO: GPIO%d=%d [0: input, 1:output]\n", (int)gpio, (int)fsel);
RL_PRINT(printBuf);
// Set GPIO pin to output
bcm2835_gpio_fsel(gpio, fsel);
}
void bcm2835_spi_begin(void)
{
volatile uint32_t* paddr;
/* Set the SPI0 pins to the Alt 0 function to enable SPI0 access on them */
bcm2835_gpio_fsel(RPI_GPIO_P1_26, BCM2835_GPIO_FSEL_ALT0); /* CE1 */
bcm2835_gpio_fsel(RPI_GPIO_P1_24, BCM2835_GPIO_FSEL_ALT0); /* CE0 */
bcm2835_gpio_fsel(RPI_GPIO_P1_21, BCM2835_GPIO_FSEL_ALT0); /* MISO */
bcm2835_gpio_fsel(RPI_GPIO_P1_19, BCM2835_GPIO_FSEL_ALT0); /* MOSI */
bcm2835_gpio_fsel(RPI_GPIO_P1_23, BCM2835_GPIO_FSEL_ALT0); /* CLK */
/* Set the SPI CS register to the some sensible defaults */
paddr = bcm2835_spi0 + BCM2835_SPI0_CS/4;
bcm2835_peri_write(paddr, 0); /* All 0s */
/* Clear TX and RX fifos */
bcm2835_peri_write_nb(paddr, BCM2835_SPI0_CS_CLEAR);
}
int DIS_init() {
if (!bcm2835_init())
return 1;
bcm2835_gpio_fsel(DIS_CS1, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(DIS_CS2, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(DIS_CS3, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(DIS_CS4, BCM2835_GPIO_FSEL_OUTP);
chipSelect(DIS_NONE);
bcm2835_spi_begin();
bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST);
bcm2835_spi_setDataMode(BCM2835_SPI_MODE0);
bcm2835_spi_setClockDivider(DIS_CLOCK_DIVIDER);
bcm2835_spi_chipSelect(BCM2835_SPI_CS_NONE);
return 0;
}
void bcm2835_spi_begin(uint8_t cs)
{
volatile uint32_t* paddr = bcm2835_spi0 + BCM2835_SPI0_CS / 4;
DBG_MSG("IN cs=%d\n", cs);
// Set the SPI0 pins to the Alt 0 function to enable SPI0 access on them
// except if we need custom Chip Select Pin
// printf("bcm2835_spi_begin -> spi_custom_cs = %d \n",cs );
// Do we need custom chip select control or
// drive CE1 manually (because CE1 does not work with hardware)
if ( cs > BCM2835_SPI_CS_NONE || cs == BCM2835_SPI_CS1 ) {
// indicate we will use a custom GPIO port
spi_custom_cs = cs ;
// ok hard CE1 not working, drive it manually
if (cs == BCM2835_SPI_CS1) {
// Dirty Hack CE1 in now custom Chip Select GPIO 26
// the real CE1 pin
spi_custom_cs = RPI_GPIO_P1_26;
bcm2835_gpio_fsel(spi_custom_cs, BCM2835_GPIO_FSEL_OUTP); // BCM2835_GPIO_FSEL_OUTP=0b001
bcm2835_gpio_write(spi_custom_cs, HIGH);
}
// Mask in we use custom CS (not sure it has a real effect)
bcm2835_peri_set_bits(paddr, BCM2835_SPI_CS_NONE, BCM2835_SPI0_CS_CS);
}
// Ok hardware driving of chip select
else {
// Just in case
spi_custom_cs = 0 ;
// Mask in the CS bits of CS
bcm2835_peri_set_bits(paddr, cs, BCM2835_SPI0_CS_CS);
}
// Now we can drive the I/O as asked
if (spi_custom_cs == 0) {
// Not custom CS, so hardware driven
bcm2835_gpio_fsel(RPI_GPIO_P1_24, BCM2835_GPIO_FSEL_ALT0); // CE0
bcm2835_gpio_fsel(RPI_GPIO_P1_26, BCM2835_GPIO_FSEL_ALT0); // CE1
} else {
// so set custom CS as output, High level by default
bcm2835_gpio_fsel(spi_custom_cs, BCM2835_GPIO_FSEL_OUTP); // Custom GPIO
bcm2835_gpio_write(spi_custom_cs, HIGH);
}
// Classic pin, hardware driven
bcm2835_gpio_fsel(RPI_GPIO_P1_21, BCM2835_GPIO_FSEL_ALT0); // MISO
bcm2835_gpio_fsel(RPI_GPIO_P1_19, BCM2835_GPIO_FSEL_ALT0); // MOSI
bcm2835_gpio_fsel(RPI_GPIO_P1_23, BCM2835_GPIO_FSEL_ALT0); // CLK
// Set the SPI CS register to the some sensible defaults
bcm2835_peri_write(paddr, 0); // All 0s
// Clear TX and RX fifos
bcm2835_peri_write_nb(paddr, BCM2835_SPI0_CS_CLEAR);
}
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());
}
void init_lcd_spi(void)
{
bcm2835_init();
bcm2835_spi_begin();
bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST); // The default
bcm2835_spi_setDataMode(BCM2835_SPI_MODE3); // The default
bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_256); // The default
bcm2835_gpio_fsel(RPI_GPIO_P1_16, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(RPI_GPIO_P1_22, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(RPI_GPIO_P1_24, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(RPI_GPIO_P1_26, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_fsel(PENIRQ, BCM2835_GPIO_FSEL_INPT);
bcm2835_gpio_set_pud(PENIRQ, BCM2835_GPIO_PUD_UP);///////////////////////
printf("\n spi-lcd22 test :\n Start .......\n ");
}
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;
}
void PCA9685::init(int bus, int address) {
_i2cbus = bus;
_i2caddr = address;
snprintf(busfile, sizeof(busfile), "/dev/i2c-%d", bus);
bcm2835_init(); //init bcm chip for power switch
bcm2835_gpio_fsel(POWERPIN, BCM2835_GPIO_FSEL_OUTP); //set GPIO17 (pin11) as the power switch pin
SetMainPower(true); //set power on
reset();
//usleep(10*1000);
}
/**
*@brief this function creates pwm signal
*
*This function creates pwm signal
*@param name the name of pwm (eg: pwm_reverse or pwm_forward)
*@param gpio the gpio that will be used to produce a pwm signal
*@return
*/
void pwm_create(struct pwm_data_t *pwm, char *name, int gpio)
{
pwm_data_init(pwm, name, gpio);
bcm2835_gpio_fsel(gpio,BCM2835_GPIO_FSEL_OUTP);
pthread_create(&(pwm->pt), NULL, pwm_thread, (void *) pwm);
struct sched_param param;
memset(¶m, 0, sizeof(param));
param.sched_priority = 40;
pthread_setschedparam(pwm->pt, SCHED_FIFO, ¶m);
}
int main(int argc, char **argv)
{
// If you call this, it will not actually access the GPIO
// Use for testing
// bcm2835_set_debug(1);
int a[MAX_SAMPLES];
int k;
for (k=0;k<MAX_SAMPLES;++k)
a[k] = 100000 + k;
struct timeval tv ;
gettimeofday (&tv, NULL) ;
epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
if (!bcm2835_init()) return 1;
// Set the pin to be an input
bcm2835_gpio_fsel(PIN_15, BCM2835_GPIO_FSEL_INPT); // Ausgang IR Empfänger
// Funktioniert als IR Repeater. IR Empfangsmodul ist an IN PIN_15
// OUT PIN_22 steuert 38kHz Oszillator
while (1) {
int i=0;
int msBegin = millis();
int msEnd = 0;
a[i] = bcm2835_gpio_lev(PIN_15);
if (a[i] == 0) {
++i;
while (i < MAX_SAMPLES) {
a[i] = bcm2835_gpio_lev(PIN_15);
++i;
int p,q;
for (p=0; p < 1000; ++p)
q=p;
}
msEnd = millis();
printf("%d - %d, %d samples, %d ms per 100 samples\n", msBegin, msEnd, MAX_SAMPLES, (msEnd-msBegin)*100/MAX_SAMPLES);
int j;
int nLastPrint = 0;
for (j=0;j<MAX_SAMPLES;++j) {
if (j>0 && a[j] != a[j-1] && a[j] == 0) {
printf(" (%d)\n", j-nLastPrint);
nLastPrint=j;
}
printf("%d", (a[j]) ? 0 : 1);
}
printf("\n");
}
}
return 0;
}
void bcm2835_i2c_begin(void)
{
#ifdef I2C_V1
volatile uint32_t* paddr = bcm2835_bsc0 + BCM2835_BSC_DIV/4;
// Set the I2C/BSC0 pins to the Alt 0 function to enable I2C access on them
bcm2835_gpio_fsel(RPI_GPIO_P1_03, BCM2835_GPIO_FSEL_ALT0); // SDA
bcm2835_gpio_fsel(RPI_GPIO_P1_05, BCM2835_GPIO_FSEL_ALT0); // SCL
#else
volatile uint32_t* paddr = bcm2835_bsc1 + BCM2835_BSC_DIV/4;
// Set the I2C/BSC1 pins to the Alt 0 function to enable I2C access on them
bcm2835_gpio_fsel(RPI_V2_GPIO_P1_03, BCM2835_GPIO_FSEL_ALT0); // SDA
bcm2835_gpio_fsel(RPI_V2_GPIO_P1_05, BCM2835_GPIO_FSEL_ALT0); // SCL
#endif
// Read the clock divider register
uint16_t cdiv = bcm2835_peri_read(paddr);
// Calculate time for transmitting one byte
// 1000000 = micros seconds in a second
// 9 = Clocks per byte : 8 bits + ACK
i2c_byte_wait_us = ((float)cdiv / BCM2835_CORE_CLK_HZ) * 1000000 * 9;
}
int main(int argc, char *argv[])
{
if (!bcm2835_init())
{
printf("Failed to init bcm2835\n");
return 1;
}
// Set the pin to be an output
bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP);
int rep;
char *on_or_off = NULL;
on_or_off = argv[1];
if (!(on_or_off))
{
printf("Usage %s on|off \n",argv[0]);
exit(2);
}
usleep(500);
bcm2835_gpio_write(PIN, LOW);
usleep(8000);
for (rep=0; rep<10; rep++);
//recall INVERSION out a 1 to ge a zero!
{
{
bcm2835_gpio_write(PIN, LOW);
usleep(8000);
//above is gap between burst
bgas_main();
//########################################################
if (strcmp(on_or_off,"on")==0){
bgas_on();
/* # It is on */
} else if (strcmp(on_or_off,"off") == 0) {
bgas_off();
/* # It is off */
}
// ##################################################################
}
// printf ("loop done\n");
}
bcm2835_gpio_write(PIN, LOW);
bcm2835_close();
return 0;
} // main
