Poniżej jest schemat płytki testowej którą wykorzystuje (tak jest tam arduino nano ale to dlatego że jest małe i dość poręczne) do testów.
Poniżej znajduje się kod pliku main.c, spi.c, spi.h, timeout.c i timeout.h
main.c
[syntax=c]/*
* main.c
*
* Created on: 6 maj 2020
* Author: MIKE
*/
#include <avr/io.h>
#include <util/delay.h>
#include "spi/spi.h"
#include "uart/uart.h"
#include "timeout/timeout.h"
unsigned long previus_millis = 0;
int main(void) {
DDRD |= (1<<7);
PORTD &= ~(1<<7);
uint8_t status = 0xFF;
uart_init(UBRR_VAL);
spi_init(SPI_MODE0, SPI_CLOCK_DIV64);
timeout_init();
sei();
uart_putsn("SPI TEST");
while (1) {
unsigned long current_millis = timeout_millis();
if (current_millis - previus_millis >= 1000) {
previus_millis = current_millis;
spi_putc(0xFF, 1);
uart_puts("Status: ");
uart_putint(status, 16);
uart_putsn("");
}
}
}[/syntax]
spi.c
[syntax=c]/*
* spi.c
*
* Created on: 6 maj 2020
* Author: MIKE
* based on SPI library by Julien Delvaux
*/
#include "spi.h"
volatile uint8_t tx_buff[TX_BUFF_SIZE];
volatile uint8_t tx_buff_mask;
volatile uint8_t rx_buff[RX_BUFF_SIZE];
volatile uint8_t rx_buff_mask;
volatile uint8_t cts;
volatile uint8_t bytes_request;
volatile uint8_t tx_head;
volatile uint8_t tx_tail;
volatile uint8_t rx_head;
volatile uint8_t rx_tail;
void (*tx_callback)();
void (*rx_callback)();
volatile uint8_t tx_flag = 0;
volatile uint8_t rx_flag = 0;
void spi_init(uint8_t mode, uint8_t clock) {
// Pin Configuration
SPI_DDR |= (1<<SPI_PIN_SS);
SPI_PORT|= (1<<SPI_PIN_SS);
cts = SPI_INACTIVE;
// Set MOSI and SCK output, all others input
SPI_DDR |= (1<<SPI_PIN_MOSI)|(1<<SPI_PIN_SCK);
// Enable SPI, Master, set clock rate
SPCR = (1<<SPIE)|(1<<SPE)|(1<<MSTR)|(mode<<CPHA)|(clock<<SPR0);
}
void spi_send_bytes(const char *str) {
uint16_t tmptail=0;
// Stores datas in buffer
while (*str) {
spi_putc(*str++, 0);
}
// Checks if ready to send and proceed
if(cts==SPI_INACTIVE){
cts=SPI_ACTIVE;
SPI_PORT &= ~(1<<SPI_PIN_SS); // Pull-down the line
if ( tx_head != tx_tail) {
tmptail = (tx_tail + 1) & TX_BUFF_MASK;
tx_tail = tmptail;
/* get one byte from buffer and write it to UART */
SPDR = tx_buff[tmptail]; /* start transmission */
}
}
}
void spi_read_data(uint8_t bytes_count) {
bytes_request = bytes_count;
if (cts == SPI_INACTIVE) {
cts = SPI_ACTIVE;
SPI_PORT &= ~(1<<SPI_PIN_SS);
SPDR = 0x00;
}
}
void spi_close(void) {
spi_flush();
SPCR = (0x00);
SPI_DDR &= ~(1<<SPI_PIN_SS);
SPI_PORT &= ~(1<<SPI_PIN_SS);
}
uint8_t spi_getc() {
uint16_t temp_tail;
uint8_t data;
if (rx_head == rx_tail) {
}
temp_tail = (rx_tail + 1) & RX_BUFF_MASK;
rx_tail = temp_tail;
data = rx_buff[temp_tail];
return data;
}
void spi_putc(uint8_t data, uint8_t mode) {
uint16_t temp_head;
if (mode == 0) {
temp_head = (tx_head + 1) & TX_BUFF_MASK;
if (temp_head != tx_tail) {
tx_buff[temp_head] = data;
tx_head = temp_head;
}
} else {
uint16_t tmptail=0;
temp_head = (tx_head + 1) & TX_BUFF_MASK;
if (temp_head != tx_tail) {
tx_buff[temp_head] = data;
tx_head = temp_head;
}
if(cts==SPI_INACTIVE){
cts=SPI_ACTIVE;
SPI_PORT &= ~(1<<SPI_PIN_SS); // Pull-down the line
if ( tx_head != tx_tail) {
tmptail = (tx_tail + 1) & TX_BUFF_MASK;
tx_tail = tmptail;
/* get one byte from buffer and write it to UART */
SPDR = tx_buff[tmptail]; /* start transmission */
}
}
}
}
uint8_t spi_transfer(uint8_t data) {
spi_putc(data, 1);
return spi_getc();
}
void spi_puts(const char *str) {
while (*str) {
spi_putc(*str++, 0);
}
}
void spi_flush(void) {
rx_head = rx_tail;
}
uint8_t spi_available(void) {
return (RX_BUFF_SIZE + rx_head - rx_tail) & rx_buff_mask;
}
ISR(SPI_STC_vect)
/*************************************************************************
Function: SPI interrupt
Purpose: called when the SS pin has been put low
**************************************************************************/
{
uint16_t temp_head=0;
uint16_t temp_tail=0;
//RECEIVE
// calculate buffer index
temp_head = ( rx_head + 1) & RX_BUFF_MASK;
if ( temp_head == rx_tail ) {
// error: receive buffer overflow
} else {
// store new index
rx_head = temp_head;
// store received data in buffer
rx_buff[temp_head] = SPDR;
rx_flag = 1;
}
// SEND
if ( tx_head != tx_tail) {
// calculate and store new buffer index
temp_tail = (tx_tail + 1) & TX_BUFF_MASK;
tx_tail = temp_tail;
// get one byte from buffer and write it to UART
SPDR = tx_buff[temp_tail]; // start transmission
tx_flag = 1;
}
else if(bytes_request > 0){
bytes_request--;
SPDR = 0x00;
}
else {
// tx buffer empty, STOP the transmission
SPI_PORT|= (1<<SPI_PIN_SS);
cts = SPI_INACTIVE;
}
}
void spi_set_on_writed_data_callback(void (*callback)()) {
tx_callback = callback;
tx_flag = 0;
}
void spi_set_on_readed_data_callback(void (*callback)()) {
rx_callback = callback;
rx_flag = 0;
}
void spi_on_writed_data() {
(*tx_callback)();
}
void spi_on_readed_data() {
(*rx_callback)();
}[/syntax]
spi.h
[syntax=c]/*
* spi.h
*
* Created on: 6 maj 2020
* Author: MIKE
* based on SPI library by Julien Delvaux
*/
#ifndef SPI_SPI_H_
#define SPI_SPI_H_
#include <avr/io.h>
#include <avr/interrupt.h>
#define MOSI PB5// <---- A (SER IN)
#define SCK PB7// <---- SHIFT CLOCK (SC)
#define CS PB4// <---- LATCH CLOCK (LC)
#define TX_BUFF_SIZE 64
#define TX_BUFF_MASK (TX_BUFF_SIZE - 1)
#define RX_BUFF_SIZE 64
#define RX_BUFF_MASK (RX_BUFF_SIZE - 1)
#define SPI_ACTIVE0 // SS Pin put Low
#define SPI_INACTIVE1 // SS Pin put High
#define SPI_PIN_SS2//SS PIN
#define SPI_PIN_MOSI3//MOSI PIN
#define SPI_PIN_MISO4//MISO PIN
#define SPI_PIN_SCK5//SCK PIN
#define SPI_DDRDDRB//SPI on PORTB
#define SPI_PORTPORTB//SPI on PORTB
#define SPI_CLOCK_DIV40x00
#define SPI_CLOCK_DIV160x01
#define SPI_CLOCK_DIV640x02
#define SPI_CLOCK_DIV1280x03
#define SPI_CLOCK_DIV20x04
#define SPI_CLOCK_DIV80x05
#define SPI_CLOCK_DIV320x06
#define SPI_MODE0 0x00
#define SPI_MODE1 0x04
#define SPI_MODE2 0x08
#define SPI_MODE3 0x0C
void spi_init(uint8_t mode, uint8_t clock);
void spi_read_data(uint8_t bytes_count);
void spi_send_bytes(const char *str);
void spi_close(void);
uint8_t spi_getc(void);
void spi_putc(uint8_t data, uint8_t mode);
void spi_puts(const char *str);
uint8_t spi_transfer(uint8_t data);
void spi_on_writed_data();
void spi_on_readed_data();
void spi_set_on_writed_data_callback(void (*callback)());
void spi_set_on_readed_data_callback(void (*callback)());
void spi_flush(void);
uint8_t spi_available(void);
#endif /* SPI_SPI_H_ */[/syntax]
timeout.c
[syntax=c]/*
* timeout.c
*
* Created on: 9 maj 2020
* Author: MIKE
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include "timeout.h"
volatile unsigned long millis;
void timeout_init(void) {
// 8-bit TimerX config
TCCR0B |= (1<<CS00)|(1<<CS01); // set prescaler = 64 ---> please check proper values in PDF;
TCCR0A |= (1<<WGM01); // set CTC mode ---> please check proper values in PDF
OCR0A = 249; // every [ 1 ms ]
TIMSK0 |= (1<<OCIE0A); // enable CompareX interrupt
}
unsigned long timeout_millis() {
return millis;
}
ISR( TIMER0_COMPA_vect ) {
millis++;
}[/syntax]
timeout.h
[syntax=c]/*
* timeout.h
*
* Created on: 9 maj 2020
* Author: MIKE
*/
#ifndef TIMEOUT_TIMEOUT_H_
#define TIMEOUT_TIMEOUT_H_
void timeout_init();
unsigned long timeout_millis();
#endif /* TIMEOUT_TIMEOUT_H_ */[/syntax]
Kodów źródłowych do uarta nie będę publikował bo jest to przerobiona wersja z bb (dostosowane rejestry do ATmegi328p, zmieniona konwencja nazewnictwa zmiennych, wycięta obsługa RS485 i dodany odbiór łańcuchów tekstowych) - chyba że Mirek się zgodzi to wtedy źródła do uarta udostępnię.
Z góry dziękuję za każda pomoc w namierzeniu problemu
. Pozdrawiam!
Statystyki: Napisane przez MichalXY — 9 maja 2020, o 12:54
]]>