void mcp_write(char reg, char byte){
selectChip();
SPI_MasterTransmit(MCP_WRITE);
SPI_MasterTransmit(reg);
SPI_MasterTransmit(byte);
deselectChip();
}
void SPI_Recive(char Prossesor)
{
int counter=0;
do{
if (Prossesor==0x01) //recive from komunikation
PORTB=(1<<DD_SS);
else //recive from sensor
PORTB=(1<<PB3);
/* Wait for reception complete */
while(!(SPSR & (1<<SPIF)));
/* Return Data Register */
recived_data[counter] = SPDR;
counter++;
}while(PC6|PC7); //still sending data
//kod för att skicka vidare data
if (recived_data[0] & 0x08==0x08)
{
SPI_MasterTransmit(recived_data,0x01); //till komunikation
recive_flag=1;
}
else if (recived_data[0] & 0x0f==0x00)
SPI_MasterTransmit(recived_data,0x03); //till sensor
else
recive_flag=1;
}
char mcp_read_status(){
selectChip();
SPI_MasterTransmit(MCP_READ_STATUS);
SPI_MasterTransmit(0xff);
deselectChip();
return SPI_MasterRead();
}
void cc2500_Init(uint8_t power)
{
prog_uint8_t *init = cc2500InitValue;
SET_BIT(PORTB, OUT_B_SPI_SCK);
RES_BIT(PORTB, OUT_B_SPI_MOSI);
RES_BIT(PORTB, OUT_B_SPI_SS);
_delay_us(40); // warten 40us
SPI_MasterInit();
_delay_us(40); // warten 40us
cc2500_Reset();
cc2500_Off(); // SS wegnehmen
SPI_MasterTransmit(CC2500_IOCFG2 | CC2500_WRITE_BURST);
do
{
SPI_MasterTransmit(pgm_read_byte(init++));
}
while(init < (cc2500InitValue + sizeof(cc2500InitValue) - 3));
cc2500_Off(); // SS wegnehmen wegen Burst
SPI_MasterTransmit(CC2500_TEST2 | CC2500_WRITE_BURST);
do
{
SPI_MasterTransmit(pgm_read_byte(init++));
}
while(init < (cc2500InitValue + sizeof(cc2500InitValue)));
cc2500_Off(); // SS wegnehmen wegen Burst
cc2500setPatableMax(power);
}
void mcp_bit_modify_instruction(char reg, char mask, char data){
selectChip();
SPI_MasterTransmit(MCP_BITMOD);
SPI_MasterTransmit(reg);
SPI_MasterTransmit(mask);
SPI_MasterTransmit(data);
deselectChip();
}
char mcp_read(char reg){
selectChip();
SPI_MasterTransmit(MCP_READ);
SPI_MasterTransmit(reg);
SPI_MasterTransmit(0xFF);
deselectChip();
return SPI_MasterRead();
}
void matrix_transmit(char address, char data)
{
SPI_PORT &= ~(1<<SPI_SS);
SPI_MasterTransmit(address);
SPI_MasterTransmit(data);
SPI_PORT |= (1<<SPI_SS);
}
byte FRAM_Read(void) {
csFM_STATE(LOW); // Low: Chip is selected
SPI_MasterTransmit(RMSB); // Read memory data MSB
SPI_MasterTransmit(RLSB); // Read memory data LSB
csFM_STATE(HIGH);
return SPDR;
}
void switchline(unsigned char line)
{
if(line>=8)line=0;
PORTB&=~(1<<PB1); //发送命令
SPI_MasterTransmit(0xB0 + line);
SPI_MasterTransmit(0x00);
SPI_MasterTransmit(0x10);
point=(line)*128;
}
void glcd_sendData16(unsigned int data)
{
unsigned char data1 = data>>8;
unsigned char data2 = data&0xff;
glcd_dc_high();
glcd_cs_low();
SPI_MasterTransmit(data1);
SPI_MasterTransmit(data2);
glcd_cs_high();
}
void init_LCD(void){
char read;
PORTB &= ~_BV(SS);
PORTB &= ~_BV(D_C);
SPI_MasterTransmit(RDID1);
read = SPI_MasterTransmit(RDID1);
PORTB |= _BV(D_C);
PORTB |= _BV(SS);
}
void OLED_Display(char display)
{
unsigned char count;
if(point%128>=125)
switchline(point/128+1);
display-=32;
PORTB|=(1<<PB1); //发送数据
for(count=0;count<5;count++)
SPI_MasterTransmit(pgm_read_byte(Ascii_1[display]+count));
SPI_MasterTransmit(0);
point+=6;
}
void writeRegister(unsigned char address, unsigned char data)
{
// SC16IS740 expects a R/W bit first, followed by the 4 bit
// register address of the byte.
// So shift the bits left by three bits:
unsigned char reg = address << 3;
unsigned char regToSend = reg | 0x00;
select();
SPI_MasterTransmit(regToSend);
SPI_MasterTransmit(data);
deselect();
}
/* --------- FRAM --------- */
void FRAM_Write(byte bData) {
csFM_STATE(LOW); // Low: Chip is selected
SPI_MasterTransmit(WREN); // Set Write Enable Latch
csFM_STATE(HIGH);
csFM_STATE(LOW);
SPI_MasterTransmit(WMSB); // Write memory data MSB
SPI_MasterTransmit(WLSB); // Write memory data LSB
SPI_MasterTransmit(bData);
csFM_STATE(HIGH);
}
void oled_clear()
{
unsigned char i;
unsigned char page;
for (page=0; page<8; page++)
{
PORTB&=~(1<<PB1); //发送命令
SPI_MasterTransmit(0xB0 + page);
SPI_MasterTransmit(0x00);
SPI_MasterTransmit(0x10);
PORTB|=(1<<PB1); //发送数据
for (i=0; i<128; i++)
SPI_MasterTransmit(0);
}
switchline(0);
}
char SPI_sendchar(char cData)
{
SPI_MasterTransmit(cData);
USART_Transmit(SPDR);
return SPDR;
}
unsigned char readRegister(unsigned char address)
{
// SC16IS740 expects a R/W bit first, followed by the 4 bit
// register address of the byte.
// So shift the bits left by three bits:
unsigned char reg = address << 3;
// now combine the register address and the command into one byte:
unsigned char dataToSend = reg | 0x80;
unsigned char result;
select();
SPI_MasterTransmit(dataToSend);
result = SPI_MasterTransmit(0xFF);
deselect();
return result;
}
void glcd_sendData(unsigned char data)
{
glcd_dc_high();
glcd_cs_low();
SPI_MasterTransmit(data);
glcd_cs_high();
}
void xmit_Tick(){
//Actions
switch(xmit_state){
case xmit_INIT:
break;
case xmit_RUN:
parseData();
SPI_MasterTransmit(data);
break;
default:
break;
}
//Transitions
switch(xmit_state){
case xmit_INIT:
xmit_state = xmit_RUN;
break;
case xmit_RUN:
xmit_state = xmit_RUN;
break;
default:
xmit_state = xmit_INIT;
break;
}
}
int main(void)
{
PORTB=0xFF;
DDRB=0xFF;
SPI_MasterInit();
while (1)
{
SPI_MasterTransmit(0x37);
_delay_ms(500);
SPI_MasterTransmit(0x38);
_delay_ms(500);
SPI_MasterTransmit(0x39);
_delay_ms(500);
}
}
void mcp_init(){
deselectChip();
SPI_MasterTransmit(MCP_RESET);
//setLoopbackOperationalMode();
setOperationModeNormal();
mcp_write(MCP_CANINTE, MCP_RX_INT);
mcp_bit_modify_instruction(MCP_RXB0CTRL, 0b01100000, 0xFF);
}
//Gets all the sensor values from sensorenheten via the SPI-bus
void getSensorValues() {
for(uint8_t i = 0; i < RETRIEVABLE_SENSOR_DATA; ++i) {
PORTB &= ~_BV(PB3);
SPI_MasterTransmit(i);
PORTB |= _BV(PB3);
_delay_us(10);
PORTB &= ~_BV(PB3);
dataValues[i] = SPI_MasterTransmit(0xAA);
PORTB |= _BV(PB3);
_delay_us(10);
}
ADConvert();
}
u08 SPI_MasterTransmitX(u08 data, u08 slave)
{
/* Perform normal transfer */
SPI_MasterTransmit(data, slave);
/* Return data from slave */
return (SPDR);
}
//---------------------------------------Commands----------------------
//---------------------------------------------------------------------
//Use this function to move the robot using one of the pre-defined commands
void moveRobot(uint8_t move){
if(calibrating >= 3){
PORTB &= ~_BV(PB1);
SPI_MasterTransmit(move);
PORTB |= _BV(PB1);
}
dataValues[13] = move;
}
int main(void) {
char highbyte, lowbyte;
SPI_MasterInit();
int i;
i = MCP_START; // MCP4921 initial value
while(1)
{
for (i=MCP_START; i<MCP_START+4096; i+=2)
{
highbyte = i>>8;
lowbyte = i;
PORTB &= ~(1<<2); //SS sets to low
SPI_MasterTransmit(highbyte);
SPI_MasterTransmit(lowbyte);
PORTB |= 1<<2; //SS sets to high
}
}
}
int main ()
{
/* Configure port D pin 0 as output
* for signaling when tests pass
*/
DDR_SIGNAL = (1<<DD_SIGNAL);
uint8_t i, byte_received;
SPI_MasterInit();
for (i=0; i<100; i++)
{
SPI_MasterTransmit(0x81);
_delay_ms(5);
/* is SPI interrupt flag set? */
if (SPSR == 0x80)
{
/* if SPI interrupt flag is set
* clear it by reading the data
* in SPI data register */
byte_received = SPI_ReadData();
set_bit(SIGNAL_PORT, SIGNAL);
//_delay_ms(25);
/* did clearing interrupt
* flag succeed? */
if (SPSR == 0x00)
{
/* if yes blink LED */
clear_bit(SIGNAL_PORT, SIGNAL);
//_delay_ms(25);
}
}
/* if flag is not set blink slowly
* forever */
else
{
while (1)
{
set_bit(SIGNAL_PORT, SIGNAL);
_delay_ms(500);
clear_bit(SIGNAL_PORT, SIGNAL);
_delay_ms(500);
}
}
}
/* if all is well, after completing
* the requested transmissions
* the LED should go off and the
* processeor should do nothing
* happily ever after */
while (1);
;
return (0);
}
void LCD_Tx(char CD, char cData) {
cdLCD_DIR(OUT);
cdLCD_STATE(CD); // Low: Command; High: Data;
csLCD_DIR(OUT);
csLCD_STATE(LOW); // Low: LCD is selected
SPI_MasterTransmit(cData);
csLCD_STATE(HIGH); // High: LCD is released
}
int main()
{
DDRC=255; //PORTC as output,used for Slave Selections
while(1)
{
PORTC=0;
_delay_ms(1000);
SPI_MasterInit();
SPI_MasterTransmit(255);
PORTC=255;
_delay_ms(1000);
PORTC=0;
_delay_ms(1000);
SPI_MasterInit();
SPI_MasterTransmit(0);
PORTC=255;
_delay_ms(1000);
}
return 0;
}
bool checkcc2500(void)
{
prog_uint8_t *init = cc2500InitValue;
bool f = true;
_delay_ms(100);
SPI_MasterTransmit(CC2500_IOCFG2 | CC2500_READ_BURST);
do
{
if(SPI_MasterTransmit(0) != pgm_read_byte(init++))
f = false;
}
while(init < (cc2500InitValue + sizeof(cc2500InitValue) - 3));
cc2500_Off(); // SS wegnehmen wegen Burst
SPI_MasterTransmit(CC2500_TEST2 | CC2500_READ_BURST);
do
{
if(SPI_MasterTransmit(0) != pgm_read_byte(init++))
f = false;
}
while(init < (cc2500InitValue + sizeof(cc2500InitValue)));
cc2500_Off(); // SS wegnehmen wegen Burst
return f;
}
//Gets all the sensor values from sensorenheten via the SPI-bus
void getSensorValues(){
uint8_t temp = 0;
for(uint8_t i = 0; i < RETRIEVABLE_SENSOR_DATA; ++i){
if(i != 1 && i != 5 && i != 6){
PORTB &= ~_BV(PB3);
SPI_MasterTransmit(i);
PORTB |= _BV(PB3);
_delay_us(10);
PORTB &= ~_BV(PB3);
temp = SPI_MasterTransmit(0xAA);
PORTB |= _BV(PB3);
cli();
dataValues[i] = temp;
sei();
_delay_us(10);
}
}
ADConvert();
}
