luke-else/esp32_gps_display
1
0
Fork 0
generated from luke-else/esp32-std-template
Code Issues 5 Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: luke-else:a2a9abc4b3948284b79f82f0c7ac0126f93db57e
Branches Tags
luke-else:main
luke-else:nmea-lib
..
compare: luke-else:278444b620de53134e99305db6869be8562ac425
Branches Tags
luke-else:nmea-lib
luke-else:main

No commits in common. "a2a9abc4b3948284b79f82f0c7ac0126f93db57e" and "278444b620de53134e99305db6869be8562ac425" have entirely different histories.
a2a9abc4b3 ... 278444b620

3 changed files with 61 additions and 67 deletions
Show Stats Expand all files Collapse all files

65
src/display/mod.rs
View File

@ -1,21 +1,25 @@
use crate::error::Error;
use display_interface_i2c::I2CInterface;
use embedded_graphics::{
mono_font::{ascii::FONT_10X20, MonoTextStyle},
pixelcolor::BinaryColor,
prelude::*,
text::{Alignment, Text},
mono_font::{ascii::FONT_7X13, ascii::FONT_10X20, MonoTextStyle},
pixelcolor::BinaryColor,
text::{Text, Alignment},
};
use esp_idf_hal::i2c::I2cDriver;
use ssd1306::{
prelude::*, rotation::DisplayRotation, size::DisplaySize, I2CDisplayInterface, Ssd1306,
use esp_idf_hal::{
self,
prelude::Peripherals,
units::Hertz,
i2c::{I2cConfig, I2cDriver, I2c}
};
// clear the stage of failure of the display
use ssd1306::{prelude::*, I2CDisplayInterface, Ssd1306};
use display_interface_i2c;
/// Enum to make clear the stage of failure of the display
#[derive(Debug)]
pub enum DisplayError {
SetupError(display_interface::DisplayError),
@ -24,45 +28,44 @@ pub enum DisplayError {
}
pub struct Display<'a, SIZE: DisplaySize> {
display: Ssd1306<I2CInterface<I2cDriver<'a>>, SIZE, ssd1306::mode::BufferedGraphicsMode<SIZE>>,
display: Ssd1306<I2CInterface<I2cDriver<'a>>, SIZE, ssd1306::mode::BufferedGraphicsMode<SIZE>>
}
impl<'a, SIZE: DisplaySize> Display<'a, SIZE> {
impl<'a, SIZE: DisplaySize> Display<'a, SIZE>
{
/// Function to create a new display interface abstraction
pub fn new(
i2c: I2cDriver<'a>,
size: SIZE,
rotation: DisplayRotation,
) -> Result<Display<'a, SIZE>, Error> {
pub fn new(i2c: I2cDriver<'a>, size: SIZE, rotation: DisplayRotation) -> Result<Display<'a, SIZE>, Error> {
// Construct the I2C driver into a display interface
let interface = I2CDisplayInterface::new(i2c);
// Construct display with new anew driver
let mut display = Ssd1306::new(interface, size, rotation).into_buffered_graphics_mode();
display
.init()
.map_err(|err| Error::DisplayError(DisplayError::SetupError(err)))?;
let mut display = Ssd1306::new(interface, size, rotation)
.into_buffered_graphics_mode();
display.init().map_err(|err| Error::DisplayError(DisplayError::SetupError(err)))?;
Ok(Display { display })
Ok(Display{display})
}
/// Function to draw a given set of text to a display
pub fn draw(&mut self, text: &str) -> Result<(), Error> {
// Clear display ready for next write
let style = MonoTextStyle::new(&FONT_10X20, BinaryColor::On);
self.display
.clear(BinaryColor::Off)
.map_err(|_| Error::DisplayError(DisplayError::DrawingError))?;
self.display.clear(BinaryColor::Off)
.map_err(|_| Error::DisplayError(DisplayError::DrawingError))?;
// Draw text to Display
Text::with_alignment(text, Point::new(64, 20), style, Alignment::Center)
.draw(&mut self.display)
.map_err(|_| Error::DisplayError(DisplayError::DrawingError))?;
Text::with_alignment(
text,
Point::new(64, 20),
style,
Alignment::Center,
)
.draw(&mut self.display)
.map_err(|_| Error::DisplayError(DisplayError::DrawingError))?;
//Flush data to the display
self.display
.flush()
.map_err(|_| Error::DisplayError(DisplayError::FlushError))?;
self.display.flush()
.map_err(|_| Error::DisplayError(DisplayError::FlushError))?;
Ok(())
}

31
src/gps/gpsdata.rs
View File

@ -16,13 +16,12 @@ pub struct GpsData {
/// Altitude reported from GPS location
altitude: Option<f64>,
/// Timestamp of the last report
timestamp: Option<DateTime<Utc>>,
timestamp: Option<DateTime<Utc>>
}
impl ToString for GpsData {
fn to_string(&self) -> String {
format!(
"Latitude: {:.4?} \nLongitude: {:.4?} \nSpeed: {:.1?}mph \nAltitude: {:.1?}m",
format!("Latitude: {:.4?} \nLongitude: {:.4?} \nSpeed: {:.1?}mph \nAltitude: {:.1?}m",
self.latitude.unwrap_or_default(),
self.longitude.unwrap_or_default(),
self.speed.unwrap_or_default(),
@ -41,8 +40,7 @@ impl GpsData {
// Format the nmea buffer into a usable string
let nmea_raw = String::from_utf8(buf.to_owned())
.map_err(|_| GpsError::ReadError())
.unwrap_or_default();
.map_err(|_| GpsError::ReadError()).unwrap_or_default();
let nmea_vec: Vec<&str> = nmea_raw.split('$').collect();
// Loop through each sentence and use the information to update GPS data
@ -59,9 +57,7 @@ impl GpsData {
let nmea = match nmea_parser.parse_sentence(sentence.as_str()) {
Ok(nmea) => nmea,
// Don't continue processing a sentence if we know that it isn't supported
Err(_) => {
continue;
}
Err(_) => { continue; }
};
// print decoded gps data to serial
@ -71,7 +67,7 @@ impl GpsData {
// Update Altitude above ground level
self.altitude = match gga.altitude {
Some(_) => gga.altitude,
None => self.altitude,
None => self.altitude
};
}
nmea_parser::ParsedMessage::Gll(gll) => {
@ -92,16 +88,14 @@ impl GpsData {
None => {}
}
}
}
},
nmea_parser::ParsedMessage::Rmc(rms) => {
// Update Ground Speed
match rms.sog_knots {
Some(_) => {
self.speed = Some(knots_to_mph(rms.sog_knots.unwrap_or_default()))
}
Some(_) => self.speed = Some(knots_to_mph(rms.sog_knots.unwrap_or_default())),
None => {}
}
}
},
_ => {}
}
}
@ -110,12 +104,15 @@ impl GpsData {
}
/// Function to get a &str of the current speed reported by the GPS module
pub fn get_speed(&self) -> Option<f64> {
self.speed
pub fn get_speed(&self) -> String {
match self.speed {
Some(speed) => format!("{:.2?}mph\n", speed),
None => format!("AWAITING\nGPS\nDATA")
}
}
}
/// Function to simply convert knots to mph
fn knots_to_mph(knots: f64) -> f64 {
fn knots_to_mph(knots: f64) -> f64{
knots * 1.150779
}

24
src/main.rs
View File

@ -14,10 +14,10 @@ use error::Error;
mod appstate;
mod gps;
use gps::{gpsdata::GpsData, GPS};
use gps::{gpsdata, GPS};
mod display;
use display::Display;
use display::{Display, DisplayError};
use ssd1306::prelude::*;
fn main() -> Result<(), Error> {
@ -42,26 +42,20 @@ fn main() -> Result<(), Error> {
let i2c =
I2cDriver::new(peripherals.i2c0, sda, scl, &config).map_err(|err| Error::EspError(err))?;
// Prepare components for processing
let mut gps: GPS = GPS::new(peripherals.uart0, gps_rx)?;
let mut display: Display<DisplaySize128x64> =
Display::new(i2c, DisplaySize128x64, DisplayRotation::Rotate0)?;
let mut _app_state = appstate::AppState::default();
const NO_DATA: &str = "NO\nGPS\nDATA";
let mut app_state = appstate::AppState::default();
loop {
let text: String;
let text: &str;
// Get the latest data from GPS module and flush to Display
text = match gps.poll() {
Ok(res) => match res.get_speed() {
Some(s) => format!("{:.2} MPH", s),
None => NO_DATA.to_string(),
},
match gps.poll() {
Ok(res) => display.draw(&res.get_speed().as_str())?,
Err(e) => {
eprintln!("{:?}", e);
NO_DATA.to_string()
display.draw("NO\nGPS\nDATA");
}
};
display.draw(text.as_str())?
}
}
}