diff --git a/F0-nolib/F0_testbrd/main.c b/F0-nolib/F0_testbrd/main.c index 1566357..ded79c5 100644 --- a/F0-nolib/F0_testbrd/main.c +++ b/F0-nolib/F0_testbrd/main.c @@ -23,6 +23,7 @@ #include "hardware.h" #include "i2c.h" #include "proto.h" +#include "spi.h" #include "usart.h" #include "usb.h" #include "usb_lib.h" @@ -50,6 +51,7 @@ int main(void){ RCC->CSR |= RCC_CSR_RMVF; // remove reset flags USB_setup(); + spi_setup(); iwdg_setup(); while (1){ diff --git a/F0-nolib/F0_testbrd/pl2303.bin b/F0-nolib/F0_testbrd/pl2303.bin index 5b88d64..d270bdf 100755 Binary files a/F0-nolib/F0_testbrd/pl2303.bin and b/F0-nolib/F0_testbrd/pl2303.bin differ diff --git a/F0-nolib/F0_testbrd/proto.c b/F0-nolib/F0_testbrd/proto.c index 5b05901..f0f88af 100644 --- a/F0-nolib/F0_testbrd/proto.c +++ b/F0-nolib/F0_testbrd/proto.c @@ -19,10 +19,15 @@ #include "adc.h" #include "i2c.h" #include "proto.h" +#include "spi.h" #include "usart.h" #include "usb.h" #include "usb_lib.h" +#define LOCBUFFSZ (32) +// local buffer for I2C and SPI data to send +static uint8_t locBuffer[LOCBUFFSZ]; + void USB_sendstr(const char *str){ uint16_t l = 0; const char *b = str; @@ -78,6 +83,43 @@ static inline char *USARTsend(char *buf){ return "OK"; } +// read N numbers from buf, @return 0 if wrong or none +static uint16_t readNnumbers(char *buf){ + uint32_t D; + char *nxt; + uint16_t N = 0; + while((nxt = getnum(buf, &D)) && nxt != buf && N < LOCBUFFSZ){ + buf = nxt; + locBuffer[N++] = (uint8_t) D&0xff; + USND("add byte: "); USB_sendstr(uhex2str(D&0xff)); USND("\n"); + } + USND("Send "); USB_sendstr(u2str(N)); USND(" bytes\n"); + return N; +} + +// dump memory buffer +static void hexdump(uint8_t *arr, uint16_t len){ + char buf[52], *bptr = buf; + for(uint16_t l = 0; l < len; ++l, ++arr){ + for(int16_t j = 1; j > -1; --j){ + register uint8_t half = (*arr >> (4*j)) & 0x0f; + if(half < 10) *bptr++ = half + '0'; + else *bptr++ = half - 10 + 'a'; + } + if(l % 16 == 15){ + *bptr++ = '\n'; + *bptr = 0; + USB_sendstr(buf); + bptr = buf; + }else *bptr++ = ' '; + } + if(bptr != buf){ + *bptr++ = '\n'; + *bptr = 0; + USB_sendstr(buf); + } +} + static uint8_t i2cinited = 0; static inline char *setupI2C(char *buf){ buf = omit_spaces(buf); @@ -88,7 +130,6 @@ static inline char *setupI2C(char *buf){ } static uint8_t I2Caddress = 0; -static uint8_t I2Cdata[12]; static inline char *saI2C(char *buf){ uint32_t addr; if(!getnum(buf, &addr) || addr > 0x7f) return "Wrong address"; @@ -106,33 +147,26 @@ static inline void rdI2C(char *buf){ buf = nxt; uint8_t reg = N; nxt = getnum(buf, &N); - if(!nxt || buf == nxt || N > 12){ + if(!nxt || buf == nxt || N > LOCBUFFSZ){ USND("Bad length\n"); return; } - if(!read_i2c_reg(I2Caddress, reg, I2Cdata, N)){ + if(!read_i2c_reg(I2Caddress, reg, locBuffer, N)){ USND("Error reading I2C\n"); return; } if(N == 0){ USND("OK"); return; } USND("Register "); USB_sendstr(uhex2str(reg)); USND(":\n"); - for(uint32_t i = 0; i < N; ++i){ + hexdump(locBuffer, N); + /*for(uint32_t i = 0; i < N; ++i){ if(i < 10) USND(" "); - USB_sendstr(u2str(i)); USND(": "); USB_sendstr(uhex2str(I2Cdata[i])); + USB_sendstr(u2str(i)); USND(": "); USB_sendstr(uhex2str(locBuffer[i])); USND("\n"); - } + }*/ } static inline char *wrI2C(char *buf){ - uint8_t N = 0; - uint32_t D; - char *nxt; - while((nxt = getnum(buf, &D)) && nxt != buf && N < 12){ - buf = nxt; - I2Cdata[N++] = (uint8_t) D&0xff; - USND("add byte: "); USB_sendstr(uhex2str(D&0xff)); USND("\n"); - } - USND("Send "); USB_sendstr(u2str(N)); USND(" bytes\n"); - if(!write_i2c(I2Caddress, I2Cdata, N)) return "Error writing I2C"; + uint16_t N = readNnumbers(buf); + if(!write_i2c(I2Caddress, locBuffer, N)) return "Error writing I2C"; return "OK"; } @@ -144,6 +178,43 @@ static inline char *DAC_chval(char *buf){ return "OK"; } +// write locBuffer to SPI +static inline void wrSPI(int SPIidx, char *buf){ + uint16_t N = readNnumbers(buf); + if(N < 1){ + USND("Enter at least 1 number (max: "); + USB_sendstr(u2str(LOCBUFFSZ)); USND(")\n"); + return; + } + if(SPI_transmit(SPIidx, locBuffer, N)) USND("Error: busy?\n"); + else USND("done"); +} +static inline void rdSPI(int SPIidx){ + if(SPI_isoverflow(SPIidx)) USND("SPI buffer overflow\n"); + uint8_t len = LOCBUFFSZ; + if(SPI_getdata(SPIidx, locBuffer, &len)){ + USND("Error getting data: busy?\n"); + return; + } + if(len == 0){ + USND("Nothing to read\n"); + return; + } + if(len > LOCBUFFSZ) USND("Can't get full message: buffer too small\n"); + USND("SPI data:\n"); + hexdump(locBuffer, len); +} + +static inline char *procSPI(char *buf){ + int idx = 0; + if(*buf == 'p') idx = 1; + buf = omit_spaces(buf + 1); + if(*buf == 'w') wrSPI(idx, buf + 1); + else if(*buf == 'r') rdSPI(idx); + else return "Enter `w` and data to write, `r` - to read"; + return NULL; +} + const char *helpstring = "+/-[num] - increase/decrease TIM1ch1 PWM by 1 or `num`\n" "1..4'+'/'-'[num] - increase/decrease TIM3chN PWM by 1 or `num`\n" @@ -157,6 +228,10 @@ const char *helpstring = "Is - scan I2C bus\n" "L - send long string over USB\n" "m - monitor ADC on/off\n" + "Pw bytes - send bytes over SPI1\n" + "pw bytes - send bytes over SPI2\n" + "Pr - get data from SPI1\n" + "pr - get data from SPI2\n" "R - software reset\n" "S - send short string over USB\n" "Ux str - send string to USARTx (1..3)\n" @@ -202,6 +277,10 @@ const char *parse_cmd(char *buf){ else if(*buf == 's') i2c_init_scan_mode(); else return "Command should be 'Ia', 'Iw', 'Ir' or 'Is'\n"; break; + case 'p': + case 'P': + return procSPI(buf); + break; case 'U': return USARTsend(buf + 1); break; diff --git a/F0-nolib/F0_testbrd/spi.c b/F0-nolib/F0_testbrd/spi.c new file mode 100644 index 0000000..bbfd3f5 --- /dev/null +++ b/F0-nolib/F0_testbrd/spi.c @@ -0,0 +1,185 @@ +/* + * This file is part of the F0testbrd project. + * Copyright 2021 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "hardware.h" +#include "proto.h" +#include "spi.h" +#include "usb.h" + +#include // memcpy + +// buffers for DMA rx/tx +static uint8_t inbuff[SPInumber][SPIBUFSZ], outbuf[SPInumber][SPIBUFSZ]; +static uint8_t overfl[SPInumber] = {0, 0}; +spiStatus SPI_status[SPInumber] = {SPI_NOTREADY, SPI_NOTREADY}; +static DMA_Channel_TypeDef * const rxDMA[SPInumber] = {DMA1_Channel2, DMA1_Channel4}; +static DMA_Channel_TypeDef * const txDMA[SPInumber] = {DMA1_Channel3, DMA1_Channel5}; +static const uint32_t txDMAirqn[SPInumber] = {DMA1_Channel2_3_IRQn, DMA1_Channel4_5_6_7_IRQn}; +static SPI_TypeDef * const SPI[SPInumber] = {SPI1, SPI2}; + +// setup SPI by data from arrays above, +// @param SPIidx - index in arrays +// @param master - == 0 for slave +static void spicommonsetup(uint8_t SPIidx, uint8_t master){ + if(SPIidx >= SPInumber) return; + // Configure DMA SPI + /* SPI_RX DMA config */ + /* (1) Peripheral address */ + /* (2) Memory address */ + /* (3) Data size */ + /* (4) Memory increment */ + /* Peripheral to memory */ + /* 8-bit transfer */ + /* Overflow IR */ + rxDMA[SPIidx]->CPAR = (uint32_t)&(SPI[SPIidx]->DR); /* (1) */ + rxDMA[SPIidx]->CMAR = (uint32_t)inbuff[SPIidx]; /* (2) */ + rxDMA[SPIidx]->CNDTR = SPIBUFSZ; /* (3) */ + rxDMA[SPIidx]->CCR |= DMA_CCR_MINC | DMA_CCR_TEIE | DMA_CCR_EN; /* (4) */ + /* SPI_TX DMA config */ + /* (5) Peripheral address */ + /* (6) Memory address */ + /* (7) Memory increment */ + /* Memory to peripheral*/ + /* 8-bit transfer */ + /* Transfer complete IT */ + txDMA[SPIidx]->CPAR = (uint32_t)&(SPI[SPIidx]->DR); /* (5) */ + txDMA[SPIidx]->CMAR = (uint32_t)outbuf[SPIidx]; /* (6) */ + txDMA[SPIidx]->CCR |= DMA_CCR_MINC | DMA_CCR_TCIE | DMA_CCR_DIR; /* (7) */ + /* Configure IT */ + /* (8) Set priority */ + /* (9) Enable DMA */ + NVIC_SetPriority(txDMAirqn[SPIidx], 0); + NVIC_EnableIRQ(txDMAirqn[SPIidx]); + /* Configure SPI */ + /* (1) Master selection, BR: Fpclk/256 CPOL and CPHA at zero (rising first edge) */ + /* (2) TX and RX with DMA, 8-bit Rx fifo */ + /* (3) Enable SPI1 */ + SPI[SPIidx]->CR1 = master ? (SPI_CR1_MSTR | SPI_CR1_BR) : (SPI_CR1_BR); /* (1) */ + SPI[SPIidx]->CR2 = SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN | SPI_CR2_DS_2 | SPI_CR2_DS_1 | SPI_CR2_DS_0; /* (2) */ + SPI[SPIidx]->CR1 |= SPI_CR1_SPE; /* (3) */ + SPI_status[SPIidx] = SPI_READY; + SPI_prep_receive(SPIidx); +} + +// SPI1 (AF0): PB3 - SCK, PB4 - MISO, PB5 - MOSI; RxDMA - ch2, TxDMA - ch3 +// SPI2 (AF0): PB13 - SCK, PB14 - MISO, PB15 - MOSI; RxDMA - ch4, TxDMA - ch5 +void spi_setup(){ + // RCC->AHBENR |= RCC_AHBENR_GPIOBEN; // uncomment in common case + /* (1) Select AF mode on pins */ + /* (2) AF0 for SPI1 signals */ + GPIOB->MODER = (GPIOB->MODER & ~(GPIO_MODER_MODER3 | GPIO_MODER_MODER4 | GPIO_MODER_MODER5| + GPIO_MODER_MODER13 | GPIO_MODER_MODER14 | GPIO_MODER_MODER15)) | + GPIO_MODER_MODER3_AF | GPIO_MODER_MODER4_AF | GPIO_MODER_MODER5_AF | + GPIO_MODER_MODER13_AF | GPIO_MODER_MODER14_AF | GPIO_MODER_MODER15_AF; /* (1) */ + GPIOB->AFR[0] = (GPIOB->AFR[0] & ~(GPIO_AFRL_AFRL3 | GPIO_AFRL_AFRL4 | GPIO_AFRL_AFRL5)); /* (2) */ + GPIOB->AFR[1] = (GPIOB->AFR[1] & ~(GPIO_AFRH_AFRH5 | GPIO_AFRH_AFRH6 | GPIO_AFRH_AFRH7)); /* (2) */ + // enable clocking + RCC->AHBENR |= RCC_AHBENR_DMA1EN; + RCC->APB2ENR |= RCC_APB2ENR_SPI1EN; + // SPI1 - master, SPI2 - slave + spicommonsetup(0, 1); + spicommonsetup(1, 0); +} + +// SPI1 Tx (channel 3) +void dma1_channel2_3_isr(){ + if(DMA1->ISR & DMA_ISR_TCIF3){ // transfer done + DMA1->IFCR |= DMA_IFCR_CTCIF3; + SPI_status[0] = SPI_READY; + USND("SPI1 tx done\n"); + } + if(DMA1->ISR & DMA_ISR_TEIF2){ // receiver overflow + DMA1->IFCR |= DMA_IFCR_CTEIF2; + overfl[0] = 1; + } +} + +// SPI2 Tx (channel 5) +void dma1_channel4_5_isr(){ + if(DMA1->ISR & DMA_ISR_TCIF5){ + DMA1->IFCR |= DMA_IFCR_CTCIF5; + SPI_status[1] = SPI_READY; + USND("SPI2 tx done\n"); + } + if(DMA1->ISR & DMA_ISR_TEIF4){ + DMA1->IFCR |= DMA_IFCR_CTEIF4; + overfl[1] = 1; + } +} + +/** + * @brief SPI_transmit - transmit data over SPI DMA + * @param N - SPI number (0 - SPI1, 1 - SPI2) + * @param buf - data to transmit + * @param len - its length + * @return 0 if all OK + */ +uint8_t SPI_transmit(uint8_t N, const uint8_t *buf, uint8_t len){ + if(!buf || !len || len > SPIBUFSZ || N >= SPInumber) return 1; // bad data format + if(SPI_status[N] != SPI_READY) return 2; // spi not ready to transmit data + txDMA[N]->CCR &=~ DMA_CCR_EN; + memcpy(outbuf[N], buf, len); + txDMA[N]->CNDTR = len; + SPI_status[N] = SPI_BUSY; + SPI_prep_receive(N); + txDMA[N]->CCR |= DMA_CCR_EN; + return 0; +} + +// prepare channel N to receive data, return 0 if all OK +uint8_t SPI_prep_receive(uint8_t N){ + if(N >= SPInumber) return 1; + if(SPI_status[N] != SPI_READY) return 2; // still transmitting data + overfl[N] = 0; + rxDMA[N]->CCR &= ~DMA_CCR_EN; + rxDMA[N]->CNDTR = SPIBUFSZ; + rxDMA[N]->CCR |= DMA_CCR_EN; + return 0; +} + +/** + * @brief SPI_getdata - get data received by DMA & reload receiver + * @param N - number of channel (0/1) + * @param buf - buffer for data (with length maxlen) or NULL + * @param maxlen - (I) - amount of received bytes (or 0 if buffer is empty), + * (O) - amount of real bytes amount in buffer (could be > maxlen if maxlen < SPIBUFSZ) + * @return 0 if all OK or error code + */ +uint8_t SPI_getdata(uint8_t N, uint8_t *buf, uint8_t *maxlen){ + if(N >= SPInumber) return 1; + if(SPI_status[N] != SPI_READY) return 2; // still transmitting data + rxDMA[N]->CCR &= ~DMA_CCR_EN; + overfl[N] = 0; + uint8_t remain = rxDMA[N]->CNDTR; + if(maxlen){ + if(buf && *maxlen) memcpy(buf, inbuff[N], *maxlen); + *maxlen = SPIBUFSZ - remain; // bytes received + } + rxDMA[N]->CNDTR = SPIBUFSZ; + rxDMA[N]->CCR |= DMA_CCR_EN; + return 0; +} + +// return 1 if given channel overflowed & clear overflow flag +// should be called BEFORE SPI_prep_receive() or SPI_getdata() +uint8_t SPI_isoverflow(uint8_t N){ + if(N >= SPInumber) return 1; + register uint8_t o = overfl[N]; + overfl[N] = 0; + return o; +} diff --git a/F0-nolib/F0_testbrd/spi.h b/F0-nolib/F0_testbrd/spi.h new file mode 100644 index 0000000..208a739 --- /dev/null +++ b/F0-nolib/F0_testbrd/spi.h @@ -0,0 +1,43 @@ +/* + * This file is part of the F0testbrd project. + * Copyright 2021 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once +#ifndef SPI_H__ +#define SPI_H__ + +#include "stm32f0.h" + +#define SPInumber (2) + +#define SPIBUFSZ 4 + +typedef enum{ + SPI_NOTREADY, + SPI_READY, + SPI_BUSY +} spiStatus; + +extern spiStatus SPI_status[]; + +void spi_setup(); +uint8_t SPI_transmit(uint8_t N, const uint8_t *buf, uint8_t len); +uint8_t SPI_prep_receive(uint8_t N); +uint8_t SPI_getdata(uint8_t N, uint8_t *buf, uint8_t *maxlen); +uint8_t SPI_isoverflow(uint8_t N); + +#endif // SPI_H__