int cmd_spi_rx(spi_t *spi,char *data, size_t max_len, int timeout_ms)
{
int i;
/* wait for ready from client */
int size;
int result = wait_for_ready(spi, timeout_ms, &size);
if(result < 0) {
return result;
}
/* nothing to read */
if(size == 0) {
return 0;
}
/* send RX data command */
buffer[0] = CMD_RX;
buffer[1] = (char)(size);
result = spi_transmit(spi,NULL,buffer,2);
if(result < 0) {
return result;
}
/* receive data */
result = spi_transmit(spi,data,NULL,size);
if(result < 0) {
return result;
}
return size;
}
void mfrc522_write(uint8_t reg, uint8_t data)
{
rc522_select();
spi_transmit((reg << 1) & 0x7E, SKIP_RECEIVE, RC522_SPI_CH);
spi_transmit(data, SKIP_RECEIVE, RC522_SPI_CH);
rc522_release();
}
void lcd_data(int *spih, uint16_t data) {
uint8_t buff[4] = { 0,0,0,0};
uint8_t r;
#ifdef _DEBUG_
printf("LCD_DATA(%04X)\n", data);
#endif
buff[1] = data>>8;
buff[2] = data&0x00ff;
buff[3] = 0x15; // 0x15 - DATA_BE const from ili9341.c (BE is short form "before")
r = spi_transmit(spih, &buff[0], 4, LCD_SPI_SPEED, LCD_SPI_BITS_PER_WORD);
if (r < 0) {
fprintf(stderr, "SPI.LCD_DATA_1(0x%4X) error (%d,%d) : %s", data, r, errno, strerror(errno));
return;
}
buff[1] = data>>8;
buff[2] = data&0x00ff;
buff[3] = 0x1F; // 0x1F - DATA_AF const from ili9341.c (AF is short form "after")
r = spi_transmit(spih, &buff[0], 4, LCD_SPI_SPEED, LCD_SPI_BITS_PER_WORD);
if (r < 0) {
fprintf(stderr, "SPI.LCD_DATA_2(0x%4X) error (%d,%d) : %s", data, r, errno, strerror(errno));
}
}
void lcd_cmd(int *spih, uint16_t cmd) {
uint8_t buff[4] = { 0,0,0,0};
uint8_t r;
#ifdef _DEBUG_
printf("LCD_CMD(%04X)\n", cmd);
#endif
buff[1] = cmd>>8;
buff[2] = cmd&0x00ff;
buff[3] = 0x11; // 0x15 - DATA_BE const from ili9341.c (BE is short form "before")
r = spi_transmit(spih, &buff[0], 4, LCD_SPI_SPEED, LCD_SPI_BITS_PER_WORD);
if (r < 0) {
fprintf(stderr, "SPI.LCD_CMD_1(%4X) error (%d,%d) : %s", cmd, r, errno, strerror(errno));
}
buff[1] = cmd>>8;
buff[2] = cmd&0x00ff;
buff[3] = 0x1B; // 0x1F - DATA_AF const from ili9341.c (AF is short form "after")
r = spi_transmit(spih, &buff[0], 4, LCD_SPI_SPEED, LCD_SPI_BITS_PER_WORD);
if (r < 0) {
fprintf(stderr, "SPI.LCD_CMD_2(%4X) error (%d,%d) : %s", cmd, r, errno, strerror(errno));
}
}
void lcd_reset(int *spih) {
uint8_t buff[4] = { 0,0,0,0 };
uint8_t r;
#ifdef _DEBUG_
printf("LCD_RESET\n");
#endif
// set Reset LOW
r = spi_transmit(spih, &buff[0], 4, LCD_SPI_SPEED, LCD_SPI_BITS_PER_WORD);
if (r < 0) {
fprintf(stderr, "SPI.LCD_RESET_1 error (%d) : %s", errno, strerror(errno));
}
delayms(50);
// set Reset High
buff[0]=buff[1]=buff[2] = 0;
buff[3]=0x01;
r = spi_transmit(spih, &buff[0], 4, LCD_SPI_SPEED, LCD_SPI_BITS_PER_WORD);
if (r < 0) {
fprintf(stderr, "SPI.LCD_RESET_2 error (%d) : %s", errno, strerror(errno));
}
#ifdef _DEBUG_
printf("LCD_RESET end.\n");
#endif
delayms(200);
}
void lcd_reset(void) {
uint8_t buff[4] = { 0,0,0,0 };
#ifdef _DEBUG_
printf("LCD_RESET\n");
#endif
// Select LCD
//bcm2835_spi_chipSelect(BCM2835_SPI_CS1);
// set Reset LOW
spi_transmit(LCD_CS, &buff[0], 4);
delayms(50);
// set Reset High
buff[0]=buff[1]=buff[2] = 0;
buff[3]=0x01;
spi_transmit(LCD_CS, &buff[0], 4);
#ifdef _DEBUG_
printf("LCD_RESET end.\n");
#endif
delayms(200);
}
void mfrc522_write(uint8_t reg, uint8_t data)
{
ENABLE_CHIP();
spi_transmit((reg<<1)&0x7E);
spi_transmit(data);
DISABLE_CHIP();
}
void send_spi_position(uint8_t axis_idx) {
JOG_SPI_PORT &= ~(1<<JOG_SPI_SS); // Slave select active low
spi_transmit(axis_idx); // TEST DATA
spi_transmit(255);
spi_transmit(85);
spi_transmit(0);
JOG_SPI_PORT |= (1<<JOG_SPI_SS);
}
uint8_t mfrc522_read(uint8_t reg)
{
uint8_t data;
rc522_select();
spi_transmit(((reg << 1) & 0x7E) | 0x80, SKIP_RECEIVE, RC522_SPI_CH);
data = spi_transmit(0x00, RECEIVE_BYTE, RC522_SPI_CH);
rc522_release();
return data;
}
uint8_t mfrc522_read(uint8_t reg)
{
uint8_t data;
ENABLE_CHIP();
spi_transmit(((reg<<1)&0x7E)|0x80);
data = spi_transmit(0x00);
DISABLE_CHIP();
return data;
}
char mcp2515_read_status()
{
char output;
spi_select();
spi_transmit(MCP_READ);
spi_transmit(MCP_CANSTAT);
output = spi_receive();
spi_deselect();
return output;
}
/**
* @brief sends a command to the SD card
* @param cmd - unsigned char, command to send to the SD card
* @param arg - unsigned long, argument of the command sent
* @return unsigned char - response byte
*/
unsigned char sd_send_command(unsigned char cmd, unsigned long arg)
{
unsigned char response, retry = 0, status;
// SD card accepts byte address while SDHC accepts block address in multiples of 512
// so, if it's SD card we need to convert block address
// into corresponding byte address by
// multipying it with 512. which is equivalent to shifting it left 9 times
// following 'if' loop does that
if(sdhc_flag == 0)
if(cmd == READ_SINGLE_BLOCK ||
cmd == READ_MULTIPLE_BLOCKS ||
cmd == WRITE_SINGLE_BLOCK ||
cmd == WRITE_MULTIPLE_BLOCKS ||
cmd == ERASE_BLOCK_START_ADDR||
cmd == ERASE_BLOCK_END_ADDR )
{
arg = arg << 9;
}
SD_CS_ASSERT;
spi_transmit(cmd | 0x40); //send command, first two bits always '01'
spi_transmit(arg >> 24);
spi_transmit(arg >> 16);
spi_transmit(arg >> 8);
spi_transmit(arg);
// It is compulsory to send correct CRC for CMD8 (CRC=0x87) & CMD0 (CRC=0x95)
if(cmd == SEND_IF_COND)
spi_transmit(0x87); // for remaining commands, CRC is ignored in SPI mode
else
spi_transmit(0x95);
while((response = spi_receive()) == 0xff) // wait response
if(retry++ > 0xfe) break; // time out error
if(response == 0x00 && cmd == 58) // checking response of CMD58
{
status = spi_receive() & 0x40; // first byte of the OCR register (bit 31:24)
if(status == 0x40) sdhc_flag = 1; // we need it to verify SDHC card
else sdhc_flag = 0;
spi_receive(); // remaining 3 bytes of the OCR register are ignored here
spi_receive(); // one can use these bytes to check power supply limits of SD
spi_receive();
}
spi_receive(); // extra 8 CLK
SD_CS_DEASSERT;
return response;
}
void mcp2515_bit_modify(char addr, char mask_byte, char data)
{
spi_select();
spi_transmit(MCP_BITMOD);
spi_transmit(addr);
spi_transmit(mask_byte);
spi_transmit(data);
spi_deselect();
}
void mcp2515_write(char addr, char data)
{
spi_select();
spi_transmit(MCP_WRITE);
spi_transmit(addr);
spi_transmit(data);
spi_deselect();
}
char mcp2515_read (char addr){
char result;
spi_select();
spi_transmit(MCP_READ);
spi_transmit(addr);
result = spi_receive();
spi_deselect();
return result;
}
void ST7540_setup(){
reg_acc();
tx_mode();
while ((PIN_SPI & (1<<SCK))!=0);
ss_clear();
//Send configuration bytes to ST7540 control register
spi_transmit(0x13);
spi_transmit(0xB2);
spi_transmit(0x32);
ss_set();
}
/**
* @brief Writes a single block of SD Card. Data that is written is put into the
* buffer variables and writes out the 512 charachters.
* @param start_block - unsigned long, describes which block you want to right
* @return unsigned char - 0 if no error
* response byte will be sent if an error
*/
unsigned char sd_write_single_block(unsigned long start_block)
{
unsigned char response;
unsigned int i, retry = 0;
response = sd_send_command(WRITE_SINGLE_BLOCK, start_block); //write a Block command
if(response != 0x00) return response; //check for SD status: 0x00 - OK (No flags set)
SD_CS_ASSERT;
spi_transmit(0xfe); //Send start block token 0xfe (0x11111110)
for(i = 0; i < 512; i++) //send 512 bytes data
spi_transmit(buffer[i]);
spi_transmit(0xff); //transmit dummy CRC (16-bit), CRC is ignored here
spi_transmit(0xff);
response = spi_receive();
if((response & 0x1f) != 0x05) //response= 0xXXX0AAA1 ; AAA='010' - data accepted
{ //AAA='101'-data rejected due to CRC error
SD_CS_DEASSERT; //AAA='110'-data rejected due to write error
return response;
}
while(!spi_receive()) //wait for SD card to complete writing and get idle
if(retry++ > 0xfffe)
{
SD_CS_DEASSERT;
return 1;
}
SD_CS_DEASSERT;
spi_transmit(0xff); //just spend 8 clock cycle delay before reasserting the CS line
SD_CS_ASSERT; //re-asserting the CS line to verify if card is still busy
while(!spi_receive()) //wait for SD card to complete writing and get idle
if(retry++ > 0xfffe)
{
SD_CS_DEASSERT;
return 1;
}
SD_CS_DEASSERT;
return 0;
}
static int wait_for_ready(spi_t *spi,int timeout_ms,int *result_size)
{
int i;
/* wait for READY status with timeout */
for(i=0; i<timeout_ms; i++) {
int result = spi_transmit(spi,buffer,NULL,2);
if(result < 0) {
return result;
}
//printf("%02x %02x\n", (int)buffer[0], (int)buffer[1]);
// found READY ?
if((buffer[1] & READY_MASK) == READY_FLAG) {
if(result_size != NULL) {
*result_size = (int)(buffer[1] & SIZE_MASK);
}
return 0;
}
usleep(1000);
}
return -CMD_ERR_NOT_READY;
}
void max1168_read_channel(int channel) {
max1168_current_channel = channel;
max1168_read_channel_package.data[0] = (channel << 5) << 8;
switch (channel){
case 0:
max1168_read_channel_package.spi_interrupt_handler = &max1168_on_spi_int_channel0;
break;
case 1:
max1168_read_channel_package.spi_interrupt_handler = &max1168_on_spi_int_channel1;
break;
case 2:
max1168_read_channel_package.spi_interrupt_handler = &max1168_on_spi_int_channel2;
break;
case 3:
max1168_read_channel_package.spi_interrupt_handler = &max1168_on_spi_int_channel3;
break;
case 4:
max1168_read_channel_package.spi_interrupt_handler = &max1168_on_spi_int_channel4;
break;
case 5:
max1168_read_channel_package.spi_interrupt_handler = &max1168_on_spi_int_channel5;
break;
case 6:
max1168_read_channel_package.spi_interrupt_handler = &max1168_on_spi_int_channel6;
break;
case 7:
max1168_read_channel_package.spi_interrupt_handler = &max1168_on_spi_int_channel7;
break;
}
spi_transmit(&max1168_read_channel_package);
return;
}
void eeprom_93c06_write_short(unsigned char addr, unsigned short data)
{
unsigned char trash;
spi_select();
eeprom_93c06_start_bit();
spi_transmit(SPI_OP_93C06_WRITE_MASK | SPI_93C06_ADDR_MASK(addr), &trash);
spi_transmit(SPI_93C06_WRITE_DATA_BYTE1(data), &trash);
spi_transmit(SPI_93C06_WRITE_DATA_BYTE2(data), &trash);
spi_deselect();
/* Operation takes 2ms to be guaranteed. */
msleep(2);
}
void mcp2515_request_to_send(int reg)
{
spi_select();
spi_transmit(reg);
spi_deselect();
}
void mcp2515_reset()
{
spi_select();
spi_transmit(MCP_RESET);
spi_deselect();
}
void ST7540_transmit(uint8_t temp){
//Set the appropriate flags and transmit
tx_mode();
ss_clear();
spi_transmit(temp);
ss_set();
rx_mode();
}
void lcd_cmd(uint16_t cmd) {
uint8_t b1[4], b2[4];
memset(&b1,0,sizeof(b1));
memset(&b2,0,sizeof(b2));
// setup buffers
b2[1] = b1[1] = cmd>>8;
b2[2] = b1[2] = cmd&0x00ff;
b1[3] = 0x11; // 0x11 - CMD_BE const from ili9341.c (BE is short form "before")
b2[3] = 0x1B; // 0x1B - CMD_AF const from ili9341.c (AF is short form "after")
// Select LCD
//bcm2835_spi_chipSelect(BCM2835_SPI_CS1);
// send it - prepare
spi_transmit(LCD_CS, &b1[0], 4);//bcm2835_spi_transfern(&b1, 4);
// send it - store in LCD
spi_transmit(LCD_CS, &b2[0], 4); //bcm2835_spi_transfern(&b2, 4);
}
void eeprom_93c06_read_short(unsigned char addr, unsigned short *data)
{
unsigned char r1, r2, r3;
unsigned char trash;
spi_select();
eeprom_93c06_start_bit();
spi_transmit(SPI_OP_93C06_READ_MASK | SPI_93C06_ADDR_MASK(addr), &trash);
spi_transmit(SPI_DONT_CARE, &r1);
spi_transmit(SPI_DONT_CARE, &r2);
spi_transmit(SPI_DONT_CARE, &r3);
spi_deselect();
*data = SPI_93C06_READ_DATA_ASSEMBLE(r1, r2, r3);
}
void eeprom_93c06_enable_write(int en)
{
unsigned char trash;
unsigned char op = (en ? SPI_OP_93C06_EWEN_MASK : SPI_OP_93C06_EWDS_MASK);
spi_select();
eeprom_93c06_start_bit();
spi_transmit(op, &trash);
spi_deselect();
}
// Set each LEDs on or off state from a 16-bit value.
//
// LED d1 = bit 1
// LED d2 = bit 2
//
// etc, in the pattern:
//
// 1 2 3 4
// 5 6 7 8
// 9 10 11 12
// 13 14 15 16
//
void led_set_state(uint16_t new_state)
{
// If no lights have changed, transmit nothing. This saves bandwidth on
// the SPI bus for more important things.
if (g_led_state == new_state) return;
// Transmit Most Significant Byte first.
spi_transmit(new_state >> 8);
spi_transmit(new_state & 0xff);
// Latch the result to the LEDs by pulsing high.
PORTB |= LED_LATCH;
PORTB &= ~LED_LATCH;
// record the state.
g_led_state = new_state;
}
int main()
{
uint8_t data=0;
_delay_ms(50);
spi_init();
while(1)
{
ENABLE_CHIP();
spi_transmit(data++);
DISABLE_CHIP();
_delay_ms(1000);
}
}
void sca3000_read_res(void) {
spi_package package;
package.bit_mode = SPI_8_BIT_MODE;
/* trigger 2 bytes read */
unsigned char cmd=0x05<<2;
package.data[0] = cmd;
package.data[1] = 0;
package.data[2] = 0;
package.data[3] = 0;
package.data[4] = 0;
package.data[5] = 0;
package.data[6] = 0;
package.length = 7;
package.slave_select = &sca3000_select;
package.slave_unselect = &sca3000_unselect;
package.spi_interrupt_handler = &sca3000_on_spi_int;
spi_transmit(&package);
}
int cmd_spi_tx(spi_t *spi,const char *data, size_t len, int timeout_ms)
{
if(len > CMD_MAX_SIZE)
return -CMD_ERR_TOO_LONG;
/* wait for ready from slave */
int result = wait_for_ready(spi, timeout_ms, NULL);
if(result < 0) {
return result;
}
/* setup TX command header with data */
buffer[0] = CMD_TX;
buffer[1] = (char)(len & 0xff);
memcpy(buffer+2,data,len);
/* send to slave */
return spi_transmit(spi,NULL,buffer,len+2);
}
