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(); }