From ad5e9d5abf8e231f75d5562280707f54ca409a90 Mon Sep 17 00:00:00 2001 From: Edward Emelianov Date: Tue, 26 Jan 2021 23:12:32 +0300 Subject: [PATCH] rename pwmtest->pwmdmatest, add pwmtest --- F1-nolib/pwmdmatest/Makefile | 139 ++++++++++ F1-nolib/pwmdmatest/Readme | 2 + F1-nolib/pwmdmatest/hardware.c | 69 +++++ F1-nolib/pwmdmatest/hardware.h | 45 +++ F1-nolib/pwmdmatest/main.c | 159 +++++++++++ F1-nolib/pwmdmatest/proto.c | 49 ++++ F1-nolib/pwmdmatest/proto.h | 24 ++ F1-nolib/pwmdmatest/pwmtest.bin | Bin 0 -> 4500 bytes F1-nolib/pwmdmatest/usb.c | 159 +++++++++++ F1-nolib/pwmdmatest/usb.h | 33 +++ F1-nolib/pwmdmatest/usb_defs.h | 102 +++++++ F1-nolib/pwmdmatest/usb_lib.c | 476 ++++++++++++++++++++++++++++++++ F1-nolib/pwmdmatest/usb_lib.h | 184 ++++++++++++ F1-nolib/pwmtest/Readme | 1 - F1-nolib/pwmtest/hardware.c | 74 +++-- F1-nolib/pwmtest/hardware.h | 10 +- F1-nolib/pwmtest/main.c | 81 +----- F1-nolib/pwmtest/proto.c | 89 +++++- F1-nolib/pwmtest/proto.h | 3 + F1-nolib/pwmtest/pwmtest.bin | Bin 4500 -> 6908 bytes F1-nolib/pwmtest/usb.c | 45 ++- F1-nolib/pwmtest/usb.h | 4 +- 22 files changed, 1619 insertions(+), 129 deletions(-) create mode 100644 F1-nolib/pwmdmatest/Makefile create mode 100644 F1-nolib/pwmdmatest/Readme create mode 100644 F1-nolib/pwmdmatest/hardware.c create mode 100644 F1-nolib/pwmdmatest/hardware.h create mode 100644 F1-nolib/pwmdmatest/main.c create mode 100644 F1-nolib/pwmdmatest/proto.c create mode 100644 F1-nolib/pwmdmatest/proto.h create mode 100755 F1-nolib/pwmdmatest/pwmtest.bin create mode 100644 F1-nolib/pwmdmatest/usb.c create mode 100644 F1-nolib/pwmdmatest/usb.h create mode 100644 F1-nolib/pwmdmatest/usb_defs.h create mode 100644 F1-nolib/pwmdmatest/usb_lib.c create mode 100644 F1-nolib/pwmdmatest/usb_lib.h diff --git a/F1-nolib/pwmdmatest/Makefile b/F1-nolib/pwmdmatest/Makefile new file mode 100644 index 0000000..f2df821 --- /dev/null +++ b/F1-nolib/pwmdmatest/Makefile @@ -0,0 +1,139 @@ +BINARY = pwmtest +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/pwmdmatest/Readme b/F1-nolib/pwmdmatest/Readme new file mode 100644 index 0000000..02eaeab --- /dev/null +++ b/F1-nolib/pwmdmatest/Readme @@ -0,0 +1,2 @@ +Generate signals on PA8 by PWM through DMA @ TIM1_CC1. +Example for slow and high speed. High speed example works with 1-meter WS2815 LED strip (60 LEDs). diff --git a/F1-nolib/pwmdmatest/hardware.c b/F1-nolib/pwmdmatest/hardware.c new file mode 100644 index 0000000..b844d67 --- /dev/null +++ b/F1-nolib/pwmdmatest/hardware.c @@ -0,0 +1,69 @@ +/* + * This file is part of the pwmtest 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) | CRH(8, CNF_AFPP | MODE_FAST); +} + +void hw_setup(){ + gpio_setup(); + RCC->APB2ENR |= RCC_APB2ENR_TIM1EN; // enable TIM1 clocking + TIM1->ARR = 8; // 9 ticks till UEV +#ifdef HIGHSPEED + TIM1->PSC = 7; +#else + TIM1->PSC = 6999; +#endif + // PWM mode 1 (active->inactive) + TIM1->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1; + // main output + TIM1->BDTR = TIM_BDTR_MOE; + // main PWM output + TIM1->CCER = TIM_CCER_CC1E; +#ifndef HIGHSPEED + NVIC_EnableIRQ(TIM1_CC_IRQn); +#endif + RCC->AHBENR |= RCC_AHBENR_DMA1EN; // DMA1 clocking + // memsize 8bit, periphsize 16bit, memincr, circular, mem2periph, half & full transfer interrupt + DMA1_Channel5->CCR = DMA_CCR_PSIZE_0 | DMA_CCR_CIRC | DMA_CCR_MINC | DMA_CCR_DIR | DMA_CCR_TCIE | DMA_CCR_HTIE; + DMA1_Channel5->CPAR = (uint32_t)&TIM1->CCR1; + NVIC_EnableIRQ(DMA1_Channel5_IRQn); +} + +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/pwmdmatest/hardware.h b/F1-nolib/pwmdmatest/hardware.h new file mode 100644 index 0000000..6192753 --- /dev/null +++ b/F1-nolib/pwmdmatest/hardware.h @@ -0,0 +1,45 @@ +/* + * This file is part of the pwmtest 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" + +#define HIGHSPEED +#define LEDS_NUM (60) + +// 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/pwmdmatest/main.c b/F1-nolib/pwmdmatest/main.c new file mode 100644 index 0000000..3c3374a --- /dev/null +++ b/F1-nolib/pwmdmatest/main.c @@ -0,0 +1,159 @@ +/* + * This file is part of the pwmtest 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" +#include "proto.h" +#include "usb.h" +#include "usb_lib.h" + +volatile uint32_t Tms = 0; + +/* Called when systick fires */ +void sys_tick_handler(void){ + ++Tms; +} + +// usb getline +char *get_USB(){ + static char tmpbuf[512], *curptr = tmpbuf; + static int rest = 511; + uint8_t x = USB_receive((uint8_t*)curptr); + curptr[x] = 0; + if(!x) return NULL; + if(curptr[x-1] == '\n'){ + curptr = tmpbuf; + rest = 511; + return tmpbuf; + } + curptr += x; rest -= x; + if(rest <= 0){ // buffer overflow + curptr = tmpbuf; + rest = 511; + } + return NULL; +} + +#ifndef HIGHSPEED +void tim1_cc_isr(){ + TIM1->SR = 0; + TIM1->CCR1 = 0; + TIM1->DIER = 0; +} +#endif + +static int chkctr(){ + static int LED_ctr = 0; + if(++LED_ctr > LEDS_NUM){ + TIM1->CR1 |= TIM_CR1_OPM; + // THIS IS A DIRTY HACK! IT WORKS ONLY @ HIGH SPEEDS, WHEN THERE'S NO TIME TO GO INTO IRQ + // On small frequencies comment this line and allow CC1 IRQ +#ifdef HIGHSPEED + TIM1->CCR1 = 0; +#else + TIM1->DIER = TIM_DIER_CC1IE; +#endif + LED_ctr = 0; + return 0; + } + return 1; +} + +#define _1 (6) +#define _0 (3) + +// R -> B (GRB) +static uint8_t dmabuff[] = { + _0,_0,_0,_0,_0,_0,_0,_0, + _0,_0,_0,_0,_0,_0,_0,_0, + _0,_0,_0,_0,_0,_0,_0,_0, + _0,_0,_0,_0,_1,_1,_1,_1, + _0,_0,_0,_0,_0,_0,_0,_0, + _0,_0,_0,_0,_0,_0,_0,_0, +}; + +void dma1_channel5_isr(){ + if(DMA1->ISR & DMA_ISR_TCIF5){ // transfer complete + if(chkctr()){ + for(int i = 28; i < 32; ++i) // invert G in second half + if(dmabuff[i] == _0) dmabuff[i] = _1; + else dmabuff[i] = _0; + } + }else if(DMA1->ISR & DMA_ISR_HTIF5){ // half transfer complete + if(chkctr()){ + for(int i = 20; i < 24; ++i) // invert B in first half + if(dmabuff[i] == _0) dmabuff[i] = _1; + else dmabuff[i] = _0; + } + } + DMA1->IFCR = DMA_IFCR_CGIF5; +} + +static void sendone(){ + static uint8_t ctr = 7; + TIM1->CR1 = 0; // stop + DMA1_Channel5->CCR &= ~DMA_CCR_EN; // disable DMA to reconfigure + // change values of dmabuff: G in first half & R in second + if(--ctr == 1) ctr = 6; // 6..2 + for(int i = 0; i < 8; ++i){ + uint8_t val = (i == ctr) ? _1 : _0; + dmabuff[i] = val; + dmabuff[32+i] = val; + } + TIM1->DIER = TIM_DIER_UDE; // enable DMA requests + DMA1->IFCR = DMA_IFCR_CGIF5; + DMA1_Channel5->CNDTR = 48; + DMA1_Channel5->CMAR = (uint32_t)dmabuff; + DMA1_Channel5->CCR |= DMA_CCR_EN; // start DMA + TIM1->CR1 = TIM_CR1_CEN | TIM_CR1_URS;// | TIM_CR1_DIR; +} + +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(); + iwdg_setup(); + USBPU_ON(); + + while (1){ + IWDG->KR = IWDG_REFRESH; // refresh watchdog + if(lastT > Tms || Tms - lastT > 499){ + LED_blink(LED0); + lastT = Tms; + sendone(); + } + usb_proc(); + 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, l); + } + } + } + return 0; +} diff --git a/F1-nolib/pwmdmatest/proto.c b/F1-nolib/pwmdmatest/proto.c new file mode 100644 index 0000000..671ffce --- /dev/null +++ b/F1-nolib/pwmdmatest/proto.c @@ -0,0 +1,49 @@ +/* + * This file is part of the pwmtest 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 "proto.h" +#include "usb.h" + +#define USND(str) do{USB_send(str, sizeof(str)-1);}while(0) +const char *parse_cmd(const char *buf){ + if(buf[1] != '\n') return buf; + switch(*buf){ + /*case 'p': + pin_toggle(USBPU_port, USBPU_pin); + USND("USB pullup is "); + if(pin_read(USBPU_port, USBPU_pin)) USND("off\n"); + else USND("on\n"); + return NULL; + break;*/ + case 'R': + USND("Soft reset\n"); + NVIC_SystemReset(); + break; + case 'W': + USND("Wait for reboot\n"); + while(1){nop();}; + break; + default: // help + return + "'R' - software reset\n" + "'W' - test watchdog\n" + ; + break; + } + return NULL; +} diff --git a/F1-nolib/pwmdmatest/proto.h b/F1-nolib/pwmdmatest/proto.h new file mode 100644 index 0000000..09642cd --- /dev/null +++ b/F1-nolib/pwmdmatest/proto.h @@ -0,0 +1,24 @@ +/* + * This file is part of the pwmtest 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__ + +const char *parse_cmd(const char *buf); + +#endif // PROTO_H__ diff --git a/F1-nolib/pwmdmatest/pwmtest.bin b/F1-nolib/pwmdmatest/pwmtest.bin new file mode 100755 index 0000000000000000000000000000000000000000..b2a465109e9ee118137d0571a905c0909dd873d8 GIT binary patch literal 4500 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 literal 0 HcmV?d00001 diff --git a/F1-nolib/pwmdmatest/usb.c b/F1-nolib/pwmdmatest/usb.c new file mode 100644 index 0000000..6ec3c06 --- /dev/null +++ b/F1-nolib/pwmdmatest/usb.c @@ -0,0 +1,159 @@ +/* + * This file is part of the pwmtest 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; + +// 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, uint16_t 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 uint8_t 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, uint16_t len){ + 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, uint16_t 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; + uint16_t 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 + */ +uint8_t USB_receive(uint8_t *buf){ + if(!usbON || !rxNE) return 0; + uint8_t 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/pwmdmatest/usb.h b/F1-nolib/pwmdmatest/usb.h new file mode 100644 index 0000000..6249c2c --- /dev/null +++ b/F1-nolib/pwmdmatest/usb.h @@ -0,0 +1,33 @@ +/* + * This file is part of the pwmtest 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, uint16_t len); +void USB_send_blk(const char *buf, uint16_t len); +uint8_t USB_receive(uint8_t *buf); + +#endif // __USB_H__ diff --git a/F1-nolib/pwmdmatest/usb_defs.h b/F1-nolib/pwmdmatest/usb_defs.h new file mode 100644 index 0000000..fc546c1 --- /dev/null +++ b/F1-nolib/pwmdmatest/usb_defs.h @@ -0,0 +1,102 @@ +/* + * This file is part of the pwmtest 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/pwmdmatest/usb_lib.c b/F1-nolib/pwmdmatest/usb_lib.c new file mode 100644 index 0000000..badb4d6 --- /dev/null +++ b/F1-nolib/pwmdmatest/usb_lib.c @@ -0,0 +1,476 @@ +/* + * This file is part of the pwmtest 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/pwmdmatest/usb_lib.h b/F1-nolib/pwmdmatest/usb_lib.h new file mode 100644 index 0000000..306a271 --- /dev/null +++ b/F1-nolib/pwmdmatest/usb_lib.h @@ -0,0 +1,184 @@ +/* + * This file is part of the pwmtest 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__ diff --git a/F1-nolib/pwmtest/Readme b/F1-nolib/pwmtest/Readme index 006140e..fb2e731 100644 --- a/F1-nolib/pwmtest/Readme +++ b/F1-nolib/pwmtest/Readme @@ -1,2 +1 @@ Generate signals on PA8 by PWM @ TIM1_CC1. -Example for slow and high speed. High speed example works with 1-meter WS2815 LED strip (60 LEDs). diff --git a/F1-nolib/pwmtest/hardware.c b/F1-nolib/pwmtest/hardware.c index b844d67..373a4c3 100644 --- a/F1-nolib/pwmtest/hardware.c +++ b/F1-nolib/pwmtest/hardware.c @@ -17,6 +17,11 @@ */ #include "hardware.h" +#include "proto.h" +#include "usb.h" + +static uint32_t PWM_freq = 80000; // 80kHz +static uint32_t PWM_duty = 50; // PWM duty cycle in promille static inline void gpio_setup(){ // Enable clocks to the GPIO subsystems (PB for ADC), turn on AFIO clocking to disable SWD/JTAG @@ -26,33 +31,66 @@ static inline void gpio_setup(){ 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 + // USB pullup (PA15) - pushpull output, PA8 - alternate GPIOA->CRH = CRH(15, CNF_PPOUTPUT|MODE_SLOW) | CRH(8, CNF_AFPP | MODE_FAST); } -void hw_setup(){ - gpio_setup(); +static inline void tim1_setup(){ RCC->APB2ENR |= RCC_APB2ENR_TIM1EN; // enable TIM1 clocking - TIM1->ARR = 8; // 9 ticks till UEV -#ifdef HIGHSPEED - TIM1->PSC = 7; -#else - TIM1->PSC = 6999; -#endif + TIM1->PSC = 8; // 8MHz + TIM1->ARR = 99; // 100 ticks for 80kHz + TIM1->CCR1 = 49; // 50% // PWM mode 1 (active->inactive) - TIM1->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1; + TIM1->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1PE; // main output TIM1->BDTR = TIM_BDTR_MOE; // main PWM output TIM1->CCER = TIM_CCER_CC1E; -#ifndef HIGHSPEED - NVIC_EnableIRQ(TIM1_CC_IRQn); -#endif - RCC->AHBENR |= RCC_AHBENR_DMA1EN; // DMA1 clocking - // memsize 8bit, periphsize 16bit, memincr, circular, mem2periph, half & full transfer interrupt - DMA1_Channel5->CCR = DMA_CCR_PSIZE_0 | DMA_CCR_CIRC | DMA_CCR_MINC | DMA_CCR_DIR | DMA_CCR_TCIE | DMA_CCR_HTIE; - DMA1_Channel5->CPAR = (uint32_t)&TIM1->CCR1; - NVIC_EnableIRQ(DMA1_Channel5_IRQn); + // turn it on + TIM1->CR1 = TIM_CR1_CEN;// | TIM_CR1_ARPE; + TIM1->EGR |= TIM_EGR_UG; // generate update event to refresh all +} + +static void refresh_ccr1(){ + if(PWM_duty == 0){ + TIM1->CCR1 = 0; + return; + } + uint32_t ccr1 = (PWM_duty*(TIM1->ARR+1.))/1000; + USB_send("New CCR1: "); USB_send(u2str(ccr1)); USB_send("\n"); + TIM1->CCR1 = ccr1; +} + +// return 0 if can't change or return 1 +int changePWMfreq(uint32_t freq){ + if(!freq) return 0; // zero frequency + uint32_t ARRPSC = (uint32_t)TIM1FREQ / freq; + // both ARR and PSC have 16 bits + if(ARRPSC < 100) return 0; // frequency too big + // 1hz: ARRPSC=72000000, ARR=1098, PSC=65513; Freq=72000000/1099/65514=1.0000016Hz + // 98kHz: ARRPSC=734, ARR=0, PSC=733; Freq=72000000/1/734=98092Hz + uint32_t PSC = ARRPSC >> 16; + uint32_t ARR = ARRPSC / (PSC+1) - 1; + PWM_freq = TIM1FREQ/(ARR+1.)/(PSC+1.); + TIM1->ARR = ARR; + TIM1->PSC = PSC; + USB_send("New PSC: "); USB_send(u2str(PSC)); + USB_send("\nNew ARR: "); USB_send(u2str(ARR)); USB_send("\n"); + refresh_ccr1(); + return 1; +} + +// change duty; return 0 if wrong, 1 if OK (duty in promille) +int changePWMduty(uint32_t duty){ + if(duty > 1000) return 0; // wrong duty + PWM_duty = duty; + refresh_ccr1(); + return 1; +} + +void hw_setup(){ + gpio_setup(); + tim1_setup(); } void iwdg_setup(){ diff --git a/F1-nolib/pwmtest/hardware.h b/F1-nolib/pwmtest/hardware.h index 6192753..725d55f 100644 --- a/F1-nolib/pwmtest/hardware.h +++ b/F1-nolib/pwmtest/hardware.h @@ -22,8 +22,8 @@ #include "stm32f1.h" -#define HIGHSPEED -#define LEDS_NUM (60) +// frequency of TIM1 clocking +#define TIM1FREQ (72000000) // LED0 - PC13 (bluepill), blinking each second #define LED0_port GPIOC @@ -42,4 +42,10 @@ void hw_setup(); void iwdg_setup(); +#define PWM_ON() do{TIM1->CR1 = TIM_CR1_CEN | TIM_CR1_ARPE;}while(0) +#define PWM_OFF() do{TIM1->CR1 = TIM_CR1_ARPE;}while(0) + +int changePWMfreq(uint32_t freq); +int changePWMduty(uint32_t duty); + #endif // __HARDWARE_H__ diff --git a/F1-nolib/pwmtest/main.c b/F1-nolib/pwmtest/main.c index 3c3374a..1d4357e 100644 --- a/F1-nolib/pwmtest/main.c +++ b/F1-nolib/pwmtest/main.c @@ -48,80 +48,6 @@ char *get_USB(){ return NULL; } -#ifndef HIGHSPEED -void tim1_cc_isr(){ - TIM1->SR = 0; - TIM1->CCR1 = 0; - TIM1->DIER = 0; -} -#endif - -static int chkctr(){ - static int LED_ctr = 0; - if(++LED_ctr > LEDS_NUM){ - TIM1->CR1 |= TIM_CR1_OPM; - // THIS IS A DIRTY HACK! IT WORKS ONLY @ HIGH SPEEDS, WHEN THERE'S NO TIME TO GO INTO IRQ - // On small frequencies comment this line and allow CC1 IRQ -#ifdef HIGHSPEED - TIM1->CCR1 = 0; -#else - TIM1->DIER = TIM_DIER_CC1IE; -#endif - LED_ctr = 0; - return 0; - } - return 1; -} - -#define _1 (6) -#define _0 (3) - -// R -> B (GRB) -static uint8_t dmabuff[] = { - _0,_0,_0,_0,_0,_0,_0,_0, - _0,_0,_0,_0,_0,_0,_0,_0, - _0,_0,_0,_0,_0,_0,_0,_0, - _0,_0,_0,_0,_1,_1,_1,_1, - _0,_0,_0,_0,_0,_0,_0,_0, - _0,_0,_0,_0,_0,_0,_0,_0, -}; - -void dma1_channel5_isr(){ - if(DMA1->ISR & DMA_ISR_TCIF5){ // transfer complete - if(chkctr()){ - for(int i = 28; i < 32; ++i) // invert G in second half - if(dmabuff[i] == _0) dmabuff[i] = _1; - else dmabuff[i] = _0; - } - }else if(DMA1->ISR & DMA_ISR_HTIF5){ // half transfer complete - if(chkctr()){ - for(int i = 20; i < 24; ++i) // invert B in first half - if(dmabuff[i] == _0) dmabuff[i] = _1; - else dmabuff[i] = _0; - } - } - DMA1->IFCR = DMA_IFCR_CGIF5; -} - -static void sendone(){ - static uint8_t ctr = 7; - TIM1->CR1 = 0; // stop - DMA1_Channel5->CCR &= ~DMA_CCR_EN; // disable DMA to reconfigure - // change values of dmabuff: G in first half & R in second - if(--ctr == 1) ctr = 6; // 6..2 - for(int i = 0; i < 8; ++i){ - uint8_t val = (i == ctr) ? _1 : _0; - dmabuff[i] = val; - dmabuff[32+i] = val; - } - TIM1->DIER = TIM_DIER_UDE; // enable DMA requests - DMA1->IFCR = DMA_IFCR_CGIF5; - DMA1_Channel5->CNDTR = 48; - DMA1_Channel5->CMAR = (uint32_t)dmabuff; - DMA1_Channel5->CCR |= DMA_CCR_EN; // start DMA - TIM1->CR1 = TIM_CR1_CEN | TIM_CR1_URS;// | TIM_CR1_DIR; -} - int main(void){ uint32_t lastT = 0; sysreset(); @@ -141,18 +67,13 @@ int main(void){ if(lastT > Tms || Tms - lastT > 499){ LED_blink(LED0); lastT = Tms; - sendone(); } usb_proc(); 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, l); - } + if(ans) USB_send(ans); } } return 0; diff --git a/F1-nolib/pwmtest/proto.c b/F1-nolib/pwmtest/proto.c index 671ffce..9421247 100644 --- a/F1-nolib/pwmtest/proto.c +++ b/F1-nolib/pwmtest/proto.c @@ -18,28 +18,79 @@ #include "proto.h" #include "usb.h" +#include "hardware.h" + +/** + * @brief getnum - get uint32_t + * @param buf (i) - string with text + * @param N (o) - number found + * @return 1 if all OK + */ +static int getnum(const char *buf, uint32_t *N){ + char c; + int found = 0; + uint32_t val = 0; + while((c = *buf)){ + if(c == '\t' || c == ' ') ++buf; + else break; + } + while((c = *buf++)){ + if(c < '0' || c > '9') break; + val = val * 10 + (uint32_t)(c - '0'); + found = 1; + } + if(found){ + *N = val; + return 1; + } + return 0; +} + -#define USND(str) do{USB_send(str, sizeof(str)-1);}while(0) const char *parse_cmd(const char *buf){ - if(buf[1] != '\n') return buf; + uint32_t U = 0; +#define GETN() getnum(buf+1, &U) + if(buf[1] != '\n'){ + switch(*buf){ // multisymbol commands + case 'D': // change duty + if(GETN()){ + if(changePWMduty(U)) return "OK\n"; + else return "Wrong\n"; + }else return "Wrong number\n"; + break; + case 'F': // change frequency + if(GETN()){ + if(changePWMfreq(U)) return "OK\n"; + else return "Wrong\n"; + }else return "Wrong number\n"; + break; + default: + return buf; + } + } switch(*buf){ - /*case 'p': - pin_toggle(USBPU_port, USBPU_pin); - USND("USB pullup is "); - if(pin_read(USBPU_port, USBPU_pin)) USND("off\n"); - else USND("on\n"); - return NULL; - break;*/ + case '0': + PWM_OFF(); + return "PWM is off\n"; + break; + case '1': + PWM_ON(); + return "PWM is on\n"; + break; case 'R': - USND("Soft reset\n"); + USB_send("Soft reset\n"); NVIC_SystemReset(); break; case 'W': - USND("Wait for reboot\n"); + USB_send("Wait for reboot\n"); while(1){nop();}; break; default: // help return + "'0' - turn OFF PWM\n" + "'1' - turn ON PWM\n" + "'D n' - change duty (promille)\n" + "'F n' - change freq (Hz)\n" "'R' - software reset\n" "'W' - test watchdog\n" ; @@ -47,3 +98,19 @@ const char *parse_cmd(const char *buf){ } return NULL; } + +static char strbuf[11]; +// return string buffer (strbuf) with val +char *u2str(uint32_t val){ + char *bufptr = &strbuf[10]; + *bufptr = 0; + if(!val){ + *(--bufptr) = '0'; + }else{ + while(val){ + *(--bufptr) = val % 10 + '0'; + val /= 10; + } + } + return bufptr; +} diff --git a/F1-nolib/pwmtest/proto.h b/F1-nolib/pwmtest/proto.h index 09642cd..07b5c42 100644 --- a/F1-nolib/pwmtest/proto.h +++ b/F1-nolib/pwmtest/proto.h @@ -19,6 +19,9 @@ #ifndef PROTO_H__ #define PROTO_H__ +#include + const char *parse_cmd(const char *buf); +char *u2str(uint32_t val); #endif // PROTO_H__ diff --git a/F1-nolib/pwmtest/pwmtest.bin b/F1-nolib/pwmtest/pwmtest.bin index b2a465109e9ee118137d0571a905c0909dd873d8..2c9b9bf8c0e1cf4152f8f4208af0a5b87ec13119 100755 GIT binary patch delta 4166 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 delta 1713 zcmb_dZ%kWN6hHU9mcG&lJl1s3Kht(~j8V`6BUxO5N6Q|iWt1_d6I^_tF=a7YGmT9| zTQZm|#u$Aw&ePo~N#2(7rdaWpUrq?T*s59NBz-2`td*xWH|tZ9GqTwFR~5PzJ*`{4Qg>fsPJ zgnFlndvXXchmYzovo8(?2c@%g5s6EqbiMxNpe6hvz3=8L(h7Zq9Fn>;6|wA6d{r*d z*;Lqdx$@SHfHIK{JKv3T&PW?`byC&!Oz7N3n{fGO)&?2t*jotUb(5gx6>7I?&ePGM&!ut}a5ZNZ;KXV|yqxiAj$Q9SyIRVckU zc}>{~mq318fzr<>NwhiXvt3yrEIrQ>BNp@IFqA22kS)unC5P4;Q`-aFu+}>|mB;+! z^G1r`2+xfAqPZ?ZnvS-+^pj7!v}w*^@Pm9`fz--euAdnzD8b%_ctZ+SPY}E>t(cYwGmMhAEsZc3om)^;qx1JyN zkJU7Kl6<+Gb_k^??aLAYl9BQ8yAeLS^m;1Nr158$Ud@8DIx;^uK;vtmz}|sSMvF1Z z@5zNED{S4LBkYQPyHHOjyhSthhsv!}#B+Z5BLyaUY}LZ0;;-g&bos5*X3VPfr{Uw? zWQUSwG1D(JmPeFv21D=|!WFqQ=Mdb&_+15qpG`sPp8+MCKECY~M%Ly4^9-UE@wbAS zgbry;zgMeD4vZ}8T}0c5Y(m;)xT3AY?S!;oC?dS1XWt-+k$(0*c~bSJDxF3OBJc^M z9$fRNuKKx(MVLa|Mf`$DAZ&%e_zOoa. */ +//#include + #include "usb.h" #include "usb_lib.h" +static int sstrlen(const char *s){ + if(!s) return 0; + int l = 0; + while(*s++) ++l; + return l; +} + static volatile uint8_t tx_succesfull = 1; static volatile uint8_t rxNE = 0; @@ -87,22 +96,8 @@ static void send_next(){ buflen = 0; } -// unblocking sending - just fill a buffer -void USB_send(const char *buf, uint16_t len){ - 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, uint16_t len){ +static void _USB_send_blk(const char *buf, int len){ if(!usbON || !len) return; // USB disconnected if(buflen){ usbwr(usbbuff, buflen); @@ -121,6 +116,26 @@ void USB_send_blk(const char *buf, uint16_t len){ } } +// unblocking sending - just fill a buffer +void USB_send(const char *buf){ + if(!usbON || !buf || !*buf) return; + int len = sstrlen(buf); + 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++; +} + +void USB_send_blk(const char *buf){ + int len = sstrlen(buf); + _USB_send_blk(buf, len); +} + void usb_proc(){ switch(USB_Dev.USB_Status){ case USB_STATE_CONFIGURED: diff --git a/F1-nolib/pwmtest/usb.h b/F1-nolib/pwmtest/usb.h index 6249c2c..c49fd05 100644 --- a/F1-nolib/pwmtest/usb.h +++ b/F1-nolib/pwmtest/usb.h @@ -26,8 +26,8 @@ void USB_setup(); void usb_proc(); -void USB_send(const char *buf, uint16_t len); -void USB_send_blk(const char *buf, uint16_t len); +void USB_send(const char *buf); +void USB_send_blk(const char *buf); uint8_t USB_receive(uint8_t *buf); #endif // __USB_H__