Update examples to newer svd2rust api.

Similarly, the cortex-m crate API was also updated.

src/examples/_1_itm.rs

@@ -22,14 +22,13 @@
 //! extern crate cortex_m;
 //! extern crate cortex_m_rt;
 //! 
-//! use cortex_m::{asm, interrupt, peripheral};
+//! use cortex_m::{asm, Peripherals};
 //! 
 //! fn main() {
-//!     interrupt::free(|cs| {
-//!         let itm = peripheral::ITM.borrow(&cs);
+//!     let p = Peripherals::take().unwrap();
+//!     let mut itm = p.ITM;
 //! 
-//!         iprintln!(&itm.stim[0], "Hello, world!");
-//!     });
+//!     iprintln!(&mut itm.stim[0], "Hello, world!");
 //! }
 //! 
 //! // As we are not using interrupts, we just register a dummy catch all handler

src/examples/_5_device.rs

@@ -19,7 +19,7 @@
 //! $ edit Cargo.toml && cat $_
 //! [dependencies.stm32f103xx]
 //! features = ["rt"]
-//! version = "0.7.0"
+//! version = "0.8.0"
 //! ```
 //!
 //! ---
@@ -39,24 +39,29 @@
 //! use core::fmt::Write;
 //! 
 //! use cortex_m::interrupt::{self, Mutex};
-//! use cortex_m::peripheral::SystClkSource;
+//! use cortex_m::peripheral::syst::SystClkSource;
 //! use cortex_m_semihosting::hio::{self, HStdout};
 //! use stm32f103xx::Interrupt;
 //! 
 //! static HSTDOUT: Mutex<RefCell<Option<HStdout>>> =
 //!     Mutex::new(RefCell::new(None));
 //! 
+//! static NVIC: Mutex<RefCell<Option<cortex_m::peripheral::NVIC>>> =
+//!     Mutex::new(RefCell::new(None));
+//! 
 //! fn main() {
+//!     let global_p = cortex_m::Peripherals::take().unwrap();
 //!     interrupt::free(|cs| {
 //!         let hstdout = HSTDOUT.borrow(cs);
 //!         if let Ok(fd) = hio::hstdout() {
 //!             *hstdout.borrow_mut() = Some(fd);
 //!         }
 //! 
-//!         let nvic = stm32f103xx::NVIC.borrow(cs);
+//!         let mut nvic = global_p.NVIC;
 //!         nvic.enable(Interrupt::TIM2);
+//!         *NVIC.borrow(cs).borrow_mut() = Some(nvic);
 //! 
-//!         let syst = stm32f103xx::SYST.borrow(cs);
+//!         let mut syst = global_p.SYST;
 //!         syst.set_clock_source(SystClkSource::Core);
 //!         syst.set_reload(8_000_000); // 1s
 //!         syst.enable_counter();
@@ -73,9 +78,9 @@
 //!             writeln!(*hstdout, "Tick").ok();
 //!         }
 //! 
-//!         let nvic = stm32f103xx::NVIC.borrow(cs);
-//! 
-//!         nvic.set_pending(Interrupt::TIM2);
+//!         if let Some(nvic) = NVIC.borrow(cs).borrow_mut().as_mut() {
+//!             nvic.set_pending(Interrupt::TIM2);
+//!         }
 //!     });
 //! }
 //! 

src/examples/_6_allocator.rs

@@ -1,6 +1,6 @@
 //! How to use the heap and a dynamic memory allocator
 //!
-//! To compile this example you'll need to build the collections crate as part
+//! To compile this example you'll need to build the alloc crate as part
 //! of the Xargo sysroot. To do that change the Xargo.toml file to look like
 //! this:
 //!
@@ -8,7 +8,7 @@
 //! [dependencies.core]
 //! stage = 0
 //!
-//! [dependencies.collections] # NEW
+//! [dependencies.alloc] # NEW
 //! stage = 0
 //!
 //! [dependencies.compiler_builtins]
@@ -27,15 +27,16 @@
 //!
 //! ```
 //! 
-//! #[allow(deprecated)]
-//! #![feature(collections)]
+//! #![feature(alloc)]
 //! #![feature(used)]
+//! #![feature(global_allocator)]
 //! #![no_std]
+//! #[allow(deprecated)]
 //! 
 //! // This is the allocator crate; you can use a different one
 //! extern crate alloc_cortex_m;
 //! #[macro_use]
-//! extern crate collections;
+//! extern crate alloc;
 //! extern crate cortex_m;
 //! extern crate cortex_m_rt;
 //! extern crate cortex_m_semihosting;
@@ -44,25 +45,21 @@
 //! 
 //! use cortex_m::asm;
 //! use cortex_m_semihosting::hio;
+//! use alloc_cortex_m::CortexMHeap;
+//! 
+//! #[global_allocator]
+//! static ALLOCATOR: CortexMHeap = CortexMHeap::empty();
+//! 
+//! extern "C" {
+//!     static mut _sheap: u32;
+//!     static mut _eheap: u32;
+//! }
 //! 
 //! fn main() {
 //!     // Initialize the allocator
-//!     unsafe {
-//!         extern "C" {
-//!             // Start of the heap
-//!             static mut _sheap: usize;
-//!         }
-//! 
-//!         // Size of the heap in words (1 word = 4 bytes)
-//!         // NOTE The bigger the heap the greater the chance to run into a stack
-//!         // overflow (collision between the stack and the heap)
-//!         const SIZE: isize = 256;
-//! 
-//!         // End of the heap
-//!         let _eheap = (&mut _sheap as *mut _).offset(SIZE);
-//! 
-//!         alloc_cortex_m::init(&mut _sheap, _eheap);
-//!     }
+//!     let start = unsafe { &mut _sheap as *mut u32 as usize };
+//!     let end = unsafe { &mut _sheap as *mut u32 as usize };
+//!     unsafe { ALLOCATOR.init(start, end - start) }
 //! 
 //!     // Growable array allocated on the heap
 //!     let xs = vec![0, 1, 2];