View difference between Paste ID: YJdM4u9A and 1WkDQpCj

 /*
  * This file is part of the libopencm3 project.
  *
  * Copyright (C) 2010 Gareth McMullin <[email protected]>
  *
  * This library is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This library 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 Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <stdlib.h>
 #include <libopencm3/stm32/f4/rcc.h>
 #include <libopencm3/stm32/f4/gpio.h>
 #include <libopencm3/stm32/f4/timer.h>
 #include <libopencm3/stm32/f4/nvic.h>
 #include <libopencm3/usb/usbd.h>
 #include <libopencm3/usb/cdc.h>
-#include <libopencm3/cm3/nvic.h>
+
 #include "ring.h"
 #include "fourbyte.h"
 #include "timer.h"
 
 #define RX_BUFFER_SIZE    128
 static struct ring rx_ring;
 static u8 rx_buffer[RX_BUFFER_SIZE];
 static usbd_device *usbd_dev;
 //static bool start;
 
 static const struct usb_device_descriptor dev = {
 	.bLength = USB_DT_DEVICE_SIZE,
 	.bDescriptorType = USB_DT_DEVICE,
 	.bcdUSB = 0x0200,
 	.bDeviceClass = USB_CLASS_CDC,
 	.bDeviceSubClass = 0,
 	.bDeviceProtocol = 0,
 	.bMaxPacketSize0 = 64,
 	.idVendor = 0x0483,
 	.idProduct = 0x5740,
 	.bcdDevice = 0x0200,
 	.iManufacturer = 1,
 	.iProduct = 2,
 	.iSerialNumber = 3,
 	.bNumConfigurations = 1,
 };
 
 /*
  * This notification endpoint isn't implemented. According to CDC spec it's
  * optional, but its absence causes a NULL pointer dereference in the
  * Linux cdc_acm driver.
  */
 static const struct usb_endpoint_descriptor comm_endp[] = {{
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
 	.bEndpointAddress = 0x83,
 	.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,
 	.wMaxPacketSize = 16,
 	.bInterval = 255,
 }};
 
 static const struct usb_endpoint_descriptor data_endp[] = {{
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
 	.bEndpointAddress = 0x01,
 	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
 	.wMaxPacketSize = 64,
 	.bInterval = 1,
 }, {
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
 	.bEndpointAddress = 0x82,
 	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
 	.wMaxPacketSize = 64,
 	.bInterval = 1,
 }};
 
 static const struct {
 	struct usb_cdc_header_descriptor header;
 	struct usb_cdc_call_management_descriptor call_mgmt;
 	struct usb_cdc_acm_descriptor acm;
 	struct usb_cdc_union_descriptor cdc_union;
 } __attribute__((packed)) cdcacm_functional_descriptors = {
 	.header = {
 		.bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
 		.bDescriptorType = CS_INTERFACE,
 		.bDescriptorSubtype = USB_CDC_TYPE_HEADER,
 		.bcdCDC = 0x0110,
 	},
 	.call_mgmt = {
 		.bFunctionLength =
 			sizeof(struct usb_cdc_call_management_descriptor),
 		.bDescriptorType = CS_INTERFACE,
 		.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
 		.bmCapabilities = 0,
 		.bDataInterface = 1,
 	},
 	.acm = {
 		.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
 		.bDescriptorType = CS_INTERFACE,
 		.bDescriptorSubtype = USB_CDC_TYPE_ACM,
 		.bmCapabilities = 0,
 	},
 	.cdc_union = {
 		.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
 		.bDescriptorType = CS_INTERFACE,
 		.bDescriptorSubtype = USB_CDC_TYPE_UNION,
 		.bControlInterface = 0,
 		.bSubordinateInterface0 = 1,
 	 }
 };
 
 static const struct usb_interface_descriptor comm_iface[] = {{
 	.bLength = USB_DT_INTERFACE_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE,
 	.bInterfaceNumber = 0,
 	.bAlternateSetting = 0,
 	.bNumEndpoints = 1,
 	.bInterfaceClass = USB_CLASS_CDC,
 	.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
 	.bInterfaceProtocol = USB_CDC_PROTOCOL_AT,
 	.iInterface = 0,
 
 	.endpoint = comm_endp,
 
 	.extra = &cdcacm_functional_descriptors,
 	.extralen = sizeof(cdcacm_functional_descriptors)
 }};
 
 static const struct usb_interface_descriptor data_iface[] = {{
 	.bLength = USB_DT_INTERFACE_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE,
 	.bInterfaceNumber = 1,
 	.bAlternateSetting = 0,
 	.bNumEndpoints = 2,
 	.bInterfaceClass = USB_CLASS_DATA,
 	.bInterfaceSubClass = 0,
 	.bInterfaceProtocol = 0,
 	.iInterface = 0,
 
 	.endpoint = data_endp,
 }};
 
 static const struct usb_interface ifaces[] = {{
 	.num_altsetting = 1,
 	.altsetting = comm_iface,
 }, {
 	.num_altsetting = 1,
 	.altsetting = data_iface,
 }};
 
 static const struct usb_config_descriptor config = {
 	.bLength = USB_DT_CONFIGURATION_SIZE,
 	.bDescriptorType = USB_DT_CONFIGURATION,
 	.wTotalLength = 0,
 	.bNumInterfaces = 2,
 	.bConfigurationValue = 1,
 	.iConfiguration = 0,
 	.bmAttributes = 0x80,
 	.bMaxPower = 0x32,
 
 	.interface = ifaces,
 };
 
 static const char *usb_strings[] = {
 	"Black Sphere Technologies",
 	"CDC-ACM Demo",
 	"DEMO",
 };
 
 static int cdcacm_control_request(usbd_device *usbd_dev, struct usb_setup_data *req, u8 **buf,
 		u16 *len, void (**complete)(usbd_device *usbd_dev, struct usb_setup_data *req))
 {
 	(void)complete;
 	(void)buf;
 	(void)usbd_dev;
 
 	switch (req->bRequest) {
 	case USB_CDC_REQ_SET_CONTROL_LINE_STATE: {
 		/*
 		 * This Linux cdc_acm driver requires this to be implemented
 		 * even though it's optional in the CDC spec, and we don't
 		 * advertise it in the ACM functional descriptor.
 		 */
 		return 1;
 		}
 	case USB_CDC_REQ_SET_LINE_CODING:
 		if (*len < sizeof(struct usb_cdc_line_coding))
 			return 0;
 
 		return 1;
 	}
 	return 0;
 }
 
 static void cdcacm_data_rx_cb(usbd_device *usbd_dev, u8 ep)
 {
 	(void)ep;
 
 	char buf[64];
 	int len = usbd_ep_read_packet(usbd_dev, 0x01, buf, 64);
 
 	if (len) {
 		ring_write(&rx_ring, (u8 *) buf, (u32) len);
 	}
 
 	gpio_toggle(GPIOC, GPIO5);
 }
 
 static void cdcacm_set_config(usbd_device *usbd_dev, u16 wValue)
 {
 	(void)wValue;
 
 	usbd_ep_setup(usbd_dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_rx_cb);
 	usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, NULL);
 	usbd_ep_setup(usbd_dev, 0x83, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
 
 	usbd_register_control_callback(
 				usbd_dev,
 				USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE,
 				USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT,
 				cdcacm_control_request);
 }
-void nvic_setup(void)
+
 void pwm1_setup(void){
-        /* Without this the timer interrupt routine will never be called. */
+
-        nvic_enable_irq(NVIC_TIM2_IRQ);
+
-        nvic_set_priority(NVIC_TIM2_IRQ, 1);
+    timer_reset(TIM1);
     timer_set_mode(TIM1, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
 
-void tim2_init(void){
+    timer_set_prescaler(TIM1, 0);
-                rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_TIM2EN);
+    timer_enable_preload(TIM1);
-        /* Set timer start value. */
+    timer_continuous_mode(TIM1);
-        TIM_CNT(TIM2) = 1;
+    timer_set_period(TIM1, 168000000 / 32000);
 
-        /* Set timer prescaler. 120MHz/120000 => 1000 counts per second. */
+    timer_disable_oc_output(TIM1, TIM_OC1);
-        TIM_PSC(TIM2) = 120000;
+
     timer_disable_oc_output(TIM1, TIM_OC1N);
-        /* End timer value. If this is reached an interrupt is generated. */
+	timer_disable_oc_clear(TIM1, TIM_OC1N);
-        TIM_ARR(TIM2) = 1000;
+    timer_enable_oc_preload(TIM1, TIM_OC1N);
 
-        /* Update interrupt enable. */
+	timer_disable_oc_clear(TIM1, TIM_OC1);
-        TIM_DIER(TIM2) |= TIM_DIER_UIE;
+    timer_enable_oc_preload(TIM1, TIM_OC1);
 
-        /* Start timer. */
+    timer_set_oc_mode(TIM1, TIM_OC1, TIM_OCM_PWM1);
-        TIM_CR1(TIM2) |= TIM_CR1_CEN;
+    timer_set_oc_value(TIM1, TIM_OC1, 1200);
 
     // Applies to CH1
-void tim2_isr(void)
+    //timer_set_oc_mode(TIM1, TIM_OC1N, TIM_OCM_PWM2);
 
-        //gpio_toggle(GPIOB, GPIO6);   /* LED2 on/off. */
+    timer_enable_oc_output(TIM1, TIM_OC1);
-        TIM_SR(TIM2) &= ~TIM_SR_UIF; /* Clear interrrupt flag. */
+    timer_enable_oc_output(TIM1, TIM_OC1N);
-        ring_init(&rx_ring, rx_buffer, RX_BUFFER_SIZE);
+
     timer_enable_preload(TIM1);
     timer_disable_preload_complementry_enable_bits(TIM1);
-void setup_periodic_timer(uint32_t timer, unsigned int freq_in_hz)
+    timer_enable_break_main_output(TIM1);
 
-    unsigned int prescaler = 1;
+    timer_enable_counter(TIM1);
-    while (rcc_ppre1_frequency / prescaler / freq_in_hz > 0xffff)
+    timer_enable_irq(TIM1, TIM_DIER_CC1IE);
-        prescaler *= 2;
+    nvic_enable_irq(NVIC_TIM1_CC_IRQ);
-    timer_reset(timer);
+
-    timer_set_prescaler(timer, prescaler-1);
+
-    timer_set_period(timer, rcc_ppre1_frequency / prescaler / freq_in_hz);
+
-    timer_direction_down(timer);
+	timer_clear_flag(TIM4, TIM_SR_UIF);
-    timer_enable_preload(timer);
+	gpio_clear(GPIOD, GPIO12|GPIO13|GPIO14);
 	//~ while (usbd_ep_write_packet(usbd_dev, 0x82, "2", 1) == 0)
 				//~ ;
-void gpio_setup(void){
+
 
-	/* Enable GPIOD clock. */
+void tim1_cc_isr(){
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPDEN);
+	timer_clear_flag(TIM1, TIM_SR_CC1IF);
-	/* Set GPIO12 (in GPIO port D) to 'output push-pull'. */
+	gpio_toggle(GPIOD, GPIO14);
-	gpio_mode_setup(GPIOD, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO13);
+
 
 void startup(){
 	nvic_enable_irq(NVIC_TIM4_IRQ);
-void tim_setup(void){
+    //~ timer_reset(TIM4);
     timer_set_mode(TIM4, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
-	gpio_mode_setup(GPIOD, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO12);
+    timer_set_prescaler(TIM4, 16800); //168000000/16800 = 10000 ticks/s
-	gpio_set_af(GPIOD, GPIO_AF2, GPIO12);
+    timer_set_period(TIM4,10000); // 10000/10000 = 1s
-	//~ timer_reset(TIM4);
+    timer_one_shot_mode(TIM4);
-	//~ timer_set_mode(TIM4, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
+    //~ timer_continuous_mode(TIM4);
-	//~ timer_set_prescaler(TIM4, 0);
+
-	//~ timer_set_repetition_counter(TIM4, 0);
+    //~ timer_enable_preload(TIM4);
-	//~ timer_enable_preload(TIM4);
+    //~ timer_disable_preload(TIM4);
-	//~ timer_continuous_mode(TIM4);
+    gpio_set(GPIOD, GPIO12|GPIO13|GPIO14);
-	//~ timer_set_period(TIM4, 168000000 / 32000);
+    timer_enable_irq(TIM4, TIM_DIER_UIE);
-	//~ timer_disable_oc_output(TIM4, TIM_OC1);
+
-	//~ timer_disable_oc_clear(TIM4, TIM_OC1);
+
-	//~ timer_enable_oc_preload(TIM4, TIM_OC1);
+
-	//~ timer_set_oc_mode(TIM4, TIM_OC1, TIM_OCM_PWM1);
+
-	//~ timer_set_oc_value(TIM4, TIM_OC1, 5260);
+
-	//~ timer_enable_oc_output(TIM4, TIM_OC1);
+
-	//~ timer_enable_preload(TIM4);
+
-	//~ timer_enable_counter(TIM4);
+
 			switch(command[1]){
 				case ID_FL:
-    nvic_enable_irq(NVIC_TIM4_IRQ);
+
-    timer_reset(TIM4);
+
 						;
-    timer_set_prescaler(TIM4, 0);
+
-    timer_enable_preload(TIM4);
+
-    timer_continuous_mode(TIM4);
+		case START_UP:
-    timer_set_period(TIM4, 168000000 / 32000);
+			while (usbd_ep_write_packet(usbd_dev, 0x82, "1", 1) == 0)
 				;
-    timer_disable_oc_output(TIM4, TIM_OC1);
+			gpio_clear(GPIOD, GPIO12|GPIO13|GPIO14);
-	timer_disable_oc_clear(TIM4, TIM_OC1);
+			startup();
-    timer_enable_oc_preload(TIM4, TIM_OC1);
+
-    timer_set_oc_mode(TIM4, TIM_OC1, TIM_OCM_PWM1);
+
-    timer_set_oc_value(TIM4, TIM_OC1, 1000);
+
 	}
-    timer_enable_oc_output(TIM4, TIM_OC1);
+
-    timer_enable_preload(TIM4);
+
-    timer_enable_irq(TIM4, TIM_DIER_CC4IE);
+
 int main(void)
 {
 	rcc_clock_setup_hse_3v3(&hse_8mhz_3v3[CLOCK_3V3_168MHZ]);
 
-	timer_clear_flag(TIM4, 0xffffffff);
+
 	rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_TIM1EN);
 	rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);
 
 	rcc_peripheral_enable_clock(&RCC_AHB1ENR,
 					RCC_AHB1ENR_IOPAEN |
 					RCC_AHB1ENR_IOPBEN |
 					RCC_AHB1ENR_IOPDEN |
 					RCC_AHB1ENR_IOPEEN);
 
 	gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE,
 			GPIO9 | GPIO11 | GPIO12);
 	gpio_set_af(GPIOA, GPIO_AF10, GPIO9 | GPIO11 | GPIO12);
 
 	gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO12|GPIO13|GPIO14);
 
 	gpio_mode_setup(GPIOE, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO8|GPIO9);
 	gpio_set_af(GPIOE, GPIO_AF1, GPIO8|GPIO9);
 
 	usbd_dev = usbd_init(&otgfs_usb_driver, &dev, &config, usb_strings, 3);
 	usbd_register_set_config_callback(usbd_dev, cdcacm_set_config);
 
 	u8 command[4];
-	rcc_clock_setup_hse_3v3(&hse_8mhz_3v3[CLOCK_3V3_120MHZ]);
+
     ring_init(&rx_ring, rx_buffer, RX_BUFFER_SIZE);
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
+	pwm1_setup();
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPDEN);
+
-	rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);
+
 
 		if (rx_ring.count >= 4){
-	gpio_mode_setup(GPIOD, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO12|GPIO13);
+
-	gpio_set_af(GPIOD, GPIO_AF2, GPIO12|GPIO13);
+
 				parse_bytes(command);
 			}
 		}
 	}
 }