Merge branch 'release/v0.2.0'

Author: thejpster

.github/workflows/release.yml

@@ -0,0 +1,43 @@
+on:
+  push:
+    tags:
+    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+name: Upload Release
+
+jobs:
+  build:
+    name: Upload Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+        with:
+          submodules: true
+      - name: Add Target
+        run: rustup target add thumbv6m-none-eabi
+      - name: Install flip-link
+        run: cd / && cargo install flip-link
+      - name: Build
+        run: cargo build --release --target=thumbv6m-none-eabi
+      - name: Get Branch Name
+        id: branch_name
+        run: |
+          echo ::set-output name=SOURCE_TAG::${GITHUB_REF#refs/tags/}
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ steps.branch_name.outputs.SOURCE_TAG }}
+          draft: true
+          prerelease: false
+      - name: Upload files to Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            target/thumbv6m-none-eabi/release/neotron-bmc
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

CHANGELOG.md

@@ -1,7 +1,14 @@
 # Changelog
 
-## Unrelease Changes
+## Unreleased Changes
 
+* None
+
+## v0.2.0
+* Change to blink power LED when in standby
+* Actually controls DC power and reset (but doesn't check the voltage rails yet)
+
+## v0.1.0
 * Skeleton application using knurling template
 * Started work on command protocol definition
 * LED Blinking Modes defined

Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Jonathan 'theJPster' Pallant <github@thejpster.org.uk>"]
 name = "neotron-bmc"
 edition = "2018"
-version = "0.1.0"
+version = "0.2.0"
 
 [workspace]
 members = ["testsuite"]
@@ -76,4 +76,4 @@ overflow-checks = false # <-
 # defmt = { git = "https://github.com/knurling-rs/defmt", rev = "use defmt version reported by `probe-run --version`" }
 # defmt-rtt = { git = "https://github.com/knurling-rs/defmt", rev = "use defmt version reported by `probe-run --version`" }
 # defmt-test = { git = "https://github.com/knurling-rs/defmt", rev = "use defmt version reported by `probe-run --version`" }
-# panic-probe = { git = "https://github.com/knurling-rs/defmt", rev = "use defmt version reported by `probe-run --version`" }
+# panic-probe = { git = "https://github.com/knurling-rs/defmt", rev = "use defmt version reported by `probe-run --version`" }

README.md

@@ -32,7 +32,7 @@ The NBMC firmware is designed to run on an ST Micro STM32F0 (STM32F031K6T6) micr
 | Pin  | Name | Signal      | Function                                     |
 | :--- | :--- | :---------- | :------------------------------------------- |
 | 02   | PF0  | BUTTON_nPWR | Power Button Input (active low)              |
-| 03   | PF1  | HOST_nRST   | Reset Output to reset the rest of the system |
+| 03   | PF1  | BUTTON_nRST | Reset Button Input (active low)              |
 | 06   | PA0  | MON_3V3     | 3.3V rail monitor Input (1.65V nominal)      |
 | 07   | PA1  | MON_5V      | 5.0V rail monitor Input (1.65V nominal)      |
 | 08   | PA2  | nSYS_RESET  | System Reset Output (active low)             |

src/main.rs

@@ -11,7 +11,7 @@
 use cortex_m::interrupt::free as disable_interrupts;
 use rtic::app;
 use stm32f0xx_hal::{
-	gpio::gpioa::{PA10, PA11, PA12, PA9},
+	gpio::gpioa::{PA10, PA11, PA12, PA2, PA3, PA9},
 	gpio::gpiob::{PB0, PB1},
 	gpio::gpiof::{PF0, PF1},
 	gpio::{Alternate, Input, Output, PullUp, PushPull, AF1},
@@ -54,28 +54,33 @@ const APP: () = {
 		/// The FTDI UART header (J105)
 		serial: serial::Serial<pac::USART1, PA9<Alternate<AF1>>, PA10<Alternate<AF1>>>,
 		/// The Clear-To-Send line on the FTDI UART header (which the serial object can't handle)
-		uart_cts: PA11<Alternate<AF1>>,
+		pin_uart_cts: PA11<Alternate<AF1>>,
 		/// The Ready-To-Receive line on the FTDI UART header (which the serial object can't handle)
-		uart_rts: PA12<Alternate<AF1>>,
+		pin_uart_rts: PA12<Alternate<AF1>>,
 		/// The power button
 		button_power: PF0<Input<PullUp>>,
 		/// The reset button
 		button_reset: PF1<Input<PullUp>>,
 		/// Tracks power button state for short presses. 75ms x 2 = 150ms is a short press
-		button_power_short_press: debouncr::Debouncer<u8, debouncr::Repeat2>,
+		press_button_power_short: debouncr::Debouncer<u8, debouncr::Repeat2>,
 		/// Tracks power button state for long presses. 75ms x 16 = 1200ms is a long press
-		button_power_long_press: debouncr::Debouncer<u16, debouncr::Repeat16>,
+		press_button_power_long: debouncr::Debouncer<u16, debouncr::Repeat16>,
 		/// Tracks DC power state
-		dc_power_enabled: DcPowerState,
+		state_dc_power_enabled: DcPowerState,
+		/// Controls the DC-DC PSU
+		pin_dc_on: PA3<Output<PushPull>>,
+		/// Controls the Reset signal across the main board, putting all the
+		/// chips (except this BMC!) in reset when pulled low.
+		pin_sys_reset: PA2<Output<PushPull>>,
 	}
 
 	/// The entry point to our application.
 	///
 	/// Sets up the hardware and spawns the regular tasks.
 	///
-	/// * Task `led_status_blink` - blinks the LED
+	/// * Task `led_power_blink` - blinks the LED
 	/// * Task `button_poll` - checks the power and reset buttons
-	#[init(spawn = [led_status_blink, button_poll])]
+	#[init(spawn = [led_power_blink, button_poll])]
 	fn init(ctx: init::Context) -> init::LateResources {
 		defmt::info!("Neotron BMC version {:?} booting", VERSION);
 
@@ -100,12 +105,14 @@ const APP: () = {
 		let (
 			uart_tx,
 			uart_rx,
-			uart_cts,
-			uart_rts,
+			pin_uart_cts,
+			pin_uart_rts,
 			mut led_power,
 			led_status,
 			button_power,
 			button_reset,
+			mut pin_dc_on,
+			mut pin_sys_reset,
 		) = disable_interrupts(|cs| {
 			(
 				gpioa.pa9.into_alternate_af1(cs),
@@ -116,17 +123,22 @@ const APP: () = {
 				gpiob.pb1.into_push_pull_output(cs),
 				gpiof.pf0.into_pull_up_input(cs),
 				gpiof.pf1.into_pull_up_input(cs),
+				gpioa.pa3.into_push_pull_output(cs),
+				gpioa.pa2.into_push_pull_output(cs),
 			)
 		});
 
+		pin_sys_reset.set_low().unwrap();
+		pin_dc_on.set_low().unwrap();
+
 		defmt::info!("Creating UART...");
 
 		let mut serial =
 			serial::Serial::usart1(dp.USART1, (uart_tx, uart_rx), 115_200.bps(), &mut rcc);
 
 		serial.listen(serial::Event::Rxne);
 
-		ctx.spawn.led_status_blink().unwrap();
+		ctx.spawn.led_power_blink().unwrap();
 
 		ctx.spawn.button_poll().unwrap();
 
@@ -136,15 +148,17 @@ const APP: () = {
 
 		init::LateResources {
 			serial,
-			uart_cts,
-			uart_rts,
+			pin_uart_cts,
+			pin_uart_rts,
 			led_power,
 			led_status,
 			button_power,
 			button_reset,
-			button_power_short_press: debouncr::debounce_2(false),
-			button_power_long_press: debouncr::debounce_16(false),
-			dc_power_enabled: DcPowerState::Off,
+			press_button_power_short: debouncr::debounce_2(false),
+			press_button_power_long: debouncr::debounce_16(false),
+			state_dc_power_enabled: DcPowerState::Off,
+			pin_dc_on,
+			pin_sys_reset,
 		}
 	}
 
@@ -182,78 +196,76 @@ const APP: () = {
 	///
 	/// This task is called periodically. We check whether the status LED is currently on or off,
 	/// and set it to the opposite. This makes the LED blink.
-	#[task(schedule = [led_status_blink], resources = [led_status])]
-	fn led_status_blink(ctx: led_status_blink::Context) {
+	#[task(schedule = [led_power_blink], resources = [led_power, state_dc_power_enabled])]
+	fn led_power_blink(ctx: led_power_blink::Context) {
 		// Use the safe local `static mut` of RTIC
 		static mut LED_STATE: bool = false;
 
-		defmt::trace!("blink time {}", ctx.scheduled.counts());
-
-		if *LED_STATE {
-			ctx.resources.led_status.set_low().unwrap();
-			*LED_STATE = false;
-		} else {
-			ctx.resources.led_status.set_high().unwrap();
-			*LED_STATE = true;
+		if *ctx.resources.state_dc_power_enabled == DcPowerState::Off {
+			defmt::trace!("blink time {}", ctx.scheduled.counts());
+			if *LED_STATE {
+				ctx.resources.led_power.set_low().unwrap();
+				*LED_STATE = false;
+			} else {
+				ctx.resources.led_power.set_high().unwrap();
+				*LED_STATE = true;
+			}
+			let next = ctx.scheduled + LED_PERIOD_MS.millis();
+			defmt::trace!("Next blink at {}", next.counts());
+			ctx.schedule.led_power_blink(next).unwrap();
 		}
-		let next = ctx.scheduled + LED_PERIOD_MS.millis();
-		defmt::trace!("Next blink at {}", next.counts());
-		ctx.schedule.led_status_blink(next).unwrap();
 	}
 
 	/// This task polls our power and reset buttons.
 	///
 	/// We poll them rather than setting up an interrupt as we need to debounce them, which involves waiting a short period and checking them again. Given that we have to do that, we might as well not bother with the interrupt.
-	#[task(schedule = [button_poll], resources = [led_power, button_power, button_power_short_press, button_power_long_press, dc_power_enabled])]
+	#[task(
+		schedule = [button_poll],
+		spawn = [led_power_blink],
+		resources = [
+			led_power, button_power, press_button_power_short, press_button_power_long, state_dc_power_enabled,
+			pin_sys_reset, pin_dc_on
+		]
+	)]
 	fn button_poll(ctx: button_poll::Context) {
 		// Poll button
 		let pressed: bool = ctx.resources.button_power.is_low().unwrap();
 
 		// Update state
-		let short_edge = ctx.resources.button_power_short_press.update(pressed);
-		let long_edge = ctx.resources.button_power_long_press.update(pressed);
+		let short_edge = ctx.resources.press_button_power_short.update(pressed);
+		let long_edge = ctx.resources.press_button_power_long.update(pressed);
 
 		// Dispatch event
-		if short_edge == Some(debouncr::Edge::Rising) {
-			defmt::trace!(
-				"Power short press in! {}",
-				*ctx.resources.dc_power_enabled as u8
-			);
-			if *ctx.resources.dc_power_enabled == DcPowerState::Off {
-				*ctx.resources.dc_power_enabled = DcPowerState::Starting;
+		match (long_edge, short_edge, *ctx.resources.state_dc_power_enabled) {
+			(None, Some(debouncr::Edge::Rising), DcPowerState::Off) => {
+				defmt::info!("Power button pressed whilst off.");
+				// Button pressed - power on system
+				*ctx.resources.state_dc_power_enabled = DcPowerState::Starting;
 				ctx.resources.led_power.set_high().unwrap();
 				defmt::info!("Power on!");
-				// TODO: Enable DC PSU here
+				ctx.resources.pin_dc_on.set_high().unwrap();
 				// TODO: Start monitoring 3.3V and 5.0V rails here
 				// TODO: Take system out of reset when 3.3V and 5.0V are good
+				ctx.resources.pin_sys_reset.set_high().unwrap();
 			}
-		} else if short_edge == Some(debouncr::Edge::Falling) {
-			defmt::trace!(
-				"Power short press out! {}",
-				*ctx.resources.dc_power_enabled as u8
-			);
-			match *ctx.resources.dc_power_enabled {
-				DcPowerState::Starting => {
-					*ctx.resources.dc_power_enabled = DcPowerState::On;
-				}
-				DcPowerState::On => {
-					// TODO: Tell host that power off was requested
-				}
-				DcPowerState::Off => {
-					// Ignore
-				}
+			(None, Some(debouncr::Edge::Falling), DcPowerState::Starting) => {
+				defmt::info!("Power button released.");
+				// Button released after power on
+				*ctx.resources.state_dc_power_enabled = DcPowerState::On;
 			}
-		}
-
-		if long_edge == Some(debouncr::Edge::Rising) {
-			defmt::trace!(
-				"Power long press in! {}",
-				*ctx.resources.dc_power_enabled as u8
-			);
-			if *ctx.resources.dc_power_enabled == DcPowerState::On {
-				*ctx.resources.dc_power_enabled = DcPowerState::Off;
+			(Some(debouncr::Edge::Rising), None, DcPowerState::On) => {
+				defmt::info!("Power button held whilst on.");
+				*ctx.resources.state_dc_power_enabled = DcPowerState::Off;
 				ctx.resources.led_power.set_low().unwrap();
 				defmt::info!("Power off!");
+				ctx.resources.pin_sys_reset.set_low().unwrap();
+				// TODO: Wait for 100ms for chips to stop?
+				ctx.resources.pin_dc_on.set_low().unwrap();
+				// Start LED blinking again
+				ctx.spawn.led_power_blink().unwrap();
+			}
+			_ => {
+				// Do nothing
 				// TODO: Put system in reset here
 				// TODO: Disable DC PSU here
 			}