From 9573221c5f650727f66c93d5c2d4cdad0399f168 Mon Sep 17 00:00:00 2001 From: Edward Emelianov Date: Sun, 21 Feb 2021 23:46:43 +0300 Subject: [PATCH] add BMP180 --- F1-nolib/BMP180/BMP180.bin | Bin 0 -> 9880 bytes F1-nolib/BMP180/BMP180.c | 280 ++++++++++++++++++++++ F1-nolib/BMP180/BMP180.h | 54 +++++ F1-nolib/BMP180/Makefile | 139 +++++++++++ F1-nolib/BMP180/Readme | 1 + F1-nolib/BMP180/hardware.c | 48 ++++ F1-nolib/BMP180/hardware.h | 43 ++++ F1-nolib/BMP180/i2c.c | 236 ++++++++++++++++++ F1-nolib/BMP180/i2c.h | 41 ++++ F1-nolib/BMP180/main.c | 105 ++++++++ F1-nolib/BMP180/proto.c | 242 +++++++++++++++++++ F1-nolib/BMP180/proto.h | 30 +++ F1-nolib/BMP180/usb.c | 167 +++++++++++++ F1-nolib/BMP180/usb.h | 33 +++ F1-nolib/BMP180/usb_defs.h | 102 ++++++++ F1-nolib/BMP180/usb_lib.c | 476 +++++++++++++++++++++++++++++++++++++ F1-nolib/BMP180/usb_lib.h | 184 ++++++++++++++ 17 files changed, 2181 insertions(+) create mode 100755 F1-nolib/BMP180/BMP180.bin create mode 100644 F1-nolib/BMP180/BMP180.c create mode 100644 F1-nolib/BMP180/BMP180.h create mode 100644 F1-nolib/BMP180/Makefile create mode 100644 F1-nolib/BMP180/Readme create mode 100644 F1-nolib/BMP180/hardware.c create mode 100644 F1-nolib/BMP180/hardware.h create mode 100644 F1-nolib/BMP180/i2c.c create mode 100644 F1-nolib/BMP180/i2c.h create mode 100644 F1-nolib/BMP180/main.c create mode 100644 F1-nolib/BMP180/proto.c create mode 100644 F1-nolib/BMP180/proto.h create mode 100644 F1-nolib/BMP180/usb.c create mode 100644 F1-nolib/BMP180/usb.h create mode 100644 F1-nolib/BMP180/usb_defs.h create mode 100644 F1-nolib/BMP180/usb_lib.c create mode 100644 F1-nolib/BMP180/usb_lib.h diff --git a/F1-nolib/BMP180/BMP180.bin b/F1-nolib/BMP180/BMP180.bin new file mode 100755 index 0000000000000000000000000000000000000000..25181ade8956389a6ec7069c70991baea13c43d3 GIT binary patch literal 9880 zcmb_>3sh5Ay6`@aga9!Ff;I_QP7)9_R0C+WqaE{r19@l=bbPi31si8jBI=aRfA1wi z@10DTPDN~&mbSm6_D-i=Q+Zk2jx>(#%<60ACSvA?YTI;r+q5UsJ0}_>1U2{D0j$$I zbN_YM|FhP|etoa~z4qQGs1`8~<{{Ao0L#7w=v#jn2LqnQZBgcbrTI3G|LItu`2WxI zf2za(3qCrFRGob>2Jx*4c|XBWeGkRyDMB?TnuZXcJM~;VO-JzzB{y9dKsvea4u)0U z=Bh?MJwgm=MLdP%E<6TPGuCUNo#C@b$XHlWTn(spV z;mJoqa&bb%`k^gLi24yD9hTV$6~iJvm_Q{r0-ClB+Uo&=eF-oaz#sr)o+`5j@%>Y% zWFnAmrK0nYqHRmtW|z`MRva_N1B8aQ$XS_7I*j!*0^|c200?Vd8wHx;xjC?hzJBRh zv8|&|(?+Z$wBj-2jo8j_^j?*azfLfWi|msQ!#?3Z-XrFN`SNFX*gAo7%e}-RdX&)8 z{^Z2Qq`RN$o6KR(P3B79k|`?v{-XwBinw`hQW82h zDc0G!(pBds$y)IgbzM9qfq6PaObNz`DM|F}oO6>Xl$R@r{JDsVG*o;N|MP`?ZGy

E+Y2YLVK|(xUW-=zk*T{+wq9QT5tXF#5qe_UQKaadXP~*rX1ped{ zaZRKvHlu8`NaV0{BV_}=fvM>AdNc_C^*25)xAOwQYrd^WkpVhJ=ht8g*iAGimyBc^ z$s7N+Lt&;OYFVbE$n{7#dkv{70Smkf{%()$ITKqTvo7-Fwauxid!v^)GGOADQltZW z<%zgJ_e7j_Aif1`*B;w=h6IbU;psT61fO6(uL4*BVEQbXTna4$&<)Xrv_)W@>&$aP z>&SIwI&|k<)ff-sV1Md{>^wRMP%AQvY+buW785_0>S}0m)H{DZ{&<-wc7dt~su~AG zfs_OiLXV_`US`n^)qY=Q)$;_(W@~p4Az~%zw|xIdS|V6=ZNoa-jSs5GLjAQr=`$_q z*13*s$9hLLd)P6J_ns3iN(3x7UQ+AMQ�H@4^^DI;2M`*N|vIdQnNC*ebRt+{Zh* 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. + * + * 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 "i2c.h" +#include "BMP180.h" + +//#define EBUG + +#ifdef EBUG +#include "usb.h" +#include "proto.h" +#define DBG(x) do{USB_send(x);}while(0) +#else +#define DBG(x) +#endif + +#define BMP180_I2C_ADDRESS (0x77) +/** + * BMP180 registers + */ +#define BMP180_REG_OXLSB (0xF8) +#define BMP180_REG_OLSB (0xF7) +#define BMP180_REG_OMSB (0xF6) +#define BMP180_REG_OUT (BMP180_REG_OMSB) +#define BMP180_REG_CTRLMEAS (0xF4) +#define BMP180_REG_SOFTRESET (0xE0) +#define BMP180_REG_ID (0xD0) +#define BMP180_REG_CALIB (0xAA) + +// shift for oversampling +#define BMP180_CTRLM_OSS_SHIFT (6) +// start measurement +#define BMP180_CTRLM_SCO (1<<5) +// write it to BMP180_REG_SOFTRESET for soft reset +#define BMP180_SOFTRESET_VAL (0xB6) +// start measurement of T/P +#define BMP180_READ_T (0x0E) +#define BMP180_READ_P (0x14) + +// delays in milliseconds +//#define BMP180_T_DELAY (2) + +static BMP180_oversampling bmp180_os = BMP180_OVERS_2; + +static struct { + int16_t AC1; + int16_t AC2; + int16_t AC3; + uint16_t AC4; + uint16_t AC5; + uint16_t AC6; + int16_t B1; + int16_t B2; + int16_t MB; + int16_t MC; + int16_t MD; +} __attribute__ ((packed)) CaliData = {0}; + +static BMP180_status bmpstatus = BMP180_NOTINIT; +static uint8_t calidata_rdy = 0; +static uint32_t milliseconds_start = 0; // time of measurement start +//static uint32_t p_delay = 8; // delay for P measurement +static uint8_t uncomp_data[3]; // raw uncompensated data +static int32_t Tval; // uncompensated T value +// compensated values: +static uint32_t Pmeasured; // in Pa +static int32_t Tmeasured; // /10degC +static uint8_t devID = 0; + +BMP180_status BMP180_get_status(){ + return bmpstatus; +} + +void BMP180_setOS(BMP180_oversampling os){ + bmp180_os = os & 0x03; + /* + switch(os){ + case BMP180_OVERS_1: + p_delay = 5; + break; + case BMP180_OVERS_2: + p_delay = 8; + break; + case BMP180_OVERS_4: + p_delay = 14; + break; + default: + p_delay = 26; + }*/ +} + +static int read_reg8(uint8_t reg, uint8_t *val){ + if(I2C_OK != i2c_7bit_send_onebyte(reg, 0)) return 0; + if(I2C_OK != i2c_7bit_receive_onebyte(val, 1)) return 0; + return 1; +} + +static int write_reg8(uint8_t reg, uint8_t val){ + uint8_t d[2] = {reg, val}; + if(I2C_OK != i2c_7bit_send(d, 2)) return 0; + return 1; +} + +// get compensation data, return 1 if OK +static int readcompdata(){ + if(I2C_OK != i2c_7bit_send_onebyte(BMP180_REG_CALIB, 0)) return 0; + if(I2C_OK != i2c_7bit_receive((uint8_t*)&CaliData, sizeof(CaliData))) return 0; + // convert big-endian into little-endian + uint8_t *d, val; + uint16_t *arr = (uint16_t*)&CaliData; + for(int i = 0; i < (int)sizeof(CaliData)/2; ++i){ + d = (uint8_t*)(&arr[i]); + val = d[0]; + d[0] = d[1]; + d[1] = val; + } + calidata_rdy = 1; + return 1; +} + +// do a soft-reset procedure +int BMP180_reset(){ + if(!write_reg8(BMP180_REG_SOFTRESET, BMP180_SOFTRESET_VAL)){ + DBG("Can't reset\n"); + return 0; + } + return 1; +} + +// read compensation data & write registers +int BMP180_init(){ + bmpstatus = BMP180_NOTINIT; + i2c_setup(); + i2c_set_addr7(BMP180_I2C_ADDRESS); + if(!read_reg8(BMP180_REG_ID, &devID)) return 0; + DBG("Got device ID: "); DBG(u2str(devID)); DBG("\n"); + if(devID != BMP180_CHIP_ID){ + DBG("Not BMP180\n"); + return 0; + } + if(!readcompdata()){ + DBG("Can't read calibration data\n"); + }else{ + DBG("AC1="); + DBG(i2str(CaliData.AC1)); DBG(", AC2="); DBG(i2str(CaliData.AC2)); DBG(", AC3="); + DBG(i2str(CaliData.AC3)); DBG(", AC4="); DBG(u2str(CaliData.AC4)); DBG(", AC5="); + DBG(u2str(CaliData.AC5)); DBG(", AC6="); DBG(u2str(CaliData.AC6)); DBG(", B1="); + DBG(i2str(CaliData.B1)); DBG(", B2="); DBG(i2str(CaliData.B2)); DBG(", MB="); + DBG(i2str(CaliData.MB)); DBG(", MC="); DBG(i2str(CaliData.MC)); DBG(", MD="); + DBG(i2str(CaliData.MD)); DBG("\n"); + } + return 1; +} + +// @return 1 if OK, *devid -> BMP/BME +void BMP180_read_ID(uint8_t *devid){ + *devid = devID; +} + +// start measurement, @return 1 if all OK +int BMP180_start(uint32_t curr_milliseconds){ + if(!calidata_rdy || bmpstatus == BMP180_BUSYT || bmpstatus == BMP180_BUSYP) return 0; + uint8_t reg = BMP180_READ_T | BMP180_CTRLM_SCO; + if(!write_reg8(BMP180_REG_CTRLMEAS, reg)){ + DBG("Can't write CTRL reg\n"); + return 0; + } + bmpstatus = BMP180_BUSYT; + milliseconds_start = curr_milliseconds; + return 1; +} + + +// calculate T/10 degC and P in Pa +static inline void compens(uint32_t Pval){ + // T: + int32_t X1 = ((Tval - CaliData.AC6)*CaliData.AC5) >> 15; + int32_t X2 = (CaliData.MC << 11) / (X1 + CaliData.MD); + int32_t B5 = X1 + X2; + Tmeasured = (B5 + 8) >> 4; + // P: + int32_t B6 = B5 - 4000; + X1 = (CaliData.B2 * ((B6*B6) >> 12)) >> 11; + X2 = (CaliData.AC2 * B6) >> 11; + int32_t X3 = X1 + X2; + int32_t B3 = ((((CaliData.AC1 << 2) + X3) << bmp180_os) + 2) >> 2; + X1 = (CaliData.AC3 * B6) >> 13; + X2 = (CaliData.B1 * ((B6 * B6) >> 12)) >> 16; + X3 = ((X1 + X2) + 2) >> 2; + uint32_t B4 = (CaliData.AC4 * (uint32_t) (X3 + 32768)) >> 15; + uint32_t B7 = (uint32_t)(Pval - B3) * (50000 >> bmp180_os); + if(B7 < 0x80000000){ + Pmeasured = (B7 << 1) / B4; + }else{ + Pmeasured = (B7 / B4) << 1; + } + X1 = Pmeasured >> 8; + X1 *= X1; + X1 = (X1 * 3038) >> 16; + X2 = (-7357 * Pmeasured) >> 16; + Pmeasured += (X1 + X2 + 3791) >> 4; +} + +static int still_measuring(){ + uint8_t reg; + if(!read_reg8(BMP180_REG_CTRLMEAS, ®)) return 1; + if(reg & BMP180_CTRLM_SCO){ + DBG("Still measure\n"); + return 1; + } + return 0; +} + +void BMP180_process(uint32_t curr_milliseconds){ + uint8_t reg; + if(bmpstatus != BMP180_BUSYT && bmpstatus != BMP180_BUSYP) return; + if(bmpstatus == BMP180_BUSYT){ // wait for temperature + //if(curr_milliseconds - milliseconds_start < BMP180_T_DELAY) return; + if(still_measuring()) return; + // get uncompensated data + DBG("Read uncompensated T\n"); + if(I2C_OK != i2c_7bit_send_onebyte(BMP180_REG_OUT, 0)){ + bmpstatus = BMP180_ERR; + return; + } + if(I2C_OK != i2c_7bit_receive(uncomp_data, 2)){ + bmpstatus = BMP180_ERR; + return; + } + Tval = uncomp_data[0] << 8 | uncomp_data[1]; + DBG("Start P measuring\n"); + reg = BMP180_READ_P | BMP180_CTRLM_SCO | (bmp180_os << BMP180_CTRLM_OSS_SHIFT); + if(!write_reg8(BMP180_REG_CTRLMEAS, reg)){ + bmpstatus = BMP180_ERR; + return; + } + milliseconds_start = curr_milliseconds; + bmpstatus = BMP180_BUSYP; + }else{ // wait for pressure + //if(curr_milliseconds - milliseconds_start < p_delay) return; + if(still_measuring()) return; + DBG("Read uncompensated P\n"); + if(I2C_OK != i2c_7bit_send_onebyte(BMP180_REG_OUT, 0)){ + bmpstatus = BMP180_ERR; + return; + } + if(I2C_OK != i2c_7bit_receive(uncomp_data, 3)){ + bmpstatus = BMP180_ERR; + return; + } + uint32_t Pval = uncomp_data[0] << 16 | uncomp_data[1] << 8 | uncomp_data[2]; + Pval >>= (8 - bmp180_os); + // calculate compensated values + compens(Pval); + DBG("All data ready\n"); + bmpstatus = BMP180_RDY; // data ready + } +} + +// read data & convert it +void BMP180_getdata(int32_t *T, uint32_t *P){ + *T = Tmeasured; + *P = Pmeasured; + bmpstatus = BMP180_RELAX; +} diff --git a/F1-nolib/BMP180/BMP180.h b/F1-nolib/BMP180/BMP180.h new file mode 100644 index 0000000..08ac81c --- /dev/null +++ b/F1-nolib/BMP180/BMP180.h @@ -0,0 +1,54 @@ +/* + * This file is part of the BMP180 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 BMP180_H__ +#define BMP180_H__ + +#include + +#define BMP180_CHIP_ID 0x55 + +typedef enum{ + BMP180_NOTINIT, // wasn't inited + BMP180_BUSYT, // T measurement in progress + BMP180_BUSYP, // P measurement in progress + BMP180_ERR, // error in I2C + BMP180_RELAX, // relaxed state + BMP180_RDY, // data ready - can get it +} BMP180_status; + +typedef enum{ + BMP180_OVERS_1 = 0, // oversampling is off + BMP180_OVERS_2 = 1, + BMP180_OVERS_4 = 2, + BMP180_OVERS_8 = 3, + BMP180_OVERSMAX = 4 +} BMP180_oversampling; + + +int BMP180_reset(); +int BMP180_init(); +void BMP180_read_ID(uint8_t *devid); +void BMP180_setOS(BMP180_oversampling os); +BMP180_status BMP180_get_status(); +int BMP180_start(uint32_t curr_milliseconds); +void BMP180_process(uint32_t curr_milliseconds); +void BMP180_getdata(int32_t *T, uint32_t *P); + +#endif // BMP180_H__ diff --git a/F1-nolib/BMP180/Makefile b/F1-nolib/BMP180/Makefile new file mode 100644 index 0000000..ebcad14 --- /dev/null +++ b/F1-nolib/BMP180/Makefile @@ -0,0 +1,139 @@ +BINARY = BMP180 +BOOTPORT ?= /dev/ttyUSB0 +BOOTSPEED ?= 115200 +# MCU FAMILY +FAMILY ?= F1 +# MCU code +MCU ?= F103x8 +# density (stm32f10x.h, lines 70-84) +DENSITY ?= MD +# change this linking script depending on particular MCU model, +LDSCRIPT ?= stm32f103x8.ld +# debug +#DEFS = -DEBUG + +INDEPENDENT_HEADERS= + +FP_FLAGS ?= -msoft-float -mfloat-abi=soft +ASM_FLAGS ?= -mthumb -mcpu=cortex-m3 -mfix-cortex-m3-ldrd +ARCH_FLAGS = $(ASM_FLAGS) $(FP_FLAGS) + +############################################################################### +# Executables +#PREFIX ?= arm-none-eabi +# gcc from arm web site +PREFIX ?= /opt/bin/arm-none-eabi +TOOLCHLIB ?= /opt/arm-none-eabi/lib +RM := rm -f +RMDIR := rmdir +CC := $(PREFIX)-gcc +# don't replace ld with gcc: the binary size would be much greater!! +LD := $(PREFIX)-ld +AR := $(PREFIX)-ar +AS := $(PREFIX)-as +SIZE := $(PREFIX)-size +OBJCOPY := $(PREFIX)-objcopy +OBJDUMP := $(PREFIX)-objdump +GDB := $(PREFIX)-gdb +STFLASH := $(shell which st-flash) +STBOOT := $(shell which stm32flash) +DFUUTIL := $(shell which dfu-util) + +############################################################################### +# Source files +OBJDIR = mk +SRC := $(wildcard *.c) +OBJS := $(addprefix $(OBJDIR)/, $(SRC:%.c=%.o)) +STARTUP = $(OBJDIR)/startup.o +OBJS += $(STARTUP) +# dependencies: we need them to recompile files if their headers-dependencies changed +DEPS := $(OBJS:.o=.d) + +INC_DIR ?= ../inc + +INCLUDE := -I$(INC_DIR)/Fx -I$(INC_DIR)/cm +LIB_DIR := $(INC_DIR)/ld + +############################################################################### +# C flags +CFLAGS += -O2 -g -D__thumb2__=1 -MD +CFLAGS += -Wall -Werror -Wextra -Wshadow +CFLAGS += -fno-common -ffunction-sections -fdata-sections -fno-stack-protector +CFLAGS += $(ARCH_FLAGS) + +############################################################################### +# Linker flags +LDFLAGS += -nostartfiles --static -nostdlibs +LDFLAGS += -L$(LIB_DIR) -L$(TOOLCHLIB) +LDFLAGS += -T$(LDSCRIPT) + +############################################################################### +# Used libraries +LDLIBS += -lc $(shell $(CC) $(CFLAGS) -print-libgcc-file-name) + +DEFS += -DSTM32$(FAMILY) -DSTM32$(MCU) -DSTM32F10X_$(DENSITY) + +ELF := $(OBJDIR)/$(BINARY).elf +LIST := $(OBJDIR)/$(BINARY).list +BIN := $(BINARY).bin +HEX := $(BINARY).hex + +all: bin list size + +elf: $(ELF) +bin: $(BIN) +hex: $(HEX) +list: $(LIST) + +ifneq ($(MAKECMDGOALS),clean) +-include $(DEPS) +endif + +$(OBJDIR): + mkdir $(OBJDIR) + +$(STARTUP): $(INC_DIR)/startup/vector.c + $(CC) $(CFLAGS) $(DEFS) $(INCLUDE) -o $@ -c $< + +$(OBJDIR)/%.o: %.c + @echo " CC $<" + $(CC) $(CFLAGS) $(DEFS) $(INCLUDE) -o $@ -c $< + +$(BIN): $(ELF) + @echo " OBJCOPY $(BIN)" + $(OBJCOPY) -Obinary $(ELF) $(BIN) + +$(HEX): $(ELF) + @echo " OBJCOPY $(HEX)" + $(OBJCOPY) -Oihex $(ELF) $(HEX) + +$(LIST): $(ELF) + @echo " OBJDUMP $(LIST)" + $(OBJDUMP) -S $(ELF) > $(LIST) + +$(ELF): $(OBJDIR) $(OBJS) + @echo " LD $(ELF)" + $(LD) $(LDFLAGS) $(OBJS) $(LDLIBS) -o $(ELF) + +size: $(ELF) + $(SIZE) $(ELF) + +clean: + @echo " CLEAN" + $(RM) $(OBJS) $(DEPS) $(ELF) $(HEX) $(LIST) + @rmdir $(OBJDIR) 2>/dev/null || true + + +flash: $(BIN) + @echo " FLASH $(BIN)" + $(STFLASH) write $(BIN) 0x8000000 + +boot: $(BIN) + @echo " LOAD $(BIN) through bootloader" + $(STBOOT) -b$(BOOTSPEED) $(BOOTPORT) -w $(BIN) + +dfuboot: $(BIN) + @echo " LOAD $(BIN) THROUGH DFU" + $(DFUUTIL) -a0 -D $(BIN) -s 0x08000000 + +.PHONY: clean flash boot diff --git a/F1-nolib/BMP180/Readme b/F1-nolib/BMP180/Readme new file mode 100644 index 0000000..74e8004 --- /dev/null +++ b/F1-nolib/BMP180/Readme @@ -0,0 +1 @@ +Work with I2C humidity/temperature sensors SI7005 & HTU21D diff --git a/F1-nolib/BMP180/hardware.c b/F1-nolib/BMP180/hardware.c new file mode 100644 index 0000000..e3079e8 --- /dev/null +++ b/F1-nolib/BMP180/hardware.c @@ -0,0 +1,48 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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" + +static inline void gpio_setup(){ + // Enable clocks to the GPIO subsystems (PB for ADC), turn on AFIO clocking to disable SWD/JTAG + RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPCEN | RCC_APB2ENR_AFIOEN; + // turn off SWJ/JTAG +// AFIO->MAPR = AFIO_MAPR_SWJ_CFG_DISABLE; + AFIO->MAPR = AFIO_MAPR_SWJ_CFG_JTAGDISABLE; // for PA15 + // Set led as opendrain output + GPIOC->CRH |= CRH(13, CNF_ODOUTPUT|MODE_SLOW); + // USB pullup (PA15) - pushpull output + GPIOA->CRH = CRH(15, CNF_PPOUTPUT|MODE_SLOW); +} + +void hw_setup(){ + gpio_setup(); +} + +void iwdg_setup(){ + uint32_t tmout = 16000000; + RCC->CSR |= RCC_CSR_LSION; + while((RCC->CSR & RCC_CSR_LSIRDY) != RCC_CSR_LSIRDY){if(--tmout == 0) break;} /* (2) */ + IWDG->KR = IWDG_START; + IWDG->KR = IWDG_WRITE_ACCESS; + IWDG->PR = IWDG_PR_PR_1; + IWDG->RLR = 1250; + tmout = 16000000; + while(IWDG->SR){if(--tmout == 0) break;} + IWDG->KR = IWDG_REFRESH; +} diff --git a/F1-nolib/BMP180/hardware.h b/F1-nolib/BMP180/hardware.h new file mode 100644 index 0000000..210a040 --- /dev/null +++ b/F1-nolib/BMP180/hardware.h @@ -0,0 +1,43 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 __HARDWARE_H__ +#define __HARDWARE_H__ + +#include "stm32f1.h" + +// LED0 - PC13 (bluepill), blinking each second +#define LED0_port GPIOC +#define LED0_pin (1<<13) + +// USB pullup (not present in bluepill, should be soldered) - PA15 +#define USBPU_port GPIOA +#define USBPU_pin (1<<15) +#define USBPU_ON() pin_set(USBPU_port, USBPU_pin) +#define USBPU_OFF() pin_clear(USBPU_port, USBPU_pin) + +#define LED_blink(x) pin_toggle(x ## _port, x ## _pin) +#define LED_on(x) pin_clear(x ## _port, x ## _pin) +#define LED_off(x) pin_set(x ## _port, x ## _pin) + +void hw_setup(); +void iwdg_setup(); + + +#endif // __HARDWARE_H__ diff --git a/F1-nolib/BMP180/i2c.c b/F1-nolib/BMP180/i2c.c new file mode 100644 index 0000000..3c55ad8 --- /dev/null +++ b/F1-nolib/BMP180/i2c.c @@ -0,0 +1,236 @@ +/* + * This file is part of the BMP180 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 "i2c.h" + +#ifdef EBUG +#include "usb.h" +#include "proto.h" +#define DBG(x) do{USB_send(x);}while(0) +#else +#define DBG(x) +#endif + +extern volatile uint32_t Tms; + +// current addresses for read/write (should be set with i2c_set_addr7) +static uint8_t addr7r = 0, addr7w = 0; + +/* + * PB10/PB6 - I2C_SCL, PB11/PB7 - I2C_SDA or remap @ PB8 & PB9 + */ +void i2c_setup(){ + I2C1->CR1 = 0; + I2C1->SR1 = 0; + RCC->APB2ENR |= RCC_APB2ENR_IOPBEN; + GPIOB->CRL = (GPIOB->CRL & ~(GPIO_CRL_CNF6 | GPIO_CRL_CNF7)) | + CRL(6, CNF_AFOD | MODE_NORMAL) | CRL(7, CNF_AFOD | MODE_NORMAL); + RCC->APB1ENR |= RCC_APB1ENR_I2C1EN; + I2C1->CR2 = 8; // FREQR=8MHz, T=125ns + I2C1->TRISE = 9; // (9-1)*125 = 1mks + I2C1->CCR = 40; // normal mode, 8MHz/2/40 = 100kHz + I2C1->CR1 |= I2C_CR1_PE; // enable periph +} + +void i2c_set_addr7(uint8_t addr){ + addr7w = addr << 1; + addr7r = addr7w | 1; +} + +// wait for event evt no more than 2 ms +#define I2C_WAIT(evt) do{ register uint32_t wait4 = Tms + 2; \ + while(Tms < wait4 && !(evt)) IWDG->KR = IWDG_REFRESH; \ + if(!(evt)){ret = I2C_TMOUT; goto eotr;}}while(0) +// wait for !busy +#define I2C_LINEWAIT() do{ register uint32_t wait4 = Tms + 2; \ + while(Tms < wait4 && (I2C1->SR2 & I2C_SR2_BUSY)) IWDG->KR = IWDG_REFRESH; \ + if(I2C1->SR2 & I2C_SR2_BUSY){I2C1->CR1 |= I2C_CR1_SWRST; return I2C_LINEBUSY;}\ + }while(0) + +// start writing +static i2c_status i2c_7bit_startw(){ + i2c_status ret = I2C_LINEBUSY; + DBG("SR1="); DBG(u2str(I2C1->SR1)); DBG("\n"); + DBG("CR1="); DBG(u2str(I2C1->CR1)); DBG("\n"); + DBG("CR2="); DBG(u2str(I2C1->CR2)); DBG("\n"); + if(I2C1->CR1 != I2C_CR1_PE) i2c_setup(); + if(I2C1->SR1) I2C1->SR1 = 0; // clear NACK and other problems + (void) I2C1->SR2; + I2C_LINEWAIT(); + DBG("linew\n"); + I2C1->CR1 |= I2C_CR1_START; // generate start sequence + I2C_WAIT(I2C1->SR1 & I2C_SR1_SB); // wait for SB + DBG("SB\n"); + (void) I2C1->SR1; // clear SB + I2C1->DR = addr7w; // set address + I2C_WAIT(I2C1->SR1 & I2C_SR1_ADDR); // wait for ADDR flag (timeout @ NACK) + DBG("ADDR\n"); + if(I2C1->SR1 & I2C_SR1_AF){ // NACK + return I2C_NACK; + } + DBG("ACK\n"); + (void) I2C1->SR2; // clear ADDR + ret = I2C_OK; +eotr: + return ret; +} + +/** + * send one byte in 7bit address mode + * @param data - data to write + * @param stop - ==1 to send stop event + * @return status + */ +i2c_status i2c_7bit_send_onebyte(uint8_t data, uint8_t stop){ + i2c_status ret = i2c_7bit_startw(); + if(ret != I2C_OK){ + I2C1->CR1 |= I2C_CR1_STOP; + goto eotr; + } + I2C1->DR = data; // init data send register + DBG("TxE\n"); + I2C_WAIT(I2C1->SR1 & I2C_SR1_TXE); // wait for TxE (timeout when NACK) + ret = I2C_OK; + DBG("OK\n"); + if(stop){ + I2C_WAIT(I2C1->SR1 & I2C_SR1_BTF); // wait for BTF + DBG("BTF\n"); + } +eotr: + if(stop){ + I2C1->CR1 |= I2C_CR1_STOP; // generate stop event + } + return ret; +} + +// send data array +i2c_status i2c_7bit_send(const uint8_t *data, int datalen){ + i2c_status ret = i2c_7bit_startw(); + if(ret != I2C_OK){ + I2C1->CR1 |= I2C_CR1_STOP; + goto eotr; + } + for(int i = 0; i < datalen; ++i){ + I2C1->DR = data[i]; + I2C_WAIT(I2C1->SR1 & I2C_SR1_TXE); + } + ret = I2C_OK; + I2C_WAIT(I2C1->SR1 & I2C_SR1_BTF); +eotr: + I2C1->CR1 |= I2C_CR1_STOP; + return ret; +} + +i2c_status i2c_7bit_receive_onebyte(uint8_t *data, uint8_t stop){ + i2c_status ret = I2C_LINEBUSY; + //I2C_LINEWAIT(); + I2C1->CR1 |= I2C_CR1_START; // generate start sequence + I2C_WAIT(I2C1->SR1 & I2C_SR1_SB); // wait for SB + DBG("Rx SB\n"); + (void) I2C1->SR1; // clear SB + I2C1->DR = addr7r; // set address + DBG("Rx addr\n"); + I2C_WAIT(I2C1->SR1 & I2C_SR1_ADDR); // wait for ADDR flag + DBG("Rx ack\n"); + I2C1->CR1 &= ~I2C_CR1_ACK; // clear ACK + if(I2C1->SR1 & I2C_SR1_AF){ // NACK + DBG("Rx nak\n"); + ret = I2C_NACK; + goto eotr; + } + (void) I2C1->SR2; // clear ADDR + DBG("Rx stop\n"); + if(stop) I2C1->CR1 |= I2C_CR1_STOP; // program STOP + I2C_WAIT(I2C1->SR1 & I2C_SR1_RXNE); // wait for RxNE + DBG("Rx OK\n"); + *data = I2C1->DR; // read data & clear RxNE + ret = I2C_OK; +eotr: + return ret; +} + +i2c_status i2c_7bit_receive_twobytes(uint8_t *data){ + i2c_status ret = I2C_LINEBUSY; + //I2C_LINEWAIT(); + I2C1->CR1 |= I2C_CR1_START | I2C_CR1_POS | I2C_CR1_ACK; // generate start sequence, set pos & ack + I2C_WAIT(I2C1->SR1 & I2C_SR1_SB); // wait for SB + DBG("2 Rx sb\n"); + (void) I2C1->SR1; // clear SB + I2C1->DR = addr7r; // set address + I2C_WAIT(I2C1->SR1 & I2C_SR1_ADDR); // wait for ADDR flag + DBG("2 ADDR\n"); + if(I2C1->SR1 & I2C_SR1_AF){ // NACK + ret = I2C_NACK; + goto eotr; + } + DBG("2 ACK\n"); + (void) I2C1->SR2; // clear ADDR + I2C1->CR1 &= ~I2C_CR1_ACK; // clear ACK + I2C_WAIT(I2C1->SR1 & I2C_SR1_BTF); // wait for BTF + DBG("2 BTF\n"); + I2C1->CR1 |= I2C_CR1_STOP; // program STOP + *data++ = I2C1->DR; *data = I2C1->DR; // read data & clear RxNE + ret = I2C_OK; +eotr: + return ret; +} + +// receive any amount of bytes +i2c_status i2c_7bit_receive(uint8_t *data, uint16_t nbytes){ + if(nbytes == 0) return I2C_HWPROBLEM; + I2C1->SR1 = 0; // clear previous NACK flag & other error flags + if(nbytes == 1) return i2c_7bit_receive_onebyte(data, 1); + else if(nbytes == 2) return i2c_7bit_receive_twobytes(data); + i2c_status ret = I2C_LINEBUSY; + //I2C_LINEWAIT(); + I2C1->CR1 |= I2C_CR1_START | I2C_CR1_ACK; // generate start sequence, set pos & ack + I2C_WAIT(I2C1->SR1 & I2C_SR1_SB); // wait for SB + DBG("got SB\n"); + (void) I2C1->SR1; // clear SB + I2C1->DR = addr7r; // set address + I2C_WAIT(I2C1->SR1 & I2C_SR1_ADDR); // wait for ADDR flag + DBG("send addr\n"); + if(I2C1->SR1 & I2C_SR1_AF){ // NACK + DBG("NACKed\n"); + ret = I2C_NACK; + goto eotr; + } + DBG("ACKed\n"); + (void) I2C1->SR2; // clear ADDR + for(uint16_t x = nbytes - 3; x > 0; --x){ + I2C_WAIT(I2C1->SR1 & I2C_SR1_RXNE); // wait next byte + *data++ = I2C1->DR; // get data + } + DBG("three left\n"); + // three bytes remain to be read + I2C_WAIT(I2C1->SR1 & I2C_SR1_RXNE); // wait dataN-2 + DBG("dataN-2\n"); + I2C_WAIT(I2C1->SR1 & I2C_SR1_BTF); // wait for BTF + DBG("BTF\n"); + I2C1->CR1 &= ~I2C_CR1_ACK; // clear ACK + *data++ = I2C1->DR; // read dataN-2 + I2C1->CR1 |= I2C_CR1_STOP; // program STOP + *data++ = I2C1->DR; // read dataN-1 + I2C_WAIT(I2C1->SR1 & I2C_SR1_RXNE); // wait next byte + *data = I2C1->DR; // read dataN + DBG("got it\n"); + ret = I2C_OK; +eotr: + return ret; +} diff --git a/F1-nolib/BMP180/i2c.h b/F1-nolib/BMP180/i2c.h new file mode 100644 index 0000000..8cdb85e --- /dev/null +++ b/F1-nolib/BMP180/i2c.h @@ -0,0 +1,41 @@ +/* + * This file is part of the BMP180 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 I2C_H__ + +#include + +typedef enum{ + I2C_OK = 0, + I2C_LINEBUSY, + I2C_TMOUT, + I2C_NOADDR, + I2C_NACK, + I2C_HWPROBLEM, +} i2c_status; + +void i2c_setup(); +void i2c_set_addr7(uint8_t addr); +i2c_status i2c_7bit_send_onebyte(uint8_t data, uint8_t stop); +i2c_status i2c_7bit_send(const uint8_t *data, int datalen); +i2c_status i2c_7bit_receive_onebyte(uint8_t *data, uint8_t stop); +i2c_status i2c_7bit_receive_twobytes(uint8_t *data); +i2c_status i2c_7bit_receive(uint8_t *data, uint16_t nbytes); + +#define I2C_H__ +#endif // I2C_H__ diff --git a/F1-nolib/BMP180/main.c b/F1-nolib/BMP180/main.c new file mode 100644 index 0000000..e9cd46b --- /dev/null +++ b/F1-nolib/BMP180/main.c @@ -0,0 +1,105 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 "BMP180.h" +#include "hardware.h" +#include "proto.h" +#include "usb.h" +#include "usb_lib.h" + +#define USBBUFSZ 127 + +volatile uint32_t Tms = 0; + +/* Called when systick fires */ +void sys_tick_handler(void){ + ++Tms; +} + +// usb getline +static char *get_USB(){ + static char tmpbuf[USBBUFSZ+1], *curptr = tmpbuf; + static int rest = USBBUFSZ; + int x = USB_receive(curptr); + curptr[x] = 0; + if(!x) return NULL; + if(curptr[x-1] == '\n'){ + curptr = tmpbuf; + rest = USBBUFSZ; + return tmpbuf; + } + curptr += x; rest -= x; + if(rest <= 0){ // buffer overflow + curptr = tmpbuf; + rest = USBBUFSZ; + USB_send("USB buffer overflow\n"); + } + return NULL; +} + +int main(void){ + uint32_t lastT = 0; + sysreset(); + StartHSE(); + hw_setup(); + SysTick_Config(72000); + + RCC->CSR |= RCC_CSR_RMVF; // remove reset flags + + USBPU_OFF(); + USB_setup(); + BMP180_init(); + iwdg_setup(); + USBPU_ON(); + + while (1){ + IWDG->KR = IWDG_REFRESH; // refresh watchdog + if(lastT > Tms || Tms - lastT > 499){ + LED_blink(LED0); + lastT = Tms; + } + usb_proc(); + BMP180_process(Tms); + BMP180_status s = BMP180_get_status(); + if(s == BMP180_RDY){ // data ready - get it + int32_t T; + uint32_t P; + BMP180_getdata(&T, &P); + USB_send("T="); USB_send(i2str(T)); USB_send(" (/10degC)\nP="); + USB_send(u2str(P)); USB_send(" (Pa) or "); + float mm = P*0.0750062; + USB_send(u2str(mm)); USB_send(" (/10mmHg)\n"); + }else if(s == BMP180_ERR){ + USB_send("Error in measurement\n"); + BMP180_reset(); + BMP180_init(); + } + + char *txt, *ans; + if((txt = get_USB())){ + IWDG->KR = IWDG_REFRESH; + ans = (char*)parse_cmd(txt); + if(ans){ + uint16_t l = 0; char *p = ans; + while(*p++) l++; + USB_send(ans); + } + } + } + return 0; +} diff --git a/F1-nolib/BMP180/proto.c b/F1-nolib/BMP180/proto.c new file mode 100644 index 0000000..c020e64 --- /dev/null +++ b/F1-nolib/BMP180/proto.c @@ -0,0 +1,242 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 "BMP180.h" +#include "proto.h" +#include "usb.h" + +extern volatile uint32_t Tms; + +char *omit_spaces(const char *buf){ + while(*buf){ + if(*buf > ' ') break; + ++buf; + } + return (char*)buf; +} + +// In case of overflow return `buf` and N==0xffffffff +// read decimal number & return pointer to next non-number symbol +static char *getdec(const char *buf, uint32_t *N){ + char *start = (char*)buf; + uint32_t num = 0; + while(*buf){ + char c = *buf; + if(c < '0' || c > '9'){ + break; + } + if(num > 429496729 || (num == 429496729 && c > '5')){ // overflow + *N = 0xffffff; + return start; + } + num *= 10; + num += c - '0'; + ++buf; + } + *N = num; + return (char*)buf; +} +// read hexadecimal number (without 0x prefix!) +static char *gethex(const char *buf, uint32_t *N){ + char *start = (char*)buf; + uint32_t num = 0; + while(*buf){ + char c = *buf; + uint8_t M = 0; + if(c >= '0' && c <= '9'){ + M = '0'; + }else if(c >= 'A' && c <= 'F'){ + M = 'A' - 10; + }else if(c >= 'a' && c <= 'f'){ + M = 'a' - 10; + } + if(M){ + if(num & 0xf0000000){ // overflow + *N = 0xffffff; + return start; + } + num <<= 4; + num += c - M; + }else{ + break; + } + ++buf; + } + *N = num; + return (char*)buf; +} +// read octal number (without 0 prefix!) +static char *getoct(const char *buf, uint32_t *N){ + char *start = (char*)buf; + uint32_t num = 0; + while(*buf){ + char c = *buf; + if(c < '0' || c > '7'){ + break; + } + if(num & 0xe0000000){ // overflow + *N = 0xffffff; + return start; + } + num <<= 3; + num += c - '0'; + ++buf; + } + *N = num; + return (char*)buf; +} +// read binary number (without b prefix!) +static char *getbin(const char *buf, uint32_t *N){ + char *start = (char*)buf; + uint32_t num = 0; + while(*buf){ + char c = *buf; + if(c < '0' || c > '1'){ + break; + } + if(num & 0x80000000){ // overflow + *N = 0xffffff; + return start; + } + num <<= 1; + if(c == '1') num |= 1; + ++buf; + } + *N = num; + return (char*)buf; +} + +/** + * @brief getnum - read uint32_t from string (dec, hex or bin: 127, 0x7f, 0b1111111) + * @param buf - buffer with number and so on + * @param N - the number read + * @return pointer to first non-number symbol in buf + * (if it is == buf, there's no number or if *N==0xffffffff there was overflow) + */ +char *getnum(const char *txt, uint32_t *N){ + char *nxt = NULL; + char *s = omit_spaces(txt); + if(*s == '0'){ // hex, oct or 0 + if(s[1] == 'x' || s[1] == 'X'){ // hex + nxt = gethex(s+2, N); + if(nxt == s+2) nxt = (char*)txt; + }else if(s[1] > '0'-1 && s[1] < '8'){ // oct + nxt = getoct(s+1, N); + if(nxt == s+1) nxt = (char*)txt; + }else{ // 0 + nxt = s+1; + *N = 0; + } + }else if(*s == 'b' || *s == 'B'){ + nxt = getbin(s+1, N); + if(nxt == s+1) nxt = (char*)txt; + }else{ + nxt = getdec(s, N); + if(nxt == s) nxt = (char*)txt; + } + return nxt; +} + +const char* helpmsg = + "'0' - reset BMP180\n" + "'1' - init BMP180\n" + "'I' - read chip ID (after init)\n" + "'M' - start measurements\n" + "'Ox' - set oversampling of p to x(0..3)\n" + "'R' - software reset\n" + "'W' - test watchdog\n" +; + +const char *parse_cmd(const char *buf){ + uint8_t u; + if(buf[1] == '\n'){ // one symbol commands + switch(*buf){ + case '0': + if(BMP180_reset()) return "Reseted\n"; + else return "Error in reset\n"; + break; + case '1': + if(!BMP180_init()) return "Error in init process\n"; + return "OK, inited\n"; + break; + case 'I': + BMP180_read_ID(&u); + if(u == BMP180_CHIP_ID) return "BMP180\n"; + else return "ID unknown\n"; + break; + case 'M': + if(!BMP180_start(Tms)) return "BMP180 not found or not inited\n"; + else return "Start\n"; + break; + case 'R': + USB_send("Soft reset\n"); + NVIC_SystemReset(); + break; + case 'W': + USB_send("Wait for reboot\n"); + while(1){nop();}; + break; + default: + return helpmsg; + } + return NULL; + } + uint32_t Num = 0; + switch(*buf){ // long messages + case 'O': + ++buf; + if(buf != getnum(buf, &Num) && Num < BMP180_OVERSMAX){ + BMP180_setOS(Num); + return "Changed\n"; + }else return "Wrong OS number"; + break; + default: + return buf; + } + return NULL; +} + +static char *_2str(uint32_t val, uint8_t minus){ + static char strbuf[12]; + char *bufptr = &strbuf[11]; + *bufptr = 0; + if(!val){ + *(--bufptr) = '0'; + }else{ + while(val){ + *(--bufptr) = val % 10 + '0'; + val /= 10; + } + } + if(minus) *(--bufptr) = '-'; + return bufptr; +} + +// return string with number `val` +char *u2str(uint32_t val){ + return _2str(val, 0); +} +char *i2str(int32_t i){ + uint8_t minus = 0; + uint32_t val; + if(i < 0){ + minus = 1; + val = -i; + }else val = i; + return _2str(val, minus); +} diff --git a/F1-nolib/BMP180/proto.h b/F1-nolib/BMP180/proto.h new file mode 100644 index 0000000..b86934e --- /dev/null +++ b/F1-nolib/BMP180/proto.h @@ -0,0 +1,30 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 PROTO_H__ +#define PROTO_H__ + +#include + +const char *parse_cmd(const char *buf); +char *omit_spaces(const char *buf); +char *getnum(const char *buf, uint32_t *N); +char *u2str(uint32_t val); +char *i2str(int32_t val); + +#endif // PROTO_H__ diff --git a/F1-nolib/BMP180/usb.c b/F1-nolib/BMP180/usb.c new file mode 100644 index 0000000..0659dbd --- /dev/null +++ b/F1-nolib/BMP180/usb.c @@ -0,0 +1,167 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 "usb.h" +#include "usb_lib.h" + +static volatile uint8_t tx_succesfull = 1; +static volatile uint8_t rxNE = 0; + +static int sstrlen(const char *s){ + if(!s) return 0; + int l = 0; + while(*s++) ++l; + return l; +} + +// interrupt IN handler (never used?) +static void EP1_Handler(){ + uint16_t epstatus = KEEP_DTOG(USB->EPnR[1]); + if(RX_FLAG(epstatus)) epstatus = (epstatus & ~USB_EPnR_STAT_TX) ^ USB_EPnR_STAT_RX; // set valid RX + else epstatus = epstatus & ~(USB_EPnR_STAT_TX|USB_EPnR_STAT_RX); + // clear CTR + epstatus = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX)); + USB->EPnR[1] = epstatus; +} + +// data IN/OUT handlers +static void transmit_Handler(){ // EP3IN + tx_succesfull = 1; + uint16_t epstatus = KEEP_DTOG_STAT(USB->EPnR[3]); + // clear CTR keep DTOGs & STATs + USB->EPnR[3] = (epstatus & ~(USB_EPnR_CTR_TX)); // clear TX ctr +} + +static void receive_Handler(){ // EP2OUT + rxNE = 1; + uint16_t epstatus = KEEP_DTOG_STAT(USB->EPnR[2]); + USB->EPnR[2] = (epstatus & ~(USB_EPnR_CTR_RX)); // clear RX ctr +} + +void USB_setup(){ + NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn); + NVIC_DisableIRQ(USB_HP_CAN1_TX_IRQn); + RCC->APB1ENR |= RCC_APB1ENR_USBEN; + USB->CNTR = USB_CNTR_FRES; // Force USB Reset + for(uint32_t ctr = 0; ctr < 72000; ++ctr) nop(); // wait >1ms + //uint32_t ctr = 0; + USB->CNTR = 0; + USB->BTABLE = 0; + USB->DADDR = 0; + USB->ISTR = 0; + USB->CNTR = USB_CNTR_RESETM | USB_CNTR_WKUPM; // allow only wakeup & reset interrupts + NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn); +} + +static int usbwr(const char *buf, int l){ + uint32_t ctra = 1000000; + while(--ctra && tx_succesfull == 0){ + IWDG->KR = IWDG_REFRESH; + } + tx_succesfull = 0; + EP_Write(3, (uint8_t*)buf, l); + ctra = 1000000; + while(--ctra && tx_succesfull == 0){ + IWDG->KR = IWDG_REFRESH; + } + if(tx_succesfull == 0){usbON = 0; return 1;} // usb is OFF? + return 0; +} + +static char usbbuff[USB_TXBUFSZ-1]; // temporary buffer (63 - to prevent need of ZLP) +static int buflen = 0; // amount of symbols in usbbuff + +// send next up to 63 bytes of data in usbbuff +static void send_next(){ + if(!buflen || !tx_succesfull) return; + tx_succesfull = 0; + EP_Write(3, (uint8_t*)usbbuff, buflen); + buflen = 0; +} + +// unblocking sending - just fill a buffer +void USB_send(const char *buf){ + int len = sstrlen(buf); + if(!usbON || !len) return; + if(len > USB_TXBUFSZ-1 - buflen){ + usbwr(usbbuff, buflen); + buflen = 0; + } + if(len > USB_TXBUFSZ-1){ + USB_send_blk(buf, len); + return; + } + while(len--) usbbuff[buflen++] = *buf++; +} + +// blocking sending +void USB_send_blk(const char *buf, int len){ + if(!usbON || !len) return; // USB disconnected + if(buflen){ + usbwr(usbbuff, buflen); + buflen = 0; + } + int needzlp = 0; + while(len){ + if(len == USB_TXBUFSZ) needzlp = 1; + int s = (len > USB_TXBUFSZ) ? USB_TXBUFSZ : len; + if(usbwr(buf, s)) return; + len -= s; + buf += s; + } + if(needzlp){ + usbwr(NULL, 0); + } +} + +void usb_proc(){ + switch(USB_Dev.USB_Status){ + case USB_STATE_CONFIGURED: + // make new BULK endpoint + // Buffer have 1024 bytes, but last 256 we use for CAN bus (30.2 of RM: USB main features) + EP_Init(1, EP_TYPE_INTERRUPT, USB_EP1BUFSZ, 0, EP1_Handler); // IN1 - transmit + EP_Init(2, EP_TYPE_BULK, 0, USB_RXBUFSZ, receive_Handler); // OUT2 - receive data + EP_Init(3, EP_TYPE_BULK, USB_TXBUFSZ, 0, transmit_Handler); // IN3 - transmit data + USB_Dev.USB_Status = USB_STATE_CONNECTED; + break; + case USB_STATE_DEFAULT: + case USB_STATE_ADDRESSED: + if(usbON){ + usbON = 0; + } + break; + default: // USB_STATE_CONNECTED - send next data portion + if(!usbON) return; + send_next(); + } +} + +/** + * @brief USB_receive + * @param buf (i) - buffer[64] for received data + * @return amount of received bytes + */ +int USB_receive(char *buf){ + if(!usbON || !rxNE) return 0; + int sz = EP_Read(2, (uint16_t*)buf); + uint16_t epstatus = KEEP_DTOG(USB->EPnR[2]); + // keep stat_tx & set ACK rx + USB->EPnR[2] = (epstatus & ~(USB_EPnR_STAT_TX)) ^ USB_EPnR_STAT_RX; + rxNE = 0; + return sz; +} diff --git a/F1-nolib/BMP180/usb.h b/F1-nolib/BMP180/usb.h new file mode 100644 index 0000000..a1eb61a --- /dev/null +++ b/F1-nolib/BMP180/usb.h @@ -0,0 +1,33 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 __USB_H__ +#define __USB_H__ + +#include "hardware.h" + +#define BUFFSIZE (64) + +void USB_setup(); +void usb_proc(); +void USB_send(const char *buf); +void USB_send_blk(const char *buf, int len); +int USB_receive(char *buf); + +#endif // __USB_H__ diff --git a/F1-nolib/BMP180/usb_defs.h b/F1-nolib/BMP180/usb_defs.h new file mode 100644 index 0000000..5ba0367 --- /dev/null +++ b/F1-nolib/BMP180/usb_defs.h @@ -0,0 +1,102 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 __USB_DEFS_H__ +#define __USB_DEFS_H__ + +#include + +// max endpoints number +#define STM32ENDPOINTS 8 +/** + * Buffers size definition + **/ +#define USB_BTABLE_SIZE 512 +// first 64 bytes of USB_BTABLE are registers! +//#define USB_EP0_BASEADDR 64 +// for USB FS EP0 buffers are from 8 to 64 bytes long (64 for PL2303) +#define USB_EP0_BUFSZ 64 +// USB transmit buffer size (64 for PL2303) +#define USB_TXBUFSZ 64 +// USB receive buffer size (64 for PL2303) +#define USB_RXBUFSZ 64 +// EP1 - interrupt - buffer size +#define USB_EP1BUFSZ 8 + +#define USB_BTABLE_BASE 0x40006000 +#define USB_BASE ((uint32_t)0x40005C00) +#define USB ((USB_TypeDef *) USB_BASE) + +#ifdef USB_BTABLE +#undef USB_BTABLE +#endif +#define USB_BTABLE ((USB_BtableDef *)(USB_BTABLE_BASE)) +#define USB_ISTR_EPID 0x0000000F +#define USB_FNR_LSOF_0 0x00000800 +#define USB_FNR_lSOF_1 0x00001000 +#define USB_LPMCSR_BESL_0 0x00000010 +#define USB_LPMCSR_BESL_1 0x00000020 +#define USB_LPMCSR_BESL_2 0x00000040 +#define USB_LPMCSR_BESL_3 0x00000080 +#define USB_EPnR_CTR_RX 0x00008000 +#define USB_EPnR_DTOG_RX 0x00004000 +#define USB_EPnR_STAT_RX 0x00003000 +#define USB_EPnR_STAT_RX_0 0x00001000 +#define USB_EPnR_STAT_RX_1 0x00002000 +#define USB_EPnR_SETUP 0x00000800 +#define USB_EPnR_EP_TYPE 0x00000600 +#define USB_EPnR_EP_TYPE_0 0x00000200 +#define USB_EPnR_EP_TYPE_1 0x00000400 +#define USB_EPnR_EP_KIND 0x00000100 +#define USB_EPnR_CTR_TX 0x00000080 +#define USB_EPnR_DTOG_TX 0x00000040 +#define USB_EPnR_STAT_TX 0x00000030 +#define USB_EPnR_STAT_TX_0 0x00000010 +#define USB_EPnR_STAT_TX_1 0x00000020 +#define USB_EPnR_EA 0x0000000F +#define USB_COUNTn_RX_BLSIZE 0x00008000 +#define USB_COUNTn_NUM_BLOCK 0x00007C00 +#define USB_COUNTn_RX 0x0000003F + +#ifdef USB_TypeDef +#define USB_TypeDef USB_TypeDef_custom +#endif + +typedef struct { + __IO uint32_t EPnR[STM32ENDPOINTS]; + __IO uint32_t RESERVED[STM32ENDPOINTS]; + __IO uint32_t CNTR; + __IO uint32_t ISTR; + __IO uint32_t FNR; + __IO uint32_t DADDR; + __IO uint32_t BTABLE; +} USB_TypeDef; + +typedef struct{ + __IO uint32_t USB_ADDR_TX; + __IO uint32_t USB_COUNT_TX; + __IO uint32_t USB_ADDR_RX; + __IO uint32_t USB_COUNT_RX; +} USB_EPDATA_TypeDef; + +typedef struct{ + __IO USB_EPDATA_TypeDef EP[STM32ENDPOINTS]; +} USB_BtableDef; + +#endif // __USB_DEFS_H__ diff --git a/F1-nolib/BMP180/usb_lib.c b/F1-nolib/BMP180/usb_lib.c new file mode 100644 index 0000000..f3293a1 --- /dev/null +++ b/F1-nolib/BMP180/usb_lib.c @@ -0,0 +1,476 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 +#include "usb_lib.h" + +ep_t endpoints[STM32ENDPOINTS]; + +usb_dev_t USB_Dev; +static usb_LineCoding lineCoding = {115200, 0, 0, 8}; +static config_pack_t setup_packet; +static uint8_t ep0databuf[EP0DATABUF_SIZE]; +static uint8_t ep0dbuflen = 0; + +usb_LineCoding getLineCoding(){return lineCoding;} + +uint8_t usbON = 0; // device disconnected from terminal + +// definition of parts common for USB_DeviceDescriptor & USB_DeviceQualifierDescriptor +#define bcdUSB_L 0x10 +#define bcdUSB_H 0x01 +#define bDeviceClass 0 +#define bDeviceSubClass 0 +#define bDeviceProtocol 0 +#define bNumConfigurations 1 + +static const uint8_t USB_DeviceDescriptor[] = { + 18, // bLength + 0x01, // bDescriptorType - Device descriptor + bcdUSB_L, // bcdUSB_L - 1.10 + bcdUSB_H, // bcdUSB_H + bDeviceClass, // bDeviceClass - USB_COMM + bDeviceSubClass, // bDeviceSubClass + bDeviceProtocol, // bDeviceProtocol + USB_EP0_BUFSZ, // bMaxPacketSize + 0x7b, // idVendor_L PL2303: VID=0x067b, PID=0x2303 + 0x06, // idVendor_H + 0x03, // idProduct_L + 0x23, // idProduct_H + 0x00, // bcdDevice_Ver_L + 0x03, // bcdDevice_Ver_H + 0x01, // iManufacturer + 0x02, // iProduct + 0x00, // iSerialNumber + bNumConfigurations // bNumConfigurations +}; + +static const uint8_t USB_DeviceQualifierDescriptor[] = { + 10, //bLength + 0x06, // bDescriptorType - Device qualifier + bcdUSB_L, // bcdUSB_L + bcdUSB_H, // bcdUSB_H + bDeviceClass, // bDeviceClass + bDeviceSubClass, // bDeviceSubClass + bDeviceProtocol, // bDeviceProtocol + USB_EP0_BUFSZ, // bMaxPacketSize0 + bNumConfigurations, // bNumConfigurations + 0x00 // Reserved +}; + +static const uint8_t USB_ConfigDescriptor[] = { + /*Configuration Descriptor*/ + 0x09, /* bLength: Configuration Descriptor size */ + 0x02, /* bDescriptorType: Configuration */ + 39, /* wTotalLength:no of returned bytes */ + 0x00, + 0x01, /* bNumInterfaces: 1 interface */ + 0x01, /* bConfigurationValue: Configuration value */ + 0x00, /* iConfiguration: Index of string descriptor describing the configuration */ + 0xa0, /* bmAttributes - Bus powered, Remote wakeup */ + 0x32, /* MaxPower 100 mA */ + + /*---------------------------------------------------------------------------*/ + + /*Interface Descriptor */ + 0x09, /* bLength: Interface Descriptor size */ + 0x04, /* bDescriptorType: Interface */ + 0x00, /* bInterfaceNumber: Number of Interface */ + 0x00, /* bAlternateSetting: Alternate setting */ + 0x03, /* bNumEndpoints: 3 endpoints used */ + 0xff, /* bInterfaceClass */ + 0x00, /* bInterfaceSubClass */ + 0x00, /* bInterfaceProtocol */ + 0x00, /* iInterface: */ +/////////////////////////////////////////////////// + /*Endpoint 1 Descriptor*/ + 0x07, /* bLength: Endpoint Descriptor size */ + 0x05, /* bDescriptorType: Endpoint */ + 0x81, /* bEndpointAddress IN1 */ + 0x03, /* bmAttributes: Interrupt */ + 0x0a, /* wMaxPacketSize LO: */ + 0x00, /* wMaxPacketSize HI: */ + 0x01, /* bInterval: */ + + /*Endpoint OUT2 Descriptor*/ + 0x07, /* bLength: Endpoint Descriptor size */ + 0x05, /* bDescriptorType: Endpoint */ + 0x02, /* bEndpointAddress: OUT2 */ + 0x02, /* bmAttributes: Bulk */ + (USB_RXBUFSZ & 0xff), /* wMaxPacketSize: 64 */ + (USB_RXBUFSZ >> 8), + 0x00, /* bInterval: ignore for Bulk transfer */ + + /*Endpoint IN3 Descriptor*/ + 0x07, /* bLength: Endpoint Descriptor size */ + 0x05, /* bDescriptorType: Endpoint */ + 0x83, /* bEndpointAddress IN3 */ + 0x02, /* bmAttributes: Bulk */ + (USB_TXBUFSZ & 0xff), /* wMaxPacketSize: 64 */ + (USB_TXBUFSZ >> 8), + 0x00, /* bInterval: ignore for Bulk transfer */ +}; + +_USB_LANG_ID_(USB_StringLangDescriptor, LANG_US); +// these descriptors are not used in PL2303 emulator! +_USB_STRING_(USB_StringSerialDescriptor, u"0"); +_USB_STRING_(USB_StringManufacturingDescriptor, u"Prolific Technology Inc."); +_USB_STRING_(USB_StringProdDescriptor, u"USB-Serial Controller"); + +/* + * default handlers + */ +// SET_LINE_CODING +void WEAK linecoding_handler(usb_LineCoding __attribute__((unused)) *lc){ +} + +// SET_CONTROL_LINE_STATE +void WEAK clstate_handler(uint16_t __attribute__((unused)) val){ +} + +// SEND_BREAK +void WEAK break_handler(){ +} + +// handler of vendor requests +void WEAK vendor_handler(config_pack_t *packet){ + if(packet->bmRequestType & 0x80){ // read + uint8_t c; + switch(packet->wValue){ + case 0x8484: + c = 2; + break; + case 0x0080: + c = 1; + break; + case 0x8686: + c = 0xaa; + break; + default: + c = 0; + } + EP_WriteIRQ(0, &c, 1); + }else{ // write ZLP + EP_WriteIRQ(0, (uint8_t *)0, 0); + } +} + +static void wr0(const uint8_t *buf, uint16_t size){ + if(setup_packet.wLength < size) size = setup_packet.wLength; // shortened request + if(size < endpoints[0].txbufsz){ + EP_WriteIRQ(0, buf, size); + return; + } + while(size){ + uint16_t l = size; + if(l > endpoints[0].txbufsz) l = endpoints[0].txbufsz; + EP_WriteIRQ(0, buf, l); + buf += l; + size -= l; + uint8_t needzlp = (l == endpoints[0].txbufsz) ? 1 : 0; + if(size || needzlp){ // send last data buffer + uint16_t status = KEEP_DTOG(USB->EPnR[0]); + // keep DTOGs, clear CTR_RX,TX, set TX VALID, leave stat_Rx + USB->EPnR[0] = (status & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX|USB_EPnR_STAT_RX)) + ^ USB_EPnR_STAT_TX; + uint32_t ctr = 1000000; + while(--ctr && (USB->ISTR & USB_ISTR_CTR) == 0){IWDG->KR = IWDG_REFRESH;}; + if((USB->ISTR & USB_ISTR_CTR) == 0){ + return; + } + if(needzlp) EP_WriteIRQ(0, (uint8_t*)0, 0); + } + } +} + +static inline void get_descriptor(){ + switch(setup_packet.wValue){ + case DEVICE_DESCRIPTOR: + wr0(USB_DeviceDescriptor, sizeof(USB_DeviceDescriptor)); + break; + case CONFIGURATION_DESCRIPTOR: + wr0(USB_ConfigDescriptor, sizeof(USB_ConfigDescriptor)); + break; + case STRING_LANG_DESCRIPTOR: + wr0((const uint8_t *)&USB_StringLangDescriptor, STRING_LANG_DESCRIPTOR_SIZE_BYTE); + break; + case STRING_MAN_DESCRIPTOR: + wr0((const uint8_t *)&USB_StringManufacturingDescriptor, USB_StringManufacturingDescriptor.bLength); + break; + case STRING_PROD_DESCRIPTOR: + wr0((const uint8_t *)&USB_StringProdDescriptor, USB_StringProdDescriptor.bLength); + break; + case STRING_SN_DESCRIPTOR: + wr0((const uint8_t *)&USB_StringSerialDescriptor, USB_StringSerialDescriptor.bLength); + break; + case DEVICE_QUALIFIER_DESCRIPTOR: + wr0(USB_DeviceQualifierDescriptor, USB_DeviceQualifierDescriptor[0]); + break; + default: + break; + } +} + +static uint8_t configuration = 0; // reply for GET_CONFIGURATION (==1 if configured) +static inline void std_d2h_req(){ + uint16_t status = 0; // bus powered + switch(setup_packet.bRequest){ + case GET_DESCRIPTOR: + get_descriptor(); + break; + case GET_STATUS: + EP_WriteIRQ(0, (uint8_t *)&status, 2); // send status: Bus Powered + break; + case GET_CONFIGURATION: + EP_WriteIRQ(0, &configuration, 1); + break; + default: + break; + } +} + +static inline void std_h2d_req(){ + switch(setup_packet.bRequest){ + case SET_ADDRESS: + // new address will be assigned later - after acknowlegement or request to host + USB_Dev.USB_Addr = setup_packet.wValue; + break; + case SET_CONFIGURATION: + // Now device configured + USB_Dev.USB_Status = USB_STATE_CONFIGURED; + configuration = setup_packet.wValue; + break; + default: + break; + } +} + +/* +bmRequestType: 76543210 +7 direction: 0 - host->device, 1 - device->host +65 type: 0 - standard, 1 - class, 2 - vendor +4..0 getter: 0 - device, 1 - interface, 2 - endpoint, 3 - other +*/ +/** + * Endpoint0 (control) handler + */ +static void EP0_Handler(){ + uint16_t epstatus = USB->EPnR[0]; // EP0R on input -> return this value after modifications + uint8_t reqtype = setup_packet.bmRequestType & 0x7f; + uint8_t dev2host = (setup_packet.bmRequestType & 0x80) ? 1 : 0; + int rxflag = RX_FLAG(epstatus); + if(rxflag && SETUP_FLAG(epstatus)){ + switch(reqtype){ + case STANDARD_DEVICE_REQUEST_TYPE: // standard device request + if(dev2host){ + std_d2h_req(); + }else{ + std_h2d_req(); + EP_WriteIRQ(0, (uint8_t *)0, 0); + } + break; + case STANDARD_ENDPOINT_REQUEST_TYPE: // standard endpoint request + if(setup_packet.bRequest == CLEAR_FEATURE){ + EP_WriteIRQ(0, (uint8_t *)0, 0); + } + break; + case VENDOR_REQUEST_TYPE: + vendor_handler(&setup_packet); + break; + case CONTROL_REQUEST_TYPE: + switch(setup_packet.bRequest){ + case GET_LINE_CODING: + EP_WriteIRQ(0, (uint8_t*)&lineCoding, sizeof(lineCoding)); + break; + case SET_LINE_CODING: // omit this for next stage, when data will come + break; + case SET_CONTROL_LINE_STATE: + usbON = 1; + clstate_handler(setup_packet.wValue); + break; + case SEND_BREAK: + usbON = 0; + break_handler(); + break; + default: + break; + } + if(setup_packet.bRequest != GET_LINE_CODING) EP_WriteIRQ(0, (uint8_t *)0, 0); // write acknowledgement + break; + default: + EP_WriteIRQ(0, (uint8_t *)0, 0); + } + }else if(rxflag){ // got data over EP0 or host acknowlegement + if(endpoints[0].rx_cnt){ + if(setup_packet.bRequest == SET_LINE_CODING){ + linecoding_handler((usb_LineCoding*)ep0databuf); + } + } + } else if(TX_FLAG(epstatus)){ // package transmitted + // now we can change address after enumeration + if ((USB->DADDR & USB_DADDR_ADD) != USB_Dev.USB_Addr){ + USB->DADDR = USB_DADDR_EF | USB_Dev.USB_Addr; + // change state to ADRESSED + USB_Dev.USB_Status = USB_STATE_ADDRESSED; + } + } + epstatus = KEEP_DTOG(USB->EPnR[0]); + if(rxflag) epstatus ^= USB_EPnR_STAT_TX; // start ZLP/data transmission + else epstatus &= ~USB_EPnR_STAT_TX; // or leave unchanged + // keep DTOGs, clear CTR_RX,TX, set RX VALID + USB->EPnR[0] = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_RX; +} + +static uint16_t lastaddr = LASTADDR_DEFAULT; +/** + * Endpoint initialisation + * @param number - EP num (0...7) + * @param type - EP type (EP_TYPE_BULK, EP_TYPE_CONTROL, EP_TYPE_ISO, EP_TYPE_INTERRUPT) + * @param txsz - transmission buffer size @ USB/CAN buffer + * @param rxsz - reception buffer size @ USB/CAN buffer + * @param uint16_t (*func)(ep_t *ep) - EP handler function + * @return 0 if all OK + */ +int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)(ep_t ep)){ + if(number >= STM32ENDPOINTS) return 4; // out of configured amount + if(txsz > USB_BTABLE_SIZE || rxsz > USB_BTABLE_SIZE) return 1; // buffer too large + if(lastaddr + txsz + rxsz >= USB_BTABLE_SIZE) return 2; // out of btable + USB->EPnR[number] = (type << 9) | (number & USB_EPnR_EA); + USB->EPnR[number] ^= USB_EPnR_STAT_RX | USB_EPnR_STAT_TX_1; + if(rxsz & 1 || rxsz > 512) return 3; // wrong rx buffer size + uint16_t countrx = 0; + if(rxsz < 64) countrx = rxsz / 2; + else{ + if(rxsz & 0x1f) return 3; // should be multiple of 32 + countrx = 31 + rxsz / 32; + } + USB_BTABLE->EP[number].USB_ADDR_TX = lastaddr; + endpoints[number].tx_buf = (uint16_t *)(USB_BTABLE_BASE + lastaddr*2); + endpoints[number].txbufsz = txsz; + lastaddr += txsz; + USB_BTABLE->EP[number].USB_COUNT_TX = 0; + USB_BTABLE->EP[number].USB_ADDR_RX = lastaddr; + endpoints[number].rx_buf = (uint16_t *)(USB_BTABLE_BASE + lastaddr*2); + lastaddr += rxsz; + USB_BTABLE->EP[number].USB_COUNT_RX = countrx << 10; + endpoints[number].func = func; + return 0; +} + +// standard IRQ handler +void usb_lp_can_rx0_isr(){ + if(USB->ISTR & USB_ISTR_RESET){ + usbON = 0; + // Reinit registers + USB->CNTR = USB_CNTR_RESETM | USB_CNTR_CTRM | USB_CNTR_SUSPM | USB_CNTR_WKUPM; + USB->ISTR = 0; + // Endpoint 0 - CONTROL + // ON USB LS size of EP0 may be 8 bytes, but on FS it should be 64 bytes! + lastaddr = LASTADDR_DEFAULT; + // clear address, leave only enable bit + USB->DADDR = USB_DADDR_EF; + USB_Dev.USB_Status = USB_STATE_DEFAULT; + USB->ISTR = ~USB_ISTR_RESET; + if(EP_Init(0, EP_TYPE_CONTROL, USB_EP0_BUFSZ, USB_EP0_BUFSZ, EP0_Handler)){ + return; + } + } + if(USB->ISTR & USB_ISTR_CTR){ + // EP number + uint8_t n = USB->ISTR & USB_ISTR_EPID; + // copy status register + uint16_t epstatus = USB->EPnR[n]; + // copy received bytes amount + endpoints[n].rx_cnt = USB_BTABLE->EP[n].USB_COUNT_RX & 0x3FF; // low 10 bits is counter + // check direction + if(USB->ISTR & USB_ISTR_DIR){ // OUT interrupt - receive data, CTR_RX==1 (if CTR_TX == 1 - two pending transactions: receive following by transmit) + if(n == 0){ // control endpoint + if(epstatus & USB_EPnR_SETUP){ // setup packet -> copy data to conf_pack + EP_Read(0, (uint16_t*)&setup_packet); + ep0dbuflen = 0; + // interrupt handler will be called later + }else if(epstatus & USB_EPnR_CTR_RX){ // data packet -> push received data to ep0databuf + ep0dbuflen = endpoints[0].rx_cnt; + EP_Read(0, (uint16_t*)&ep0databuf); + } + } + } + // call EP handler + if(endpoints[n].func) endpoints[n].func(endpoints[n]); + } + if(USB->ISTR & USB_ISTR_SUSP){ // suspend -> still no connection, may sleep + usbON = 0; + USB->CNTR |= USB_CNTR_FSUSP | USB_CNTR_LP_MODE; + USB->ISTR = ~USB_ISTR_SUSP; + } + if(USB->ISTR & USB_ISTR_WKUP){ // wakeup + USB->CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LP_MODE); // clear suspend flags + USB->ISTR = ~USB_ISTR_WKUP; + } +} + +/** + * Write data to EP buffer (called from IRQ handler) + * @param number - EP number + * @param *buf - array with data + * @param size - its size + */ +void EP_WriteIRQ(uint8_t number, const uint8_t *buf, uint16_t size){ + uint8_t i; + if(size > endpoints[number].txbufsz) size = endpoints[number].txbufsz; + uint16_t N2 = (size + 1) >> 1; + // the buffer is 16-bit, so we should copy data as it would be uint16_t + uint16_t *buf16 = (uint16_t *)buf; + uint32_t *out = (uint32_t *)endpoints[number].tx_buf; + for(i = 0; i < N2; ++i, ++out){ + *out = buf16[i]; + } + USB_BTABLE->EP[number].USB_COUNT_TX = size; +} + +/** + * Write data to EP buffer (called outside IRQ handler) + * @param number - EP number + * @param *buf - array with data + * @param size - its size + */ +void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size){ + EP_WriteIRQ(number, buf, size); + uint16_t status = KEEP_DTOG(USB->EPnR[number]); + // keep DTOGs, clear CTR_TX & set TX VALID to start transmission + USB->EPnR[number] = (status & ~(USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_TX; +} + +/* + * Copy data from EP buffer into user buffer area + * @param *buf - user array for data + * @return amount of data read + */ +int EP_Read(uint8_t number, uint16_t *buf){ + int sz = endpoints[number].rx_cnt; + if(!sz) return 0; + endpoints[number].rx_cnt = 0; + int n = (sz + 1) >> 1; + uint32_t *in = (uint32_t *)endpoints[number].rx_buf; + if(n){ + for(int i = 0; i < n; ++i, ++in) + buf[i] = *(uint16_t*)in; + } + return sz; +} + diff --git a/F1-nolib/BMP180/usb_lib.h b/F1-nolib/BMP180/usb_lib.h new file mode 100644 index 0000000..6442dbe --- /dev/null +++ b/F1-nolib/BMP180/usb_lib.h @@ -0,0 +1,184 @@ +/* + * This file is part of the BMP180 project. + * Copyright 2020 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 __USB_LIB_H__ +#define __USB_LIB_H__ + +#include +#include "usb_defs.h" + +#define EP0DATABUF_SIZE (64) +#define LASTADDR_DEFAULT (STM32ENDPOINTS * 8) + +// bmRequestType & 0x7f +#define STANDARD_DEVICE_REQUEST_TYPE 0 +#define STANDARD_ENDPOINT_REQUEST_TYPE 2 +#define VENDOR_REQUEST_TYPE 0x40 +#define CONTROL_REQUEST_TYPE 0x21 +// bRequest, standard; for bmRequestType == 0x80 +#define GET_STATUS 0x00 +#define GET_DESCRIPTOR 0x06 +#define GET_CONFIGURATION 0x08 +// for bmRequestType == 0 +#define CLEAR_FEATURE 0x01 +#define SET_FEATURE 0x03 // unused +#define SET_ADDRESS 0x05 +#define SET_DESCRIPTOR 0x07 // unused +#define SET_CONFIGURATION 0x09 +// for bmRequestType == 0x81, 1 or 0xB2 +#define GET_INTERFACE 0x0A // unused +#define SET_INTERFACE 0x0B // unused +#define SYNC_FRAME 0x0C // unused +#define VENDOR_REQUEST 0x01 // unused + +// Class-Specific Control Requests +#define SEND_ENCAPSULATED_COMMAND 0x00 // unused +#define GET_ENCAPSULATED_RESPONSE 0x01 // unused +#define SET_COMM_FEATURE 0x02 // unused +#define GET_COMM_FEATURE 0x03 // unused +#define CLEAR_COMM_FEATURE 0x04 // unused +#define SET_LINE_CODING 0x20 +#define GET_LINE_CODING 0x21 +#define SET_CONTROL_LINE_STATE 0x22 +#define SEND_BREAK 0x23 + +// control line states +#define CONTROL_DTR 0x01 +#define CONTROL_RTS 0x02 + +// wValue +#define DEVICE_DESCRIPTOR 0x100 +#define CONFIGURATION_DESCRIPTOR 0x200 +#define STRING_LANG_DESCRIPTOR 0x300 +#define STRING_MAN_DESCRIPTOR 0x301 +#define STRING_PROD_DESCRIPTOR 0x302 +#define STRING_SN_DESCRIPTOR 0x303 +#define DEVICE_QUALIFIER_DESCRIPTOR 0x600 + +#define RX_FLAG(epstat) (epstat & USB_EPnR_CTR_RX) +#define TX_FLAG(epstat) (epstat & USB_EPnR_CTR_TX) +#define SETUP_FLAG(epstat) (epstat & USB_EPnR_SETUP) + +// EPnR bits manipulation +#define KEEP_DTOG_STAT(EPnR) (EPnR & ~(USB_EPnR_STAT_RX|USB_EPnR_STAT_TX|USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX)) +#define KEEP_DTOG(EPnR) (EPnR & ~(USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX)) + +// USB state: uninitialized, addressed, ready for use +typedef enum{ + USB_STATE_DEFAULT, + USB_STATE_ADDRESSED, + USB_STATE_CONFIGURED, + USB_STATE_CONNECTED +} USB_state; + +// EP types +#define EP_TYPE_BULK 0x00 +#define EP_TYPE_CONTROL 0x01 +#define EP_TYPE_ISO 0x02 +#define EP_TYPE_INTERRUPT 0x03 + +#define LANG_US (uint16_t)0x0409 + +#define _USB_STRING_(name, str) \ +static const struct name \ +{ \ + uint8_t bLength; \ + uint8_t bDescriptorType; \ + uint16_t bString[(sizeof(str) - 2) / 2]; \ + \ +} \ +name = {sizeof(name), 0x03, str} + +#define _USB_LANG_ID_(name, lng_id) \ + \ +static const struct name \ +{ \ + uint8_t bLength; \ + uint8_t bDescriptorType; \ + uint16_t bString; \ + \ +} \ +name = {0x04, 0x03, lng_id} +#define STRING_LANG_DESCRIPTOR_SIZE_BYTE (4) + +// EP0 configuration packet +typedef struct { + uint8_t bmRequestType; + uint8_t bRequest; + uint16_t wValue; + uint16_t wIndex; + uint16_t wLength; +} config_pack_t; + +// endpoints state +typedef struct{ + uint16_t *tx_buf; // transmission buffer address + uint16_t txbufsz; // transmission buffer size + uint16_t *rx_buf; // reception buffer address + void (*func)(); // endpoint action function + unsigned rx_cnt : 10; // received data counter +} ep_t; + +// USB status & its address +typedef struct { + uint8_t USB_Status; + uint16_t USB_Addr; +}usb_dev_t; + +typedef struct { + uint32_t dwDTERate; + uint8_t bCharFormat; + #define USB_CDC_1_STOP_BITS 0 + #define USB_CDC_1_5_STOP_BITS 1 + #define USB_CDC_2_STOP_BITS 2 + uint8_t bParityType; + #define USB_CDC_NO_PARITY 0 + #define USB_CDC_ODD_PARITY 1 + #define USB_CDC_EVEN_PARITY 2 + #define USB_CDC_MARK_PARITY 3 + #define USB_CDC_SPACE_PARITY 4 + uint8_t bDataBits; +} __attribute__ ((packed)) usb_LineCoding; + +typedef struct { + uint8_t bmRequestType; + uint8_t bNotificationType; + uint16_t wValue; + uint16_t wIndex; + uint16_t wLength; +} __attribute__ ((packed)) usb_cdc_notification; + +extern ep_t endpoints[]; +extern usb_dev_t USB_Dev; +extern uint8_t usbON; + +void USB_Init(); +void USB_ResetState(); +int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)()); +void EP_WriteIRQ(uint8_t number, const uint8_t *buf, uint16_t size); +void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size); +int EP_Read(uint8_t number, uint16_t *buf); +usb_LineCoding getLineCoding(); + +void linecoding_handler(usb_LineCoding *lc); +void clstate_handler(uint16_t val); +void break_handler(); +void vendor_handler(config_pack_t *packet); + +#endif // __USB_LIB_H__