void LCD_write_4(char byteToSend)
{
unsigned char sendByte = byteToSend;
sendByte &= 0x0F;
//Thanks to Coastie Ryan Hub I got this line!
sendByte |= LCDCON;
sendByte &= 0x7F;
SPI_send(sendByte);
__delay_cycles(42);
sendByte |= 0x80;
SPI_send(sendByte);
__delay_cycles(42);
sendByte &= 0x7F;
SPI_send(sendByte);
__delay_cycles(42);
}
void display_init(void)
{
SPI_set_sample_rising_edge();
/* Disable shutdown mode */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_SHUTDOWN);
SPI_send(0x1);
SPI_deselect(SPI_CS_MAX7221);
/* Disable display test mode */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DISPLAY_TEST);
SPI_send(0x0);
SPI_deselect(SPI_CS_MAX7221);
/* Set the decoding mode to Code-B font for all digits */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DECODE_MODE);
SPI_send(0xFF);
SPI_deselect(SPI_CS_MAX7221);
/* Set the display intensity */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_INTENSITY);
SPI_send(0xF);
SPI_deselect(SPI_CS_MAX7221);
/* Set the scan limit to include all 8 digits */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_SCAN_LIMIT);
SPI_send(0x07);
SPI_deselect(SPI_CS_MAX7221);
}
void LCD_write_4(char byteToSend)
{
unsigned char sendByte = byteToSend;
sendByte &= 0x0F;
sendByte |= LCDCON;
sendByte &= 0x7f;
SPI_send(sendByte);
delayMilli();
sendByte |= 0x80;
SPI_send(sendByte);
delayMilli();
sendByte &= 0x7F;
SPI_send(sendByte);
delayMilli();
}
void MCP_write(uint8_t address, uint8_t data){
toggle_cs(0);
SPI_send(MCP_WRITE); //Send write command 0b00000010
SPI_send(address);
SPI_send(data);
toggle_cs(1);
}
uint8_t MCP_read(uint8_t address){
toggle_cs(0);
SPI_send(MCP_READ); //Send read command 0b00000011
SPI_send(address);
uint8_t data = SPI_receive();
toggle_cs(1);
return data;
}
void MCP_bit_modify(uint8_t address, uint8_t mask, uint8_t data){
toggle_cs(0);
SPI_send(MCP_BITMOD); // send bit modify command: 0b00000101
SPI_send(address);
SPI_send(mask);
SPI_send(data);
toggle_cs(1);
}
void LCD_write_4(char sendByte) {
sendByte &= 0x0F; // ensure upper half of byte is clear
sendByte |= LCDcon; // set LCD control nibble
sendByte &= 0x7F; // set E low
SPI_send(sendByte); //call #SPI_send
delayMicro();
sendByte |= 0x80; // set E high
SPI_send(sendByte); //call #SPI_send
delayMicro();
sendByte &= 0x7F; // set E low
SPI_send(sendByte); //call #SPI_send
delayMicro();
}
char SPI_read() {
// Send dummy data
SPI_send(0);
//Return data register
return SPDR;
}
void LCDINIT()
{
writeCommandNibble(0x03);
writeCommandNibble(0x03);
writeCommandNibble(0x03);
writeCommandNibble(0x02);
writeCommandByte(0x28);
writeCommandByte(0x0C);
writeCommandByte(0x01);
writeCommandByte(0x06);
writeCommandByte(0x01);
writeCommandByte(0x02);
SPI_send(0);
delayMicro();
}
void LCDinit()
{
writeCommandNibble(0x03);
writeCommandNibble(0x03);
writeCommandNibble(0x03);
writeCommandNibble(0x02);
writeCommandByte(0x28);
writeCommandByte(0x0C);
writeCommandByte(0x01);
writeCommandByte(0x06);
writeCommandByte(0x01);
writeCommandByte(0x02);
SPI_send(0);
delayMilli();
}
char SD_initialize(void) {
char i;
cli();
// ]r:10
CS_HIGH();
for(i=0; i<10; i++) // idle for 1 bytes / 80 clocks
SPI_send(0xFF);
// [0x40 0x00 0x00 0x00 0x00 0x95 r:8] until we get "1"
for(i=0; i<10 && SD_command(0x40, 0x00000000, 0x95, 8) != 1; i++) {
delay_ms(100);
}
if(i == 10) // card did not respond to initialization
return CARD_NOT_INIT;
// CMD1 until card comes out of idle, but maximum of 10 times
for(i=0; i<10 && SD_command(0x41, 0x00000000, 0xFF, 8) != 0; i++) {
delay_ms(100);
}
if(i == 10) // card did not come out of idle
return CARD_IN_IDLE;
// SET_BLOCKLEN to 512
SD_command(0x50, 0x00000200, 0xFF, 8);
sd_sector = sd_pos = 0;
return CARD_INIT;
}
void initLCD()
{
set_SS_hi();
writeCommandNibble(0x03);
writeCommandNibble(0x03);
writeCommandNibble(0x03);
writeCommandNibble(0x02);
writeCommandByte(0x28);
writeCommandByte(0x0C);
writeCommandByte(0x01);
writeCommandByte(0x06);
writeCommandByte(0x01);
writeCommandByte(0x02);
SPI_send(0);
__delay_cycles(42);
}
/**
* For talking to the MCP4822 DAC
*/
void DAC_updateVoltage(uint16_t channel, uint16_t value) {
// Validate channel selection
if(channel <= 1) {
// Cap value to 12 bits only
if(value > 0x0FFF) {
value = 0x0FFF;
}
char txBuf[2];
uint16_t cmd = 0x3000 | (value & 0x0FFF);
if(channel) cmd |= 0x8000;
txBuf[1] = cmd & 0x00FF;
txBuf[0] = __swap_bytes(cmd) & 0x00FF;
CLR_BITS(SPI_PORT(OUT),SSEL | nLDAC); // CS~ falling edge, hold nLDAC low
SPI_send(txBuf, 2);
SET_BITS(SPI_PORT(OUT),SSEL); // CS~ Rising edge. Because nLDAC is low, DAC output changes on rising CS~ edge.
}
}
uint8_t MCP_rx_status(){
toggle_cs(0);
SPI_send(MCP_RX_STATUS); // send read rx status code: 0b10110000
uint8_t data = SPI_receive();
toggle_cs(1);
return data;
}
// enable SPI, ensures a zero byte was sent (MOSI=0)
// using SPI MODE 2 and that CS and clock remain high
void SPI_on(SPI_type *spi) {
const uint8_t buffer[1] = {0};
#if EPD_COG_VERSION == 1
set_spi_mode(spi, SPI_MODE_2);
#else
set_spi_mode(spi, SPI_MODE_0);
#endif
SPI_send(spi, buffer, sizeof(buffer));
}
uint8_t SD_command(uint8_t cmd, uint32_t arg,
uint8_t crc, uint8_t read) {
CS_LOW();
SPI_send(cmd);
SPI_send(arg>>24);
SPI_send(arg>>16);
SPI_send(arg>>8);
SPI_send(arg);
SPI_send(crc);
uint8_t i;
for(i=0; i<read; i++) {
if (0x01 == SPI_send(0xFF) ) { //card sent back a 1 == ready
CS_HIGH();
return CARD_READY;
}
}
CS_HIGH();
return CARD_BUSY;
}
/* Set single word to ad9833 via SPI */
void main_send_word_ad9833_spi( uint16_t word, uint8_t msborder )
{
switch(msborder)
{
default:
case 1:
/* Send MSB - if MSBORDER is used in SPI initialization */
SPI_send((uint8_t)(word>>8));
/* Send LSB*/
SPI_send((uint8_t)word); break;
case 0:
/* Send LSB - if MSBORDER is NOT used in SPI initialization */
SPI_send((uint8_t)word);
/* Send MSB*/
SPI_send((uint8_t)(word>>8)); break;
}
}
void MCP_rts(uint8_t buffer){
toggle_cs(0);
switch(buffer%4){ //Select buffer to use, 3 = all
case 0:
SPI_send(MCP_RTS_TX0);
break;
case 1:
SPI_send(MCP_RTS_TX1);
break;
case 2:
SPI_send(MCP_RTS_TX2);
break;
case 3:
SPI_send(MCP_RTS_ALL);
break;
default:
break;
}
toggle_cs(1);
}
int main(void)
{
uint8_t tmp;
InitFifo();
USART_Config();
LED_Init();
// I2C_Configuration();
Systick_Init();
mySPI_Init();
//spi();
//Delay(1000);
printf("init SPI test \n\r");
SPI_send(0x23, 0xc9); // resetting the accelerometer internal circuit
SPI_send(0x20, 0x67); // 100Hz data update rate, block data update disable, x/y/z enabled
SPI_send(0x24, 0x20); // Anti aliasing filter bandwidth 800Hz, 16G (very sensitive), no self-test, 4-wire interface
SPI_send(0x10, 0x00); // Output(X) = Measurement(X) - OFFSET(X) * 32;
SPI_send(0x11, 0x00); // Output(Y) = Measurement(Y) - OFFSET(Y) * 32;
SPI_send(0x12, 0x00); // Output(Z) = Measurement(Z) - OFFSET(Z) * 32;
while (1)
{
//tmp = SPI_read(0x28);
//printf("x : %x \n\r",tmp);
tmp = SPI_read(0x29);
printf("x : %x \n\r",tmp);
Delay(1000);
}
}
void LCD_write_4(char LCDDATA)
{
unsigned char databyte = LCDDATA;
databyte &= 0x0F;
databyte |= LCDCON;
databyte &= 0x7F;
SPI_send(databyte);
delayMicro();
databyte |= 0x80;
SPI_send(databyte);
delayMicro();
databyte &= 0x7F;
SPI_send(databyte);
delayMicro();
}
void LCD_write_4(unsigned char sendByte) {
sendByte &= 0x0F;
sendByte |= LCDCON;
sendByte &= 0x7F;
SPI_send(sendByte);
delayMicro();
sendByte |= 0x80;
SPI_send(sendByte);
delayMicro();
sendByte &= 0x7F;
SPI_send(sendByte);
delayMicro();
}
void accelInit()
{
SPI_InitTypeDef SPI_InitTypeDefStruct;
GPIO_InitTypeDef GPIO_InitTypeDefStruct;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE , ENABLE);
SPI_InitTypeDefStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitTypeDefStruct.SPI_Mode = SPI_Mode_Master;
SPI_InitTypeDefStruct.SPI_DataSize = SPI_DataSize_8b;
SPI_InitTypeDefStruct.SPI_CPOL = SPI_CPOL_High;
SPI_InitTypeDefStruct.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitTypeDefStruct.SPI_NSS = SPI_NSS_Soft;
SPI_InitTypeDefStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; //seems like it was here causing trouble
SPI_InitTypeDefStruct.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitTypeDefStruct.SPI_CRCPolynomial = 1;
SPI_DeInit(SPI1);
SPI_Init(SPI1, &SPI_InitTypeDefStruct);
GPIO_InitTypeDefStruct.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7 | GPIO_Pin_6;
GPIO_InitTypeDefStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitTypeDefStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitTypeDefStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitTypeDefStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &GPIO_InitTypeDefStruct);
GPIO_InitTypeDefStruct.GPIO_Pin = GPIO_Pin_3;
GPIO_InitTypeDefStruct.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitTypeDefStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitTypeDefStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitTypeDefStruct.GPIO_OType = GPIO_OType_PP;
GPIO_Init(GPIOE, &GPIO_InitTypeDefStruct);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_SPI1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);
GPIO_SetBits(GPIOE, GPIO_Pin_3);
SPI_Cmd(SPI1, ENABLE);
SPI_send(ACCEL_CTRL_REG6, 0x01); //reboot
SPI_send(ACCEL_CTRL_REG3, 0xc9); // resetting the accelerometer internal circuit
SPI_send(ACCEL_CTRL_REG4, 0x67); // 100Hz data update rate, block data update disable, x/y/z enabled
SPI_send(ACCEL_CTRL_REG4, 0x67); // 100Hz data update rate, block data update disable, x/y/z enabled
SPI_send(ACCEL_CTRL_REG4, 0x67); // 100Hz data update rate, block data update disable, x/y/z enabled
SPI_send(ACCEL_CTRL_REG5, 0x20); // Anti aliasing filter bandwidth 800Hz, 16G, no self-test, 4-wire interface
}
// Initializes mem card
char MEM_init()
{
char val;
mem_bus_granted = 0;
// acquire the SPI bus and other necesary signals
val = MEM_acquireControl();
if(val)
return(val);
// reset to known idle state
// assert reset, wait and deassert reset
ClearPin(PORTC, MEM_RESET);
delay(1);
SetPin(PORTC, MEM_RESET);
// get memory status
// select memory
SPI_select(MEMCS);
// read status register
SPI_send(READ_STATUS_REGISTER);
// get return value
val = SPI_receive(0x00);
SPI_deselect();
if(((val >> 2) & 0x0f) == 0x0f) {
if(!(val & 0x01)) {
MEM.mem_size = 8650752;
MEM.page_size = 1056;
}
else {
blinkLED(10);
}
MEM.fbell_offset = MEM.page_size;
MEM.rbell_offset = MEM.mem_size / 2;
}
else
/**
Transforms the humidity value given in percent relative humidity into
decimal digits and sends the information to the 7-segment display controller.
The display is updated when the chip select signal is deactivated.
\param humidity Integer that represents relative humidity in percent.
*/
void display_humidity(uint8_t humidity)
{
SPI_set_sample_rising_edge();
/* Values of each of the 3 digits */
uint8_t digit [3];
/* Determine the value of each digit */
int8_t tmp;
tmp = humidity / 10;
digit[2] = humidity - 10 * tmp;
humidity = tmp;
tmp = humidity / 10;
digit[1] = humidity - 10 * tmp;
humidity = tmp;
tmp = humidity / 10;
digit[0] = humidity - 10 * tmp;
/* Eliminate leading zeros */
if (digit[0] == 0) {
digit[0] = DISPLAY_CODE_B_BLANK;
if (digit[1] == 0) {
digit[1] = DISPLAY_CODE_B_BLANK;
}
}
/* Send the SPI commands */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DIGIT_5);
SPI_send(digit[0]);
SPI_deselect(SPI_CS_MAX7221);
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DIGIT_6);
SPI_send(digit[1]);
SPI_deselect(SPI_CS_MAX7221);
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DIGIT_7);
SPI_send(digit[2]);
SPI_deselect(SPI_CS_MAX7221);
}
void SetLed(uint8_t led,uint8_t red,uint8_t green, uint8_t blue)
{
if(led > 0)
{
ch[idx[led-1]*3+2]=blue<<4;
ch[idx[led-1]*3+1]=green<<4;
ch[idx[led-1]*3]=red<<4;
}
else
{
for(uint8_t i = 0; i<16; i++)
{
ch[idx[i]*3+2]=blue<<4;
ch[idx[i]*3+1]=green<<4;
ch[idx[i]*3]=red<<4;
}
}
for(uint8_t i = 24; i>0; i--)
{
SPI_send(ch[i*2-1]>>4);
SPI_send((ch[i*2-1]<<4)|(ch[i*2-2]>>8));
SPI_send(ch[i*2-2]);
}
// PORTD |= (1<<PORTD7);//blanc on
PORTB |= (1<<PORTB1); // latch on
// _delay_ms(1);
PORTB &= ~(1<<PORTB1); // latch off
// PORTD &= ~(1<<PORTD7);//blanc off
}
void DAC7512_send(spi_device_t *dev, uint16_t data) {
SPI_send(dev, data, 1);
}
// disable SPI, ensures a zero byte was sent (MOSI=0)
// using SPI MODE 0 and that CS and clock remain low
void SPI_off(SPI_type *spi) {
const uint8_t buffer[1] = {0};
set_spi_mode(spi, SPI_MODE_0);
SPI_send(spi, buffer, sizeof(buffer));
}
/**
Transforms the given temperature that is represented as degrees Celsius
times 100 into decimal digits in preparation for display.
Then it transfers the information to the 7-segment display controller.
The display is updated as soon as the chip select signal is deactivated.
\param temperature Integer that represents temperature in Celsius multiplied by the factor 100.
*/
void display_temperature(int16_t temperature)
{
SPI_set_sample_rising_edge();
/* Values of each of the 5 digits */
uint8_t digit [5];
/* Test for negativity */
if (temperature < 0) {
temperature = -temperature;
digit[0] = DISPLAY_CODE_B_MINUS;
} else {
digit[0] = DISPLAY_CODE_B_BLANK;
}
/* Determine the value of each digit */
int16_t tmp;
tmp = temperature / 10;
digit[4] = temperature - 10 * tmp;
temperature = tmp;
tmp = temperature / 10;
digit[3] = temperature - 10 * tmp;
temperature = tmp;
tmp = temperature / 10;
digit[2] = temperature - 10 * tmp;
digit[2] |= DISPLAY_CODE_DECIMAL_POINT;
temperature = tmp;
tmp = temperature / 10;
digit[1] = temperature - 10 * tmp;
/* Eliminate leading zeros */
if (digit[1] == 0) {
/* The 0th digit may contain a minus sign */
digit[1] = digit[0];
digit[0] = DISPLAY_CODE_B_BLANK;
}
/* Send the SPI commands for digit 0 */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DIGIT_0);
SPI_send(digit[0]);
SPI_deselect(SPI_CS_MAX7221);
/* Send the SPI commands for digit 1 */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DIGIT_1);
SPI_send(digit[1]);
SPI_deselect(SPI_CS_MAX7221);
/* Send the SPI commands for digit 2 */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DIGIT_2);
SPI_send(digit[2]);
SPI_deselect(SPI_CS_MAX7221);
/* Send the SPI commands for digit 3 */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DIGIT_3);
SPI_send(digit[3]);
SPI_deselect(SPI_CS_MAX7221);
/* Send the SPI commands for digit 4 */
SPI_select(SPI_CS_MAX7221);
SPI_send(DISPLAY_REG_DIGIT_4);
SPI_send(digit[4]);
SPI_deselect(SPI_CS_MAX7221);
}
/**
* Send function for the AD5504 which formats the 16, bit messages for the AD5504.
* Message format is as follows:
* +------++-----+--------------+-------------+
* | Bits || 15 | 14 downto 12 | 11 downto 0 |
* +======++=====+==============+=============+
* | DOUT || R_W | Address | Data |
* +------++-----+--------------+-------------+
*/
int16_t AD5504_send(spi_device_t *dev, uint8_t address, uint16_t value, uint8_t read_write, uint8_t chip_address) {
SPI_send(dev, ((read_write | address) << 12) | (value & 0x0FFF), chip_address);
return 0;
}
// TODO: This function will not exit gracefully if SD card does not do what it should
void SD_read(unsigned long sector, unsigned short offset, unsigned char * buffer,
unsigned short len) {
unsigned short i, pos = 0;
CS_LOW();
SPI_send(0x51); // sector * 512 = sector << 9
SPI_send(sector>>15); // sector*512 >> 24
SPI_send(sector>>7); // sector*512 >> 16
SPI_send(sector<<1); // sector*512 >> 8
SPI_send(0); // sector*512
SPI_send(0xFF);
for(i=0; i<10 && SPI_send(0xFF) != 0x00; i++) {} // wait for 0
for(i=0; i<10 && SPI_send(0xFF) != 0xFE; i++) {} // wait for data start
for(i=0; i<offset; i++) // "skip" bytes
SPI_send(0xFF);
for(i=0; i<len; i++) // read len bytes
buffer[i] = SPI_send(0xFF);
for(i+=offset; i<512; i++) // "skip" again
SPI_send(0xFF);
// skip checksum
SPI_send(0xFF);
SPI_send(0xFF);
CS_HIGH();
}
