mirrors
/
pimoroni-pico
mirror of https://github.com/pimoroni/pimoroni-pico.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
pimoroni-pico/drivers/esp32spi/spi_drv.cpp

397 lines
10 KiB
C++
Raw Blame History

#include "spi_drv.hpp"
namespace pimoroni {
void SpiDrv::init() {
spi_init(spi, 8000000);
gpio_set_function(miso, GPIO_FUNC_SPI);
gpio_set_function(sck, GPIO_FUNC_SPI);
gpio_set_function(mosi, GPIO_FUNC_SPI);
// Chip select is active-low, so we'll initialise it to a driven-high state
gpio_init(cs);
gpio_set_dir(cs, GPIO_OUT);
gpio_put(cs, true);
gpio_init(gpio0);
gpio_set_dir(gpio0, GPIO_OUT);
gpio_init(resetn);
gpio_set_dir(resetn, GPIO_OUT);
}
void SpiDrv::reset() {
gpio_put(gpio0, true);
gpio_put(cs, true);
gpio_put(resetn, false);
sleep_ms(10);
gpio_put(resetn, true);
sleep_ms(750);
}
bool SpiDrv::available() {
return gpio_get(gpio0);
}
void SpiDrv::esp_select() {
gpio_put(cs, false);
}
void SpiDrv::esp_deselect() {
gpio_put(cs, true);
}
bool SpiDrv::get_esp_ready() {
return !gpio_get(ack);
}
bool SpiDrv::get_esp_ack() {
return gpio_get(ack);
}
bool SpiDrv::wait_for_esp_ack(uint32_t timeout_ms) {
absolute_time_t timeout = make_timeout_time_ms(timeout_ms);
while(!get_esp_ack()) {
tight_loop_contents();
if (absolute_time_diff_us(get_absolute_time(), timeout) <= 0) {
return false;
}
}
return true;
}
bool SpiDrv::wait_for_esp_ready(uint32_t timeout_ms) {
absolute_time_t timeout = make_timeout_time_ms(timeout_ms);
while(!get_esp_ready()) {
tight_loop_contents();
if (absolute_time_diff_us(get_absolute_time(), timeout) <= 0) {
return false;
}
}
return true;
}
bool SpiDrv::wait_for_esp_select(uint32_t timeout_ms) {
if(!wait_for_esp_ready(timeout_ms)) {
return false;
}
esp_select();
if(!wait_for_esp_ack(timeout_ms)) {
esp_deselect();
return false;
}
return true;
}
int SpiDrv::wait_for_byte(uint8_t wait_byte) {
int timeout = BYTE_TIMEOUT;
uint8_t byte_read = 0;
do{
byte_read = read_byte(); //get data byte
if (byte_read == ERR_CMD) {
WARN("Err cmd received\n");
return -1;
}
} while((timeout-- > 0) && (byte_read != wait_byte));
return (byte_read == wait_byte);
}
bool SpiDrv::read_and_check_byte(uint8_t check_byte, uint8_t *byte_out) {
get_param(byte_out);
return (*byte_out == check_byte);
}
uint8_t SpiDrv::read_byte() {
uint8_t byte_read = 0;
get_param(&byte_read);
return byte_read;
}
bool SpiDrv::wait_response_params(uint8_t cmd, uint8_t num_param, outParam *params_out) {
uint8_t data = 0;
int i = 0;
IF_CHECK_START_CMD() {
CHECK_DATA(cmd | REPLY_FLAG, data){};
uint8_t num_param_read = read_byte();
if(num_param_read != 0) {
for(i = 0; i < num_param_read; ++i) {
params_out[i].param_len = read_param_len8();
spi_read_blocking(spi, DUMMY_DATA, params_out[i].param, params_out[i].param_len);
}
}
else {
WARN("Error num_param == 0\n");
return false;
}
if(num_param != num_param_read) {
WARN("Mismatch num_param\n");
return false;
}
read_and_check_byte(END_CMD, &data);
}
return true;
}
bool SpiDrv::wait_response_cmd(uint8_t cmd, uint8_t num_param, uint8_t *param_out, uint16_t *param_len_out) {
uint8_t data = 0;
int ii = 0;
IF_CHECK_START_CMD() {
CHECK_DATA(cmd | REPLY_FLAG, data){};
CHECK_DATA(num_param, data) {
read_param_len8(param_len_out);
for(ii = 0; ii < (*param_len_out); ++ii) {
get_param(&param_out[ii]);
}
}
read_and_check_byte(END_CMD, &data);
}
return true;
}
bool SpiDrv::wait_response_data8(uint8_t cmd, uint8_t *param_out, uint16_t *param_len_out) {
uint8_t data = 0;
IF_CHECK_START_CMD() {
CHECK_DATA(cmd | REPLY_FLAG, data){};
uint8_t num_param_read = read_byte();
if(num_param_read != 0) {
read_param_len8(param_len_out);
spi_read_blocking(spi, DUMMY_DATA, param_out, *param_len_out);
}
read_and_check_byte(END_CMD, &data);
}
return true;
}
bool SpiDrv::wait_response_data16(uint8_t cmd, uint8_t* param_out, uint16_t *param_len_out) {
uint8_t data = 0;
IF_CHECK_START_CMD() {
CHECK_DATA(cmd | REPLY_FLAG, data){};
uint8_t num_param_read = read_byte();
if(num_param_read != 0) {
read_param_len16(param_len_out);
spi_read_blocking(spi, DUMMY_DATA, param_out, *param_len_out);
}
read_and_check_byte(END_CMD, &data);
}
return false;
}
bool SpiDrv::wait_response(uint8_t cmd, uint16_t *num_param_out, uint8_t **params_out, uint8_t max_num_params) {
uint8_t data = 0;
int i = 0;
uint8_t* index[WL_SSID_MAX_LENGTH];
for(i = 0 ; i < WL_NETWORKS_LIST_MAXNUM; i++)
index[i] = (uint8_t*)params_out + (WL_SSID_MAX_LENGTH * i);
IF_CHECK_START_CMD() {
CHECK_DATA(cmd | REPLY_FLAG, data){};
uint8_t num_param_read = read_byte();
if(num_param_read > max_num_params) {
num_param_read = max_num_params;
}
*num_param_out = num_param_read;
if(num_param_read != 0) {
for(i = 0; i < num_param_read; ++i) {
uint8_t param_len = read_param_len8();
spi_read_blocking(spi, DUMMY_DATA, index[i], param_len);
index[i][param_len] = 0;
}
}
else {
WARN("Error numParams == 0\n");
read_and_check_byte(END_CMD, &data);
return false;
}
read_and_check_byte(END_CMD, &data);
}
return true;
}
void SpiDrv::send_param(const uint8_t *param, uint8_t param_len) {
send_param_len8(param_len);
spi_write_blocking(spi, param, param_len);
command_length += param_len;
}
void SpiDrv::send_param_len8(uint8_t param_len) {
spi_write_blocking(spi, &param_len, 1);
command_length += 1;
}
void SpiDrv::send_param_len16(uint16_t param_len) {
uint8_t buf[2];
buf[0] = (uint8_t)((param_len & 0xff00) >> 8);
buf[1] = (uint8_t)(param_len & 0xff);
spi_write_blocking(spi, buf, 2);
command_length += 2;
}
uint8_t SpiDrv::read_param_len8(uint16_t *param_len_out) {
uint8_t param_len;
get_param(&param_len);
if(param_len_out != nullptr) {
*param_len_out = param_len;
}
return param_len;
}
uint16_t SpiDrv::read_param_len16(uint16_t *param_len_out) {
uint8_t buf[2];
spi_read_blocking(spi, DUMMY_DATA, buf, 2);
uint16_t param_len = (buf[0] << 8) | (buf[1] & 0xff);
if(param_len_out != nullptr) {
*param_len_out = param_len;
}
return param_len;
}
void SpiDrv::send_buffer(const uint8_t* param, uint16_t param_len) {
send_param_len16(param_len);
spi_write_blocking(spi, param, param_len);
command_length += param_len;
}
void SpiDrv::start_cmd(uint8_t cmd, uint8_t num_param) {
uint8_t buf[3];
buf[0] = START_CMD;
buf[1] = cmd & ~(REPLY_FLAG);
buf[2] = num_param;
spi_write_blocking(spi, buf, 3);
command_length = 3;
}
void SpiDrv::end_cmd() {
uint8_t buf = END_CMD;
spi_write_blocking(spi, &buf, 1);
command_length += 1;
WARN("Command len: %ld\n", command_length);
pad_to_multiple_of_4(command_length);
command_length = 0;
}
void SpiDrv::pad_to_multiple_of_4(int command_size) {
while(command_size % 4) {
read_byte();
command_size++;
}
}
void SpiDrv::get_param(uint8_t* param_out) {
spi_read_blocking(spi, DUMMY_DATA, param_out, 1);
}
bool SpiDrv::send_command(uint8_t command, const SpiDrv::inParam *params_in, uint8_t num_in, uint8_t *data, uint16_t *data_len, cmd_response_type response_type) {
if (!wait_for_esp_select()) {
// Timeout waiting for ESP select
// This could be a transport error, or a sleeping EPS32
return false;
}
WARN("\n%s %d\n", commands[command], num_in);
// Send Command
start_cmd(command, num_in);
// Send params
for(uint8_t i = 0; i < num_in; i++) {
SpiDrv::inParam param = params_in[i];
switch(param.type) {
case PARAM_NORMAL:
WARN("param %d\n", param.len);
send_param(param.addr, param.len); // uint8_t length
break;
case PARAM_BUFFER:
WARN("buffer %d\n", param.len);
send_buffer(param.addr, param.len); // uint16_t length
break;
case PARAM_DUMMY:
WARN("dummy\n");
uint8_t dummy = DUMMY_DATA;
send_param(&dummy, 1);
break;
}
}
end_cmd();
esp_deselect();
// Wait for reply
// START_SCAN_NETWORKS is a no-op, and SCAN_NETWORKS will block while the scan is performed
wait_for_esp_select(command == 0x27 ? 30000 : 10000);
*data = -1;
bool status = false;
switch(response_type) {
case RESPONSE_TYPE_NORMAL:
WARN("wait_response\n");
// Currently SCAN_NETWORKS is the only command using "wait_response" so its max_num_params value is hard-coded
status = wait_response(command, data_len, (uint8_t**)data, WL_NETWORKS_LIST_MAXNUM);
break;
case RESPONSE_TYPE_CMD:
WARN("wait_response_cmd\n");
status = wait_response_cmd(command, SpiDrv::PARAM_NUMS_1, data, data_len);
break;
case RESPONSE_TYPE_DATA8:
WARN("wait_response_data8\n");
status = wait_response_data8(command, data, data_len);
break;
case RESPONSE_TYPE_DATA16:
WARN("wait_response_data16\n");
status = wait_response_data16(command, data, data_len);
break;
}
esp_deselect();
if(status) {
// Any successful command should reset sleep status to AWAKE
// a sleeping ESP32 wont respond to commands!
sleep_state = AWAKE;
}
return status;
}
bool SpiDrv::send_command(uint8_t command, SpiDrv::outParam *params_out, SpiDrv::numParams num_out) {
if (!wait_for_esp_select()) {
// Timeout waiting for ESP select!
return false;
}
start_cmd(command, SpiDrv::PARAM_NUMS_1);
uint8_t dummy = DUMMY_DATA;
send_param(&dummy, 1);
end_cmd();
esp_deselect();
wait_for_esp_select();
bool status = wait_response_params(command, num_out, params_out);
esp_deselect();
if(status) {
// Any successful command should reset sleep status to AWAKE
// a sleeping ESP32 wont respond to commands!
sleep_state = AWAKE;
}
return status;
}
}
Reference in New Issue View Git Blame Copy Permalink