eddy/stm32samples
1
0
Fork 0
mirror of https://github.com/eddyem/stm32samples.git synced 2025-12-06 02:35:23 +03:00
Code Issues Packages Projects Releases Wiki Activity

Start fixing code for real usage

Browse Source
This commit is contained in:
Edward Emelianov 2025-09-14 23:15:57 +03:00
parent d790a1610d
commit ec8d56c4ae
4 changed files with 202 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

194
F3:F303/I2C_scan/i2c.c
View File

@ -23,14 +23,15 @@
#include "strfunc.h" // hexdump #include "strfunc.h" // hexdump
#include "usb.h" #include "usb.h"
I2C_SPEED curI2Cspeed = LOW_SPEED; i2c_speed_t i2c_curspeed = I2C_SPEED_AMOUNT;
extern volatile uint32_t Tms; extern volatile uint32_t Tms;
static uint32_t cntr; static uint32_t cntr;
static uint8_t i2c_got_DMA_Rx = 0; volatile uint8_t i2c_scanmode = 0; // == 1 when I2C is in scan mode
volatile uint8_t I2C_scan_mode = 0; // == 1 when I2C is in scan mode volatile uint8_t i2c_got_DMA = 0; // got DMA data
static uint8_t i2caddr = I2C_ADDREND; // current address in scan mode static uint8_t i2caddr = I2C_ADDREND; // current address in scan mode
static volatile int I2Cbusy = 0, goterr = 0; // busy==1 when DMA active, goterr==1 if 't was error @ last sent static volatile int I2Cbusy = 0, goterr = 0; // busy==1 when DMA active, goterr==1 if 't was error @ last sent
static uint8_t I2Cbuf[256], i2cbuflen = 0; // buffer for DMA tx/rx and its len static uint8_t I2Cbuf[I2C_BUFSIZE], i2cbuflen = 0; // buffer for DMA tx/rx and its len
static uint8_t bigendian = 0; // ==1 for big-endian 16-bit data
// macros for I2C rx/tx // macros for I2C rx/tx
#define DMARXCCR (DMA_CCR_MINC | DMA_CCR_TCIE | DMA_CCR_TEIE) #define DMARXCCR (DMA_CCR_MINC | DMA_CCR_TCIE | DMA_CCR_TEIE)
@ -48,14 +49,44 @@ static inline int isI2Cbusy(){
} }
// GPIO Resources: I2C1_SCL - PB6 (AF4), I2C1_SDA - PB7 (AF4) // GPIO Resources: I2C1_SCL - PB6 (AF4), I2C1_SDA - PB7 (AF4)
void i2c_setup(I2C_SPEED speed){ void i2c_setup(i2c_speed_t speed){
if(speed >= CURRENT_SPEED){ uint8_t PRESC, SCLDEL = 0x04, SDADEL = 0x03, SCLH, SCLL; // I2C1->TIMINGR fields
speed = curI2Cspeed; switch(speed){
}else{ case I2C_SPEED_10K:
curI2Cspeed = speed; PRESC = 0x0F;
SCLH = 0xDA;
SCLL = 0xE0;
break;
case I2C_SPEED_100K:
PRESC = 0x0F;
SCLH = 0x13;
SCLL = 0x16;
break;
case I2C_SPEED_400K:
PRESC = 0x07;
SCLH = 0x08;
SCLL = 0x09;
break;
case I2C_SPEED_1M:
SDADEL = 1;
SCLDEL = 2;
PRESC = 0x3;
SCLH = 0x4;
SCLL = 0x6;
break;
case I2C_SPEED_2M:
SDADEL = 0;
SCLDEL = 1;
PRESC = 0x0;
SCLH = 0x1;
SCLL = 0x2;
break;
default:
USND("Wrong I2C speed!\n");
return; // wrong speed
} }
RCC->AHBENR |= RCC_AHBENR_GPIOBEN; RCC->AHBENR |= RCC_AHBENR_GPIOBEN;
I2C1->CR1 = 0; I2C1->CR1 = 0; // disable I2C for setup
I2C1->ICR = 0x3f38; // clear all errors I2C1->ICR = 0x3f38; // clear all errors
GPIOB->AFR[0] = (GPIOB->AFR[0] & ~(GPIO_AFRL_AFRL6 | GPIO_AFRL_AFRL7)) | GPIOB->AFR[0] = (GPIOB->AFR[0] & ~(GPIO_AFRL_AFRL6 | GPIO_AFRL_AFRL7)) |
AFRf(4, 6) | AFRf(4, 7); AFRf(4, 6) | AFRf(4, 7);
@ -66,25 +97,19 @@ void i2c_setup(I2C_SPEED speed){
GPIOB->OTYPER |= GPIO_OTYPER_OT_6 | GPIO_OTYPER_OT_7; // both open-drain outputs GPIOB->OTYPER |= GPIO_OTYPER_OT_6 | GPIO_OTYPER_OT_7; // both open-drain outputs
// I2C (default timing from sys clock - 72MHz) // I2C (default timing from sys clock - 72MHz)
RCC->APB1ENR |= RCC_APB1ENR_I2C1EN; // clocking RCC->APB1ENR |= RCC_APB1ENR_I2C1EN; // clocking
if(speed == HIGH_SPEED){ if(speed < I2C_SPEED_400K){ // slow cpeed - common mode
// activate "fast mode plus"
SYSCFG->CFGR1 |= SYSCFG_CFGR1_I2C1_FMP | SYSCFG_CFGR1_I2C_PB6_FMP | SYSCFG_CFGR1_I2C_PB7_FMP;
}else{
SYSCFG->CFGR1 &= ~(SYSCFG_CFGR1_I2C1_FMP | SYSCFG_CFGR1_I2C_PB6_FMP | SYSCFG_CFGR1_I2C_PB7_FMP); SYSCFG->CFGR1 &= ~(SYSCFG_CFGR1_I2C1_FMP | SYSCFG_CFGR1_I2C_PB6_FMP | SYSCFG_CFGR1_I2C_PB7_FMP);
}else{ // activate "fast mode plus"
SYSCFG->CFGR1 |= SYSCFG_CFGR1_I2C1_FMP | SYSCFG_CFGR1_I2C_PB6_FMP | SYSCFG_CFGR1_I2C_PB7_FMP;
} }
if(speed == LOW_SPEED){ // 100kHz I2C1->TIMINGR = (PRESC<<I2C_TIMINGR_PRESC_Pos) | (SCLDEL<<I2C_TIMINGR_SCLDEL_Pos) |
I2C1->TIMINGR = (0xf<<28) | (0x04<<20) | (0x03<<16) | (0x12<<8) | (0x15); (SDADEL<<I2C_TIMINGR_SDADEL_Pos) | (SCLH<<I2C_TIMINGR_SCLH_Pos) | (SCLL<< I2C_TIMINGR_SCLL_Pos);
// PRESC SCLDEL SDADEL SCLH SCLL
}else if(speed == HIGH_SPEED){ // 400kHz
I2C1->TIMINGR = (0x06<<28) | (0x04<<20) | (0x03<<16) | (0x06<<8) | (0x08);
}else{ // VERYLOW_SPEED - 10kHz
I2C1->TIMINGR = (0xf<<28) | (0x04<<20) | (0x03<<16) | (0xc3<<8) | (0xc7);
}
I2C1->CR1 = I2CCR1; I2C1->CR1 = I2CCR1;
RCC->AHBENR |= RCC_AHBENR_DMA1EN; RCC->AHBENR |= RCC_AHBENR_DMA1EN;
NVIC_EnableIRQ(DMA1_Channel6_IRQn); NVIC_EnableIRQ(DMA1_Channel6_IRQn);
NVIC_EnableIRQ(DMA1_Channel7_IRQn); NVIC_EnableIRQ(DMA1_Channel7_IRQn);
I2Cbusy = 0; I2Cbusy = 0;
i2c_curspeed = speed;
} }
// setup DMA for rx (tx==0) or tx (tx==1) // setup DMA for rx (tx==0) or tx (tx==1)
@ -103,30 +128,24 @@ static void i2cDMAsetup(int tx, uint8_t len){
} }
} }
static uint8_t i2c_chk(uint8_t busychk){ // return 1 if line busy (also show error message and clear busy flag)
I2C1->CR2 = 0; static uint8_t i2c_chkbusy(){
if(busychk){
cntr = Tms; cntr = Tms;
while(I2C1->ISR & I2C_ISR_BUSY){ while(I2C1->ISR & I2C_ISR_BUSY){
IWDG->KR = IWDG_REFRESH; IWDG->KR = IWDG_REFRESH;
if(Tms - cntr > I2C_TIMEOUT){ if(Tms - cntr > I2C_TIMEOUT){
USND("i2c_chk: Line busy\n"); USND("i2c_chkbusy: Line busy;");
return 0; // check busy USND("I2c->ISR = "); USND(uhex2str(I2C1->ISR)); newline();
}} I2C1->ICR = I2C_ICR_BERRCF;
}/* return 1; // line busy
cntr = Tms; }
while(I2C1->CR2 & I2C_CR2_START){ }
IWDG->KR = IWDG_REFRESH; return 0;
if(Tms - cntr > I2C_TIMEOUT){
USND("i2c_chk: No start\n");
return 0; // check start
}}*/
return 1;
} }
// start writing // start writing
static uint8_t i2c_startw(uint8_t addr, uint8_t nbytes, uint8_t stop){ static uint8_t i2c_startw(uint8_t addr, uint8_t nbytes, uint8_t stop){
if(!i2c_chk(1)) return 0; if(i2c_chkbusy()) return 0;
I2C1->CR2 = nbytes << 16 | addr; I2C1->CR2 = nbytes << 16 | addr;
if(stop){ if(stop){
I2C1->CR2 |= I2C_CR2_AUTOEND; // autoend I2C1->CR2 |= I2C_CR2_AUTOEND; // autoend
@ -168,10 +187,7 @@ static uint8_t write_i2cs(uint8_t addr, uint8_t *data, uint8_t nbytes, uint8_t s
} }
cntr = Tms; cntr = Tms;
if(stop){ if(stop){
while(I2C1->ISR & I2C_ISR_BUSY){ if(i2c_chkbusy()) return 0;
IWDG->KR = IWDG_REFRESH;
if(Tms - cntr > I2C_TIMEOUT){USND("write_i2cs: Busy timeout\n"); break;}
}
}else{ // repeated start }else{ // repeated start
while(!(I2C1->ISR & I2C_ISR_TC)){ while(!(I2C1->ISR & I2C_ISR_TC)){
IWDG->KR = IWDG_REFRESH; IWDG->KR = IWDG_REFRESH;
@ -202,8 +218,7 @@ uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint8_t nbytes){
} }
// start reading // start reading
static uint8_t i2c_startr(uint8_t addr, uint8_t nbytes, uint8_t busychk){ static uint8_t i2c_startr(uint8_t addr, uint8_t nbytes){
if(!i2c_chk(busychk)) return 0;
// read N bytes // read N bytes
I2C1->CR2 = (nbytes<<16) | addr /*| I2C_CR2_AUTOEND*/ | I2C_CR2_RD_WRN; I2C1->CR2 = (nbytes<<16) | addr /*| I2C_CR2_AUTOEND*/ | I2C_CR2_RD_WRN;
I2C1->CR2 |= I2C_CR2_START; I2C1->CR2 |= I2C_CR2_START;
@ -217,8 +232,9 @@ static uint8_t i2c_startr(uint8_t addr, uint8_t nbytes, uint8_t busychk){
* `data` should be an array with at least `nbytes` length * `data` should be an array with at least `nbytes` length
* @return 1 if all OK, 0 if NACK or no device found * @return 1 if all OK, 0 if NACK or no device found
*/ */
static uint8_t read_i2cb(uint8_t addr, uint8_t *data, uint8_t nbytes, uint8_t busychk){ static uint8_t *read_i2cb(uint8_t addr, uint8_t nbytes, uint8_t busychk){
if(!i2c_startr(addr, nbytes, busychk)) return 0; if(busychk && i2c_chkbusy()) return NULL;
if(!i2c_startr(addr, nbytes)) return NULL;
uint8_t i; uint8_t i;
for(i = 0; i < nbytes; ++i){ for(i = 0; i < nbytes; ++i){
cntr = Tms; cntr = Tms;
@ -226,31 +242,22 @@ static uint8_t read_i2cb(uint8_t addr, uint8_t *data, uint8_t nbytes, uint8_t bu
IWDG->KR = IWDG_REFRESH; IWDG->KR = IWDG_REFRESH;
if(I2C1->ISR & I2C_ISR_NACKF){ if(I2C1->ISR & I2C_ISR_NACKF){
I2C1->ICR |= I2C_ICR_NACKCF; I2C1->ICR |= I2C_ICR_NACKCF;
USND("read_i2_nostart: NAK\n"); USND("read_i2cb: NAK\n");
return 0; return NULL;
} }
if(Tms - cntr > I2C_TIMEOUT){ if(Tms - cntr > I2C_TIMEOUT){
USND("read_i2_nostart: Timeout\n"); USND("read_i2cb: Timeout\n");
return 0; return NULL;
} }
} }
*data++ = I2C1->RXDR; I2Cbuf[i] = I2C1->RXDR;
}/*
cntr = Tms;
while(!(I2C1->ISR & I2C_ISR_TC)){
IWDG->KR = IWDG_REFRESH;
if(Tms - cntr > I2C_TIMEOUT){
USND("read_i2cs: TC timeout\n");
return 0;
} }
} return I2Cbuf;
I2C1->CR2 = I2C_CR2_STOP;*/
return 1;
} }
uint8_t read_i2c(uint8_t addr, uint8_t *data, uint8_t nbytes){ uint8_t *read_i2c(uint8_t addr, uint8_t nbytes){
if(isI2Cbusy()) return 0; if(isI2Cbusy()) return 0;
return read_i2cb(addr, data, nbytes, 1); return read_i2cb(addr, nbytes, 1);
} }
uint8_t read_i2c_dma(uint8_t addr, uint8_t nbytes){ uint8_t read_i2c_dma(uint8_t addr, uint8_t nbytes){
@ -258,31 +265,41 @@ uint8_t read_i2c_dma(uint8_t addr, uint8_t nbytes){
if(isI2Cbusy()) return 0; if(isI2Cbusy()) return 0;
i2cDMAsetup(0, nbytes); i2cDMAsetup(0, nbytes);
goterr = 0; goterr = 0;
if(!i2c_startr(addr, nbytes, 1)) return 0; if(i2c_chkbusy() || !i2c_startr(addr, nbytes)) return 0;
i2c_got_DMA = 0;
I2Cbusy = 1; I2Cbusy = 1;
DMA1_Channel7->CCR = DMARXCCR | DMA_CCR_EN; // start transfer DMA1_Channel7->CCR = DMARXCCR | DMA_CCR_EN; // start transfer
return 1; return 1;
} }
static void swapbytes(uint16_t *data, int datalen){
if(!datalen) return;
for(int i = 0; i < datalen; ++i)
data[i] = __REV16(data[i]);
}
// read register reg // read register reg
uint8_t read_i2c_reg(uint8_t addr, uint8_t reg, uint8_t *data, uint8_t nbytes){ uint8_t *read_i2c_reg(uint8_t addr, uint8_t reg, uint8_t nbytes){
if(isI2Cbusy()) return 0; if(isI2Cbusy()) return NULL;
if(!write_i2cs(addr, &reg, 1, 0)) return 0; if(!write_i2cs(addr, &reg, 1, 0)) return NULL;
return read_i2cb(addr, data, nbytes, 0); return read_i2cb(addr, nbytes, 0);
} }
// read 16bit register reg // read 16bit register reg
uint8_t read_i2c_reg16(uint8_t addr, uint16_t reg16, uint8_t *data, uint8_t nbytes){ uint16_t *read_i2c_reg16(uint8_t addr, uint16_t reg16, uint8_t nwords){
if(isI2Cbusy()) return 0; if(isI2Cbusy() || nwords < 1 || nwords > I2C_BUFSIZE/2) return 0;
reg16 = __REV16(reg16); if(bigendian) reg16 = __REV16(reg16);
if(!write_i2cs(addr, (uint8_t*)&reg16, 2, 0)) return 0; if(!write_i2cs(addr, (uint8_t*)&reg16, 2, 0)) return NULL;
return read_i2cb(addr, data, nbytes, 0); if(!read_i2cb(addr, nwords*2, 0)) return NULL;
uint16_t *buf = (uint16_t*)I2Cbuf;
//hexdump(USB_sendstr, I2Cbuf, nwords*2);
if(bigendian) swapbytes(buf, nwords);
return buf;
} }
void i2c_init_scan_mode(){ void i2c_init_scan_mode(){
i2caddr = 1; // start from 1 as 0 is a broadcast address i2caddr = 1; // start from 1 as 0 is a broadcast address
I2C_scan_mode = 1; i2c_scanmode = 1;
} }
// return 1 if next addr is active & return in as `addr` // return 1 if next addr is active & return in as `addr`
@ -293,14 +310,10 @@ int i2c_scan_next_addr(uint8_t *addr){
*addr = i2caddr; *addr = i2caddr;
if(i2caddr == I2C_ADDREND){ if(i2caddr == I2C_ADDREND){
*addr = I2C_ADDREND; *addr = I2C_ADDREND;
I2C_scan_mode = 0; i2c_scanmode = 0;
return 0; return 0;
} }
/*while(!u3txrdy); if(!read_i2c((i2caddr++)<<1, 1)) return 0;
USND("Addr: "); USND(uhex2str(i2caddr)); USND("\n");
usart3_sendbuf();*/
uint8_t byte;
if(!read_i2c((i2caddr++)<<1, &byte, 1)) return 0;
return 1; return 1;
} }
@ -314,10 +327,17 @@ void i2c_bufdudump(){
hexdump(USB_sendstr, I2Cbuf, i2cbuflen); hexdump(USB_sendstr, I2Cbuf, i2cbuflen);
} }
void i2c_have_DMA_Rx(){ // get DMA buffer with conversion to little-endian; return 0 if no data, -1 on err, or words amount
if(!i2c_got_DMA_Rx) return; // TODO: fix this function, it should be called only for DMA reading!
i2c_got_DMA_Rx = 0; int i2c_getwords(uint16_t *buf, int bufsz){
i2c_bufdudump(); if(!buf || bufsz < 1) return -1;
if(i2cbuflen < 2) return 0;
if(bufsz > i2cbuflen / 2) bufsz = i2cbuflen / 2;
if(bigendian){
uint16_t *b = (uint16_t*)I2Cbuf;
for(int i = 0; i < bufsz; ++i) buf[i] = __REV(b[i]);
}else memcpy(buf, I2Cbuf, bufsz * 2);
return bufsz;
} }
int i2cdma_haderr(){ int i2cdma_haderr(){
@ -326,12 +346,16 @@ int i2cdma_haderr(){
return r; return r;
} }
void endianness(uint8_t isbig){
bigendian = isbig;
}
// Rx (7) /Tx (6) interrupts // Rx (7) /Tx (6) interrupts
static void I2C_isr(int rx){ static void I2C_isr(int rx){
uint32_t isr = DMA1->ISR; uint32_t isr = DMA1->ISR;
DMA_Channel_TypeDef *ch = (rx) ? DMA1_Channel7 : DMA1_Channel6; DMA_Channel_TypeDef *ch = (rx) ? DMA1_Channel7 : DMA1_Channel6;
if(isr & (DMA_ISR_TEIF6 | DMA_ISR_TEIF6)) goterr = 1; if(isr & (DMA_ISR_TEIF6 | DMA_ISR_TEIF6)) goterr = 1;
if(rx) i2c_got_DMA_Rx = 1; // last transfer was Rx if(rx) i2c_got_DMA = 1; // last transfer was Rx
ch->CCR = 0; ch->CCR = 0;
I2Cbusy = 0; I2Cbusy = 0;
DMA1->IFCR = 0x0ff00000; // clear all flags for channel6/7 DMA1->IFCR = 0x0ff00000; // clear all flags for channel6/7

28
F3:F303/I2C_scan/i2c.h
View File

@ -20,31 +20,35 @@
#include <stdint.h> #include <stdint.h>
#define I2C_ADDREND (0x80) #define I2C_ADDREND (0x80)
#define I2C_BUFSIZE (256)
typedef enum{ typedef enum{
VERYLOW_SPEED, I2C_SPEED_10K,
LOW_SPEED, I2C_SPEED_100K,
HIGH_SPEED, I2C_SPEED_400K,
CURRENT_SPEED I2C_SPEED_1M,
} I2C_SPEED; I2C_SPEED_2M, // EXPERIMENTAL! Could be unstable!!! (speed near 1.9Mbaud)
I2C_SPEED_AMOUNT
} i2c_speed_t;
extern I2C_SPEED curI2Cspeed; extern i2c_speed_t i2c_curspeed;
extern volatile uint8_t I2C_scan_mode; extern volatile uint8_t i2c_scanmode, i2c_got_DMA;
// timeout of I2C bus in ms // timeout of I2C bus in ms
#define I2C_TIMEOUT (100) #define I2C_TIMEOUT (100)
void i2c_setup(I2C_SPEED speed); void i2c_setup(i2c_speed_t speed);
uint8_t read_i2c(uint8_t addr, uint8_t *data, uint8_t nbytes); uint8_t *read_i2c(uint8_t addr, uint8_t nbytes);
uint8_t read_i2c_reg(uint8_t addr, uint8_t reg, uint8_t *data, uint8_t nbytes); uint8_t *read_i2c_reg(uint8_t addr, uint8_t reg, uint8_t nbytes);
uint8_t read_i2c_reg16(uint8_t addr, uint16_t reg16, uint8_t *data, uint8_t nbytes); uint16_t *read_i2c_reg16(uint8_t addr, uint16_t reg16, uint8_t nbytes);
uint8_t write_i2c(uint8_t addr, uint8_t *data, uint8_t nbytes); uint8_t write_i2c(uint8_t addr, uint8_t *data, uint8_t nbytes);
uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint8_t nbytes); uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint8_t nbytes);
uint8_t read_i2c_dma(uint8_t addr, uint8_t nbytes); uint8_t read_i2c_dma(uint8_t addr, uint8_t nbytes);
void i2c_bufdudump(); void i2c_bufdudump();
void i2c_have_DMA_Rx();
int i2cdma_haderr(); int i2cdma_haderr();
void endianness(uint8_t isbig);
int i2c_getwords(uint16_t *buf, int bufsz);
void i2c_init_scan_mode(); void i2c_init_scan_mode();
int i2c_scan_next_addr(uint8_t *addr); int i2c_scan_next_addr(uint8_t *addr);

13
F3:F303/I2C_scan/main.c
View File

@ -39,22 +39,22 @@ int main(void){
SysTick_Config((uint32_t)48000); // 1ms SysTick_Config((uint32_t)48000); // 1ms
} }
hw_setup(); hw_setup();
i2c_setup(I2C_SPEED_10K); // start from lowest speed
USB_setup(); USB_setup();
uint32_t ctr = Tms; uint32_t ctr = Tms;
while(1){ while(1){
if(Tms - ctr > 499){ if(Tms - ctr > 499){
ctr = Tms; ctr = Tms;
pin_toggle(GPIOB, 1 << 1 | 1 << 0); // toggle LED @ PB0 pin_toggle(GPIOB, 1 << 1 | 1 << 0); // toggle LED @ PB0
//USND("HALO\n");
} }
USB_proc(); USB_proc();
int l = USB_receivestr(inbuff, MAXSTRLEN); int l = USB_receivestr(inbuff, MAXSTRLEN);
if(l < 0) USB_sendstr("ERROR: USB buffer overflow or string was too long\n"); if(l < 0) USND("ERROR: USB buffer overflow or string was too long\n");
else if(l){ else if(l){
const char *ans = parse_cmd(inbuff); const char *ans = parse_cmd(inbuff);
if(ans) USB_sendstr(ans); if(ans) USND(ans);
} }
if(I2C_scan_mode){ if(i2c_scanmode){
uint8_t addr; uint8_t addr;
int ok = i2c_scan_next_addr(&addr); int ok = i2c_scan_next_addr(&addr);
if(addr == I2C_ADDREND) USND("Scan ends\n"); if(addr == I2C_ADDREND) USND("Scan ends\n");
@ -64,6 +64,9 @@ int main(void){
USND(") - found device\n"); USND(") - found device\n");
} }
} }
i2c_have_DMA_Rx(); // check if there's DMA Rx complete if(i2c_got_DMA){
i2c_bufdudump();
i2c_got_DMA = 0;
}
} }
} }

102
F3:F303/I2C_scan/proto.c
View File

@ -28,37 +28,49 @@
static uint8_t locBuffer[LOCBUFFSZ]; static uint8_t locBuffer[LOCBUFFSZ];
extern volatile uint32_t Tms; extern volatile uint32_t Tms;
const char *helpstring = static const char *OK = "OK\n";
static const char *helpstring =
"https://github.com/eddyem/stm32samples/tree/master/F3:F303/I2C_scan build#" BUILD_NUMBER " @ " BUILD_DATE "\n" "https://github.com/eddyem/stm32samples/tree/master/F3:F303/I2C_scan build#" BUILD_NUMBER " @ " BUILD_DATE "\n"
"i0..2 - setup I2C with lowest..highest speed (7.7, 10 and 100kHz)\n" "i0..3 - setup I2C with speed 10k, 100k, 400k, 1M or 2M (experimental!)\n"
"B - switch to big-endian format for 16-bit registers\n"
"Ia addr - set I2C address\n" "Ia addr - set I2C address\n"
"Ig - dump content of I2Cbuf\n" "Ig - dump content of I2Cbuf\n"
"Iw bytes - send bytes (hex/dec/oct/bin) to I2C\n" "Iw bytes - send bytes (hex/dec/oct/bin) to I2C\n"
"IW bytes - the same over DMA\n" "IW bytes - the same over DMA\n"
"Ir reg n - read n bytes from I2C reg\n" "Ir reg n - read n bytes from I2C reg\n"
"I2 reg16 n - read n bytes from 16-bit register\n" "I2 reg16 n - read n words from 16-bit register\n"
"In n - just read n bytes\n" "In n - just read n bytes\n"
"IN n - the same but with DMA\n" "IN n - the same but with DMA\n"
"Is - scan I2C bus\n" "Is - scan I2C bus\n"
"L - switch to little-endian (default) format for 16-bit registers\n"
"T - print current Tms\n" "T - print current Tms\n"
; ;
static uint8_t i2cinited = 0;
TRUE_INLINE const char *setupI2C(const char *buf){ TRUE_INLINE const char *setupI2C(const char *buf){
if(!buf || !*buf){
USND("Current speed: "); USB_putbyte('0' + i2c_curspeed); newline();
return NULL;
}
buf = omit_spaces(buf); buf = omit_spaces(buf);
if(*buf < '0' || *buf > '2') return "Wrong speed\n"; int speed = *buf - '0';
i2c_setup(*buf - '0'); if(speed < 0 || speed >= I2C_SPEED_AMOUNT){
i2cinited = 1; return "Wrong speed!\n";
return "OK\n"; }
i2c_setup((i2c_speed_t)speed);
return OK;
} }
static uint8_t I2Caddress = 0; static uint8_t I2Caddress = 0;
TRUE_INLINE const char *saI2C(const char *buf){ TRUE_INLINE const char *saI2C(const char *buf){
uint32_t addr; uint32_t addr;
if(!getnum(buf, &addr) || addr > 0x7f) return "Wrong address\n"; USND("saI2C: '"); USND(buf); USND("'\n");
const char *nxt = getnum(buf, &addr);
if(nxt && nxt != buf){
if(addr > 0x7f) return "Wrong address\n";
I2Caddress = (uint8_t) addr << 1; I2Caddress = (uint8_t) addr << 1;
}else addr = I2Caddress >> 1;
USND("I2Caddr="); USND(uhex2str(addr)); newline(); USND("I2Caddr="); USND(uhex2str(addr)); newline();
return "OK\n"; return OK;
} }
static void rdI2C(const char *buf, int is16){ static void rdI2C(const char *buf, int is16){
uint32_t N = 0; uint32_t N = 0;
@ -85,35 +97,41 @@ static void rdI2C(const char *buf, int is16){
return; return;
} }
const char *erd = "Error reading I2C\n"; const char *erd = "Error reading I2C\n";
uint8_t *b8 = NULL; uint16_t *b16 = NULL;
if(noreg){ // don't write register if(noreg){ // don't write register
if(noreg == 1){ if(noreg == 1){
USND("Simple read:\n"); USND("Simple read:\n");
if(!read_i2c(I2Caddress, locBuffer, N)){ if(!(b8 = read_i2c(I2Caddress, N))){
USND(erd); USND(erd);
return; return;
} }
}else{ }else{
USND("Try to read using DMA .. "); USND("Try to read using DMA .. ");
if(!read_i2c_dma(I2Caddress, N)) USND(erd); if(!read_i2c_dma(I2Caddress, N)) USND(erd);
else USND("OK\n"); else USND(OK);
return; return;
} }
}else{ }else{
if(is16){ if(is16){
if(!read_i2c_reg16(I2Caddress, reg, locBuffer, N)){ if(!(b16 = read_i2c_reg16(I2Caddress, reg, N))){
USND(erd); USND(erd);
return; return;
} }
}else{ }else{
if(!read_i2c_reg(I2Caddress, reg, locBuffer, N)){ if(!(b8 = read_i2c_reg(I2Caddress, reg, N))){
USND(erd); USND(erd);
return; return;
} }
} }
} }
if(N == 0){ USND("OK\n"); return; } if(N == 0){ USND(OK); return; }
if(!noreg){USND("Register "); USND(uhex2str(reg)); USND(":\n");} if(!noreg){USND("Register "); USND(uhex2str(reg)); USND(":\n");}
hexdump(USB_sendstr, locBuffer, N); if(!is16){ hexdump(USB_sendstr, b8, N); return; }
for(int i = 0; i < (int)N; ++i){
USND(uhex2str(b16[i])); USB_putbyte(' ');
if((i & 7) == 7) newline();
}
if(N & 7) newline();
} }
// read N numbers from buf, @return 0 if wrong or none // read N numbers from buf, @return 0 if wrong or none
TRUE_INLINE uint16_t readNnumbers(const char *buf){ TRUE_INLINE uint16_t readNnumbers(const char *buf){
@ -133,33 +151,49 @@ static const char *wrI2C(const char *buf, int isdma){
int result = isdma ? write_i2c_dma(I2Caddress, locBuffer, N) : int result = isdma ? write_i2c_dma(I2Caddress, locBuffer, N) :
write_i2c(I2Caddress, locBuffer, N); write_i2c(I2Caddress, locBuffer, N);
if(!result) return "Error writing I2C\n"; if(!result) return "Error writing I2C\n";
return "OK\n"; return OK;
} }
const char *parse_cmd(const char *buf){ const char *parse_cmd(const char *buf){
// "long" commands if(!buf || !*buf) return NULL;
switch(*buf){ if(buf[1]) switch(*buf){ // "long" commands
case 'i': case 'i':
return setupI2C(buf + 1); return setupI2C(buf + 1);
break; break;
case 'I': case 'I':
if(!i2cinited) return "Init I2C first";
buf = omit_spaces(buf + 1); buf = omit_spaces(buf + 1);
if(*buf == 'a') return saI2C(buf + 1);
else if(*buf == 'r'){ rdI2C(buf + 1, 0); return NULL; }
else if(*buf == '2'){ rdI2C(buf + 1, 1); return NULL; }
else if(*buf == 'n'){ rdI2C(buf, 0); return NULL; }
else if(*buf == 'N'){ rdI2C(buf, 0); return NULL; }
else if(*buf == 'w') return wrI2C(buf + 1, 0);
else if(*buf == 'W') return wrI2C(buf + 1, 1);
else if(*buf == 's'){ i2c_init_scan_mode(); return "Start scan\n"; }
else if(*buf == 'g'){ i2c_bufdudump(); return NULL; }
else return "Command should be 'Ia', 'Iw', 'Ir' or 'Is'\n";
break;
}
// "short" commands
if(buf[1]) return buf; // echo wrong data
switch(*buf){ switch(*buf){
case 'a': return saI2C(buf + 1);
case 'r':
rdI2C(buf + 1, 0); return NULL;
case '2':
rdI2C(buf + 1, 1); return NULL;
case 'n':
case 'N':
rdI2C(buf, 0); return NULL;
case 'w': return wrI2C(buf + 1, 0);
case 'W': return wrI2C(buf + 1, 1);
case 's':
i2c_init_scan_mode(); return "Start scan\n";
case 'g':
i2c_bufdudump(); return NULL;
default:
return "Wrong I2C command, read help!\n";
}
break;
default:
return("Wrong command, try '?' for help\n");
}
switch(*buf){
case 'i': return setupI2C(NULL); // current settings
case 'B':
endianness(1);
return OK;
break;
case 'L':
endianness(0);
return OK;
break;
case 'T': case 'T':
USND("T="); USND("T=");
USND(u2str(Tms)); USND(u2str(Tms));