void d8x8matrix_write(const device_info_t *device_info, const char *buf, uint8_t nbyte) {
char c;
uint8_t i;
int j, k;
if (nbyte > device_info->internal.count) {
nbyte = device_info->internal.count;
}
for (i = 1; i < 9; i++) {
k = (int) nbyte;
for (j = 0; j < ((int) device_info->internal.count * 2) - ((int) nbyte * 2); j = j + 2) {
spi_data[j] = MAX7219_REG_NOOP;
spi_data[j + 1] = 0;
}
while (--k >= 0) {
c = buf[k];
spi_data[j++] = i;
spi_data[j++] = rotate((uint8_t) c, 8 - i);
}
if (device_info->chip_select == SPI_CS2) {
bcm2835_aux_spi_setClockDivider(device_info->internal.clk_div);
bcm2835_aux_spi_writenb((const char *) spi_data, (uint32_t) j);
} else {
bcm2835_spi_setClockDivider(device_info->internal.clk_div);
bcm2835_spi_chipSelect(device_info->chip_select);
bcm2835_spi_writenb((const char *) spi_data, (uint32_t) j);
}
}
}
inline static void _draw_char(int c, uint32_t x, uint32_t y, uint16_t fore, uint16_t back) {
uint32_t i, j;
uint8_t line;
unsigned char *p = (unsigned char *) cp437_font + (c * (int) FONT_CHAR_H);
uint16_t buffer[FONT_CHAR_H * FONT_CHAR_W];
uint16_t *q = buffer;
for (i = 0; i < FONT_CHAR_H; i++) {
line = (uint8_t) *p++;
for (j = 0; j < FONT_CHAR_W; j++) {
if ((line & 0x1) != 0) {
*q = __builtin_bswap16(fore);
} else {
*q = __builtin_bswap16(back);
}
line >>= 1;
q++;
}
}
write_command(0x2A);
write_data_word(x);
write_data_word(x + FONT_CHAR_H - 1);
write_command(0x2B);
write_data_word(y);
write_data_word(y + FONT_CHAR_W - 1);
write_command(0x2C);
bcm2835_spi_writenb((char *) buffer, 2 * FONT_CHAR_H * FONT_CHAR_W);
}
//void bcm2835_spi_writenb(char* buf, uint32_t len);
/// Call bcm2835_spi_writenb with 2 parameters
/// \par Refer
/// \par Modify
void ope_spi_writenb(void)
{
uint32_t len;
get_int_code();
get_int_code();
len = *(uint32_t *)(buff+5);
bcm2835_spi_writenb( bi_send_buff, len );
}
void bw_spi_dio_output(device_info_t *device_info, uint8_t pins) {
char cmd[3];
cmd[0] = device_info->slave_address;
cmd[1] = BW_PORT_WRITE_SET_ALL_OUTPUTS;
cmd[2] = pins;
dio_spi_setup(device_info);
bcm2835_spi_writenb(cmd, sizeof(cmd) / sizeof(char));
uwait(BW_DIO_SPI_BYTE_WAIT_US);
}
void bw_spi_dio_fsel_mask(device_info_t *device_info, uint8_t mask) {
char cmd[3];
cmd[0] = device_info->slave_address;
cmd[1] = BW_PORT_WRITE_IO_DIRECTION;
cmd[2] = mask;
dio_spi_setup(device_info);
bcm2835_spi_writenb(cmd, sizeof(cmd) / sizeof(char));
uwait(BW_DIO_SPI_BYTE_WAIT_US);
}
// write data via SPI to tft
// ----------------------------------------------------------
void TFT_SPI_data_out ( uint16_t data )
{
union my_union number;
char buffer[2];
number.value = data;
buffer[0] = (char) number.split.high;
buffer[1] = (char) number.split.low;
bcm2835_spi_writenb( &buffer[0], 2 );
}
void ili9340_clear(void) {
write_command(0x2A);
write_data_word(0);
write_data_word(239);
write_command(0x2B);
write_data_word(0);
write_data_word(319);
write_command(0x2C);
bcm2835_spi_writenb((char *) buffer, 2 * ILI9340_HEIGHT * ILI9340_WIDTH);
}
void spi_transfern(char *buf, uint32_t len) {
int ret;
//dump("TR tx", (uint8_t *)buf, len);
#ifdef BCM
bcm2835_spi_transfern(buf, len);
#else
uint8_t *rx = malloc(len);
struct spi_ioc_transfer tr = {
.tx_buf = (unsigned long)buf,
.rx_buf = (unsigned long)rx,
.len = len,
.delay_usecs = delay,
.speed_hz = speed,
.bits_per_word = bits,
};
ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
if (ret < 1) {
free(rx);
pabort("can't send spi message");
}
memcpy(buf, rx, len);
free(rx);
#endif
}
void spi_writenb(char * buf, uint32_t len) {
int ret;
dump("WR tx", (uint8_t *)buf, len);
#ifdef BCM
bcm2835_spi_writenb(buf, len);
#else
struct spi_ioc_transfer tr = {
.tx_buf = (unsigned long)buf,
.rx_buf = (unsigned long)0,
.len = len,
.delay_usecs = delay,
.speed_hz = speed,
.bits_per_word = bits,
};
ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
if (ret < 1)
pabort("can't send spi message");
#endif
}
void bw_spi_dimmer_output(const device_info_t *device_info, uint8_t value) {
char cmd[3];
cmd[0] = (char) device_info->slave_address;
cmd[1] = (char) BW_PORT_WRITE_DIMMER;
cmd[2] = (char) value;
if (device_info->chip_select == SPI_CS2) {
bcm2835_aux_spi_setClockDivider(device_info->internal.clk_div);
bcm2835_aux_spi_writenb(cmd, sizeof(cmd) / sizeof(cmd[0]));
} else {
bcm2835_spi_setClockDivider(device_info->internal.clk_div);
bcm2835_spi_chipSelect(device_info->chip_select);
bcm2835_spi_setDataMode(BCM2835_SPI_MODE0);
bcm2835_spi_writenb(cmd, sizeof(cmd) / sizeof(cmd[0]));
}
}
void ee_write(unsigned int BufferOffset,unsigned char data)
{
unsigned char temp[]={0x84,0xff};
bcm2835_gpio_write(PIN_CS, LOW); /*must be called*/
delay_ms(500);
bcm2835_spi_writenb(temp,2);
delay_ms(50);
bcm2835_spi_transfer((unsigned char)(BufferOffset>>8));
delay_ms(50);
bcm2835_spi_transfer((unsigned char)BufferOffset);
delay_ms(50);
bcm2835_spi_transfer(data);
delay_ms(50);
bcm2835_gpio_write(PIN_CS, HIGH); /*must be called*/
delay_ms(300);
}
static void write_all(const device_info_t *device_info, const uint8_t reg, const uint8_t data) {
uint8_t i;
if ((device_info->internal.count * 2) > sizeof(spi_data)) {
return;
}
for (i = 0; i < (device_info->internal.count * 2); i = i + 2) {
spi_data[i] = reg;
spi_data[i+1] = data;
}
if (device_info->chip_select == SPI_CS2) {
bcm2835_aux_spi_setClockDivider(device_info->internal.clk_div);
bcm2835_aux_spi_writenb((const char *) spi_data, device_info->internal.count * 2);
} else {
bcm2835_spi_setClockDivider(device_info->internal.clk_div);
bcm2835_spi_chipSelect(device_info->chip_select);
bcm2835_spi_writenb((const char *) spi_data, device_info->internal.count * 2);
}
}
inline void ArduiPi_OLED::fastSPIwrite(char* tbuf, uint32_t len) {
bcm2835_spi_writenb(tbuf, len);
}
int main(int argc, char **argv)
{
int16_t ledIndexCounter = 0, scanPasses=0, colourIndex=0;
initData();
//Initiate the SPI Data Frame
if (!bcm2835_init())
{
printf("bcm2835_init failed. Are you running as root??\n");
return 1;
}
if (!bcm2835_spi_begin())
{
printf("bcm2835_spi_begin failedg. Are you running as root??\n");
return 1;
}
bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST); // The default
bcm2835_spi_setDataMode(BCM2835_SPI_MODE0); // The default
/*
BCM2835_SPI_MODE0 CPOL = 0, CPHA = 0
BCM2835_SPI_MODE1 CPOL = 0, CPHA = 1
BCM2835_SPI_MODE2 CPOL = 1, CPHA = 0
BCM2835_SPI_MODE3 CPOL = 1, CPHA = 1
*/
bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_16); // The default
/*
BCM2835_SPI_CLOCK_DIVIDER_65536 65536 = 262.144us = 3.814697260kHz
BCM2835_SPI_CLOCK_DIVIDER_32768 32768 = 131.072us = 7.629394531kHz
BCM2835_SPI_CLOCK_DIVIDER_16384 16384 = 65.536us = 15.25878906kHz
BCM2835_SPI_CLOCK_DIVIDER_8192 8192 = 32.768us = 30/51757813kHz
BCM2835_SPI_CLOCK_DIVIDER_4096 4096 = 16.384us = 61.03515625kHz
BCM2835_SPI_CLOCK_DIVIDER_2048 2048 = 8.192us = 122.0703125kHz
BCM2835_SPI_CLOCK_DIVIDER_1024 1024 = 4.096us = 244.140625kHz
BCM2835_SPI_CLOCK_DIVIDER_512 512 = 2.048us = 488.28125kHz
BCM2835_SPI_CLOCK_DIVIDER_256 256 = 1.024us = 976.5625kHz
BCM2835_SPI_CLOCK_DIVIDER_128 128 = 512ns = = 1.953125MHz
BCM2835_SPI_CLOCK_DIVIDER_64 64 = 256ns = 3.90625MHz
BCM2835_SPI_CLOCK_DIVIDER_32 32 = 128ns = 7.8125MHz
BCM2835_SPI_CLOCK_DIVIDER_16 16 = 64ns = 15.625MHz
BCM2835_SPI_CLOCK_DIVIDER_8 8 = 32ns = 31.25MHz
BCM2835_SPI_CLOCK_DIVIDER_4 4 = 16ns = 62.5MHz
BCM2835_SPI_CLOCK_DIVIDER_2 2 = 8ns = 125MHz, fastest you can get
*/
bcm2835_spi_chipSelect(BCM2835_SPI_CS0); // The default
bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW); // the default
for(colourIndex=0; colourIndex<rainbowSize*10; colourIndex+=5)
{
getColour(colourIndex%rainbowSize, tmpColour);
//set 1st Pixel
ledDataBlock[8]=255;
ledDataBlock[9]=tmpColour[2];
ledDataBlock[10]=tmpColour[1];
ledDataBlock[11]=tmpColour[0];
//push the array
for(ledIndexCounter=(spiFrameLength-(endFrameLength*bytesPerLED))-bytesPerLED; ledIndexCounter>8; ledIndexCounter-=bytesPerLED)
{
ledDataBlock[ledIndexCounter] = ledDataBlock[ledIndexCounter-bytesPerLED];
ledDataBlock[ledIndexCounter+1] = ledDataBlock[ledIndexCounter+1-bytesPerLED];
ledDataBlock[ledIndexCounter+2] = ledDataBlock[ledIndexCounter+2-bytesPerLED];
ledDataBlock[ledIndexCounter+3] = ledDataBlock[ledIndexCounter+3-bytesPerLED];
}
//send to LEDs
bcm2835_spi_writenb(ledDataBlock, spiFrameLength);
bcm2835_delay(5);
}
//clear and render
initData();
bcm2835_spi_writenb(ledDataBlock, spiFrameLength);
//close the spi bus
bcm2835_spi_end();
bcm2835_close();
return 0;
}
/**
*@brief Writes an array of bytes to the SPI bus
*@param buff Pointer to array of char data.
*@param length Length of data array.
*@return none
*/
void SPI_Write_Array(char* buff, unsigned int length)
{
bcm2835_spi_writenb(buff,length);
}
