313 lines
9.9 KiB
C++
313 lines
9.9 KiB
C++
#ifndef SPI_H
|
|
#define SPI_H
|
|
|
|
// https://github.com/MetalPhreak/ESP8266_SPI_Driver/blob/master/include/driver/spi.h
|
|
// http://d.av.id.au/blog/esp8266-hardware-spi-driver-code-library/
|
|
|
|
// MTDI GPIO12 MISO (DIN) D6
|
|
// MTCK GPIO13 MOSI (DOUT) D7
|
|
// MTMS GPIO14 CLOCK D5
|
|
// MTDO GPIO15 CS / SS D8
|
|
|
|
// http://www.14core.com/wp-content/uploads/2015/06/Node-MCU-Pin-Out-Diagram1.png
|
|
|
|
extern "C" {
|
|
#include "eagle_soc.h"
|
|
#include "driver/spi_register.h"
|
|
}
|
|
|
|
|
|
class SPI {
|
|
|
|
// user SPI
|
|
#define spi_no 1
|
|
|
|
#define SPI_CLK_USE_DIV 0
|
|
#define SPI_CLK_80MHZ_NODIV 1
|
|
|
|
#define SPI_BYTE_ORDER_HIGH_TO_LOW 1
|
|
#define SPI_BYTE_ORDER_LOW_TO_HIGH 0
|
|
|
|
//Define some default SPI clock settings
|
|
#define SPI_CLK_PREDIV 4
|
|
#define SPI_CLK_CNTDIV 1
|
|
#define SPI_CLK_FREQ CPU_CLK_FREQ/(SPI_CLK_PREDIV*SPI_CLK_CNTDIV) // 80 / 20 = 4 MHz
|
|
|
|
public:
|
|
|
|
SPI() {
|
|
init();
|
|
}
|
|
|
|
public:
|
|
|
|
bool isBusy() const {
|
|
return READ_PERI_REG(SPI_CMD(spi_no)) & SPI_USR;
|
|
}
|
|
|
|
void sendByte(const uint8_t byte) {
|
|
send(8, byte);
|
|
}
|
|
|
|
void sendWord(const uint16_t word) {
|
|
send(16, word);
|
|
}
|
|
|
|
uint8_t readByte() {
|
|
return read(8);
|
|
}
|
|
|
|
uint16_t readWord() {
|
|
return read(16);
|
|
}
|
|
|
|
private:
|
|
|
|
void send(const uint8_t bits, const uint32_t val) {
|
|
|
|
// wait for SPI to be free
|
|
while(isBusy()) {;}
|
|
|
|
CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MOSI|SPI_USR_MISO|SPI_USR_COMMAND|SPI_USR_ADDR|SPI_USR_DUMMY);
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MOSI); // MOSI only (write only)
|
|
|
|
const uint32_t addr_bits = 0;
|
|
const uint32_t dout_bits = bits;
|
|
const uint32_t din_bits = 0;
|
|
const uint32_t dummy_bits = 0;
|
|
|
|
WRITE_PERI_REG(SPI_USER1(spi_no), ((addr_bits-1)&SPI_USR_ADDR_BITLEN)<<SPI_USR_ADDR_BITLEN_S | //Number of bits in Address
|
|
((dout_bits-1)&SPI_USR_MOSI_BITLEN)<<SPI_USR_MOSI_BITLEN_S | //Number of bits to Send
|
|
((din_bits-1)&SPI_USR_MISO_BITLEN)<<SPI_USR_MISO_BITLEN_S | //Number of bits to receive
|
|
((dummy_bits-1)&SPI_USR_DUMMY_CYCLELEN)<<SPI_USR_DUMMY_CYCLELEN_S); //Number of Dummy bits to insert
|
|
|
|
//if (READ_PERI_REG(SPI_USER(spi_no))&SPI_WR_BYTE_ORDER) {
|
|
WRITE_PERI_REG(SPI_W0(spi_no), val);
|
|
//}
|
|
|
|
// start transfer
|
|
SET_PERI_REG_MASK(SPI_CMD(spi_no), SPI_USR);
|
|
|
|
// do NOT wait for the transfer to finish! -> faster
|
|
//while (isBusy()) {;}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t read(const uint8_t bits) {
|
|
|
|
// wait for SPI to be free
|
|
while(isBusy()) {;}
|
|
|
|
CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MOSI|SPI_USR_MISO|SPI_USR_COMMAND|SPI_USR_ADDR|SPI_USR_DUMMY);
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MISO); // MISO only (read only)
|
|
|
|
const uint32_t addr_bits = 0;
|
|
const uint32_t dout_bits = 0;
|
|
const uint32_t din_bits = bits;
|
|
const uint32_t dummy_bits = 0;
|
|
|
|
WRITE_PERI_REG(SPI_USER1(spi_no), ((addr_bits-1)&SPI_USR_ADDR_BITLEN)<<SPI_USR_ADDR_BITLEN_S | //Number of bits in Address
|
|
((dout_bits-1)&SPI_USR_MOSI_BITLEN)<<SPI_USR_MOSI_BITLEN_S | //Number of bits to Send
|
|
((din_bits-1)&SPI_USR_MISO_BITLEN)<<SPI_USR_MISO_BITLEN_S | //Number of bits to receive
|
|
((dummy_bits-1)&SPI_USR_DUMMY_CYCLELEN)<<SPI_USR_DUMMY_CYCLELEN_S); //Number of Dummy bits to insert
|
|
|
|
SET_PERI_REG_MASK(SPI_CMD(spi_no), SPI_USR);
|
|
|
|
// wait for the reading to finish
|
|
while (isBusy()) {;}
|
|
|
|
//if (READ_PERI_REG(SPI_USER(spi_no))&SPI_RD_BYTE_ORDER) {
|
|
// return READ_PERI_REG(SPI_W0(spi_no)) >> (32-din_bits); //Assuming data in is written to MSB. TBC
|
|
//} else {
|
|
return READ_PERI_REG(SPI_W0(spi_no)); //Read in the same way as DOUT is sent. Note existing contents of SPI_W0 remain unless overwritten!
|
|
//}
|
|
|
|
return 0; //something went wrong
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
void init() {
|
|
|
|
spi_init_gpio(SPI_CLK_USE_DIV);
|
|
spi_clock(SPI_CLK_PREDIV, SPI_CLK_CNTDIV);
|
|
spi_tx_byte_order(SPI_BYTE_ORDER_HIGH_TO_LOW);
|
|
spi_rx_byte_order(SPI_BYTE_ORDER_HIGH_TO_LOW);
|
|
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_CS_SETUP|SPI_CS_HOLD);
|
|
CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_FLASH_MODE);
|
|
|
|
}
|
|
|
|
void spi_init_gpio(const bool fullSpeed){
|
|
|
|
uint32 clock_div_flag = 0;
|
|
if (fullSpeed) {
|
|
clock_div_flag = 0x0001;
|
|
}
|
|
|
|
WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105|(clock_div_flag<<9)); //Set bit 9 if 80MHz sysclock required
|
|
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, 2); //GPIO12 is HSPI MISO pin (Master Data In)
|
|
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, 2); //GPIO13 is HSPI MOSI pin (Master Data Out)
|
|
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, 2); //GPIO14 is HSPI CLK pin (Clock)
|
|
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, 2); //GPIO15 is HSPI CS pin (Chip Select / Slave Select)
|
|
|
|
}
|
|
|
|
/*
|
|
uint32 spi_transaction(uint8 spi_no, uint8 cmd_bits, uint16 cmd_data, uint32 addr_bits, uint32 addr_data, uint32 dout_bits, uint32 dout_data,
|
|
uint32 din_bits, uint32 dummy_bits){
|
|
|
|
if(spi_no > 1) return 0; //Check for a valid SPI
|
|
|
|
//code for custom Chip Select as GPIO PIN here
|
|
|
|
while(spi_busy(spi_no)); //wait for SPI to be ready
|
|
|
|
//########## Enable SPI Functions ##########//
|
|
//disable MOSI, MISO, ADDR, COMMAND, DUMMY in case previously set.
|
|
CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MOSI|SPI_USR_MISO|SPI_USR_COMMAND|SPI_USR_ADDR|SPI_USR_DUMMY);
|
|
|
|
//enable functions based on number of bits. 0 bits = disabled.
|
|
//This is rather inefficient but allows for a very generic function.
|
|
//CMD ADDR and MOSI are set below to save on an extra if statement.
|
|
// if(cmd_bits) {SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_COMMAND);}
|
|
// if(addr_bits) {SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_ADDR);}
|
|
if(din_bits) {SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MISO);}
|
|
if(dummy_bits) {SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_DUMMY);}
|
|
//########## END SECTION ##########//
|
|
|
|
//########## Setup Bitlengths ##########//
|
|
WRITE_PERI_REG(SPI_USER1(spi_no), ((addr_bits-1)&SPI_USR_ADDR_BITLEN)<<SPI_USR_ADDR_BITLEN_S | //Number of bits in Address
|
|
((dout_bits-1)&SPI_USR_MOSI_BITLEN)<<SPI_USR_MOSI_BITLEN_S | //Number of bits to Send
|
|
((din_bits-1)&SPI_USR_MISO_BITLEN)<<SPI_USR_MISO_BITLEN_S | //Number of bits to receive
|
|
((dummy_bits-1)&SPI_USR_DUMMY_CYCLELEN)<<SPI_USR_DUMMY_CYCLELEN_S); //Number of Dummy bits to insert
|
|
//########## END SECTION ##########//
|
|
|
|
//########## Setup Command Data ##########//
|
|
if(cmd_bits) {
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_COMMAND); //enable COMMAND function in SPI module
|
|
uint16 command = cmd_data << (16-cmd_bits); //align command data to high bits
|
|
command = ((command>>8)&0xff) | ((command<<8)&0xff00); //swap byte order
|
|
WRITE_PERI_REG(SPI_USER2(spi_no), ((((cmd_bits-1)&SPI_USR_COMMAND_BITLEN)<<SPI_USR_COMMAND_BITLEN_S) | command&SPI_USR_COMMAND_VALUE));
|
|
}
|
|
//########## END SECTION ##########//
|
|
|
|
//########## Setup Address Data ##########//
|
|
if(addr_bits){
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_ADDR); //enable ADDRess function in SPI module
|
|
WRITE_PERI_REG(SPI_ADDR(spi_no), addr_data<<(32-addr_bits)); //align address data to high bits
|
|
}
|
|
|
|
|
|
//########## END SECTION ##########//
|
|
|
|
//########## Setup DOUT data ##########//
|
|
if(dout_bits) {
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MOSI); //enable MOSI function in SPI module
|
|
//copy data to W0
|
|
if(READ_PERI_REG(SPI_USER(spi_no))&SPI_WR_BYTE_ORDER) {
|
|
WRITE_PERI_REG(SPI_W0(spi_no), dout_data<<(32-dout_bits));
|
|
} else {
|
|
|
|
uint8 dout_extra_bits = dout_bits%8;
|
|
|
|
if(dout_extra_bits){
|
|
//if your data isn't a byte multiple (8/16/24/32 bits)and you don't have SPI_WR_BYTE_ORDER set, you need this to move the non-8bit remainder to the MSBs
|
|
//not sure if there's even a use case for this, but it's here if you need it...
|
|
//for example, 0xDA4 12 bits without SPI_WR_BYTE_ORDER would usually be output as if it were 0x0DA4,
|
|
//of which 0xA4, and then 0x0 would be shifted out (first 8 bits of low byte, then 4 MSB bits of high byte - ie reverse byte order).
|
|
//The code below shifts it out as 0xA4 followed by 0xD as you might require.
|
|
WRITE_PERI_REG(SPI_W0(spi_no), ((0xFFFFFFFF<<(dout_bits - dout_extra_bits)&dout_data)<<(8-dout_extra_bits) | (0xFFFFFFFF>>(32-(dout_bits - dout_extra_bits)))&dout_data));
|
|
} else {
|
|
WRITE_PERI_REG(SPI_W0(spi_no), dout_data);
|
|
}
|
|
}
|
|
}
|
|
//########## END SECTION ##########//
|
|
|
|
//########## Begin SPI Transaction ##########//
|
|
SET_PERI_REG_MASK(SPI_CMD(spi_no), SPI_USR);
|
|
//########## END SECTION ##########//
|
|
|
|
//########## Return DIN data ##########//
|
|
if(din_bits) {
|
|
while(spi_busy(spi_no)); //wait for SPI transaction to complete
|
|
|
|
if(READ_PERI_REG(SPI_USER(spi_no))&SPI_RD_BYTE_ORDER) {
|
|
return READ_PERI_REG(SPI_W0(spi_no)) >> (32-din_bits); //Assuming data in is written to MSB. TBC
|
|
} else {
|
|
return READ_PERI_REG(SPI_W0(spi_no)); //Read in the same way as DOUT is sent. Note existing contents of SPI_W0 remain unless overwritten!
|
|
}
|
|
|
|
return 0; //something went wrong
|
|
}
|
|
//########## END SECTION ##########//
|
|
|
|
//Transaction completed
|
|
return 1; //success
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
void spi_clock(const uint16 prediv, const uint8 cntdiv){
|
|
|
|
if ( (prediv==0) | (cntdiv==0) ) {
|
|
|
|
WRITE_PERI_REG(SPI_CLOCK(spi_no), SPI_CLK_EQU_SYSCLK); // full speed
|
|
|
|
} else {
|
|
|
|
WRITE_PERI_REG(SPI_CLOCK(spi_no),
|
|
(((prediv-1)&SPI_CLKDIV_PRE)<<SPI_CLKDIV_PRE_S)|
|
|
(((cntdiv-1)&SPI_CLKCNT_N)<<SPI_CLKCNT_N_S)|
|
|
(((cntdiv>>1)&SPI_CLKCNT_H)<<SPI_CLKCNT_H_S)|
|
|
((0&SPI_CLKCNT_L)<<SPI_CLKCNT_L_S));
|
|
}
|
|
|
|
}
|
|
|
|
void spi_mode(const uint8 spi_cpha, const uint8 spi_cpol) {
|
|
|
|
if(!spi_cpha == !spi_cpol) {
|
|
CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_CK_OUT_EDGE);
|
|
} else {
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_CK_OUT_EDGE);
|
|
}
|
|
|
|
if (spi_cpol) {
|
|
SET_PERI_REG_MASK(SPI_PIN(spi_no), SPI_IDLE_EDGE);
|
|
} else {
|
|
CLEAR_PERI_REG_MASK(SPI_PIN(spi_no), SPI_IDLE_EDGE);
|
|
}
|
|
|
|
}
|
|
|
|
void spi_tx_byte_order(const uint8 byte_order){
|
|
if (byte_order){
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_WR_BYTE_ORDER);
|
|
} else {
|
|
CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_WR_BYTE_ORDER);
|
|
}
|
|
|
|
}
|
|
|
|
void spi_rx_byte_order(const uint8 byte_order){
|
|
if (byte_order){
|
|
SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_RD_BYTE_ORDER);
|
|
} else {
|
|
CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_RD_BYTE_ORDER);
|
|
}
|
|
}
|
|
|
|
|
|
};
|
|
|
|
#undef spi_no
|
|
|
|
#endif // SPI_H
|