jtbx/esp32-c_its-companion
Watch
0
0
Fork
You've already forked esp32-c_its-companion
 0
Code Activity

WIP screen: Show lane types

Browse source 
TODO: Actually draw on screen
This commit is contained in:
Jannik Beyerstedt 2026-08-28 21:23:06 +02:00
commit c40756adee
3 changed files with 98 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

63
src/applogic/mod.rs
View file

@ -106,6 +106,7 @@ pub struct GlosaSignalInfo {
pub struct SignalGroupData { pub struct SignalGroupData {
pub phase: SignalPhase, pub phase: SignalPhase,
pub maneuver: map::Maneuvers, pub maneuver: map::Maneuvers,
pub usages: Vec<map::UsageType>,
pub timing: Option<TimingData>, pub timing: Option<TimingData>,
} }
@ -383,35 +384,29 @@ impl State {
}), }),
) )
} else { } else {
// get signal groups which are in our approach // get signal groups which are in our approach and have a maneuver
let mut approach_sig_grps = intersection let mut approach_sig_grps = intersection
.signal_groups() .signal_groups()
.iter() .iter()
.filter(|i| { .filter_map(|i| {
info.signal_groups if let Some(maneuver) = i.maneuvers()
.iter() && info
.find(|sg_id| **sg_id == i.id()) .signal_groups
.is_some() .iter()
}) .find(|sg_id| **sg_id == i.id())
.collect::<Vec<_>>(); .is_some()
{
// sort signal groups by maneuver let phase = i
approach_sig_grps.sort_by_key(|v| v.maneuvers());
// display signal phases
let sig_grps = approach_sig_grps
.iter()
.filter_map(|sig| {
if let Some(maneuver) = sig.maneuvers() {
let phase = sig
.phase() .phase()
.map(core::convert::Into::into) .map(core::convert::Into::into)
.unwrap_or_default(); .unwrap_or_default();
let timing = TimingData::new(sig, self.time.and_utc()); let timing = TimingData::new(i, self.time.and_utc());
let usages = i.source_lane_usages().to_vec();
Some(SignalGroupData { Some(SignalGroupData {
phase, phase,
maneuver, maneuver,
usages,
timing, timing,
}) })
} else { } else {
@ -420,11 +415,39 @@ impl State {
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
// sort signal groups by maneuver
approach_sig_grps.sort_by_key(|v| v.maneuver);
// // display signal phases
// let sig_grps = approach_sig_grps
// .iter()
// .filter_map(|sig| {
// if let Some(maneuver) = sig.sig_group.maneuvers() {
// let phase = sig
// .sig_group
// .phase()
// .map(core::convert::Into::into)
// .unwrap_or_default();
// let timing =
// TimingData::new(&sig.sig_group, self.time.and_utc());
// Some(SignalGroupData {
// phase,
// maneuver,
// timing,
// usages: sig.lane_types.clone(),
// })
// } else {
// None
// }
// })
// .collect::<Vec<_>>();
( (
None, None,
GlosaOutput::Locked(GlosaSignalInfo { GlosaOutput::Locked(GlosaSignalInfo {
intersection_id: intersection.id(), intersection_id: intersection.id(),
signal_groups: sig_grps, signal_groups: approach_sig_grps,
}), }),
) // keep state, return signal groups ) // keep state, return signal groups
} }

67
src/applogic/v2x/map.rs
View file

@ -191,27 +191,35 @@ impl Intersection {
fn collect_signal_groups(lanes: &[Lane]) -> Vec<SignalGroup> { fn collect_signal_groups(lanes: &[Lane]) -> Vec<SignalGroup> {
let mut connections = lanes let mut connections = lanes
.iter() .iter()
.flat_map(|i| i.connections.clone()) .flat_map(ConnectionExt::from_lane)
.filter(|i| i.signal_group.is_some()) .filter(|i| i.conn.signal_group.is_some())
.collect::<Vec<_>>(); .collect::<Vec<_>>();
connections.sort_by_key(|i| i.signal_group.unwrap_or_default()); connections.sort_by_key(|i| i.conn.signal_group.unwrap_or_default());
let chunks = connections.chunk_by(|a, b| a.signal_group == b.signal_group); let chunks = connections.chunk_by(|a, b| a.conn.signal_group == b.conn.signal_group);
chunks chunks
.map(|chunk| { .map(|chunk| {
let (sig_grp_id, maneuvers, mut target_lanes) = chunk.iter().fold( let (sig_grp_id, maneuvers, mut target_lanes, mut source_lane_usages) =
(None, Maneuvers::default(), vec![]), chunk.iter().fold(
|(sig_grp_id, maneuvers, mut lanes), i| { (None, Maneuvers::default(), vec![], vec![]),
let new_maneuvers = i |(sig_grp_id, maneuvers, mut lanes, mut usages), i| {
.maneuvers let new_maneuvers = i
.map(|v| core::ops::Add::add(maneuvers, v)) .conn
.unwrap_or_default(); .maneuvers
lanes.push(i.target_lane_id); .map(|v| core::ops::Add::add(maneuvers, v))
.unwrap_or_default();
lanes.push(i.conn.target_lane_id);
(i.signal_group, new_maneuvers, lanes) let lane_usages = i.source_lane_usages.clone();
}, usages.extend_from_slice(&lane_usages);
);
usages.sort_unstable();
usages.dedup(); // TODO: only do this after all lanes were added?
(i.conn.signal_group, new_maneuvers, lanes, usages)
},
);
// unwrap is fine since we removed all connections without signal group beforehand // unwrap is fine since we removed all connections without signal group beforehand
let id = sig_grp_id.unwrap(); let id = sig_grp_id.unwrap();
@ -226,6 +234,7 @@ impl Intersection {
SignalGroup { SignalGroup {
id, id,
maneuvers, maneuvers,
source_lane_usages,
target_lanes, target_lanes,
phase: None, phase: None,
min_end_time: None, min_end_time: None,
@ -402,6 +411,28 @@ impl From<&etsi_its_dsrc::Connection> for Connection {
} }
} }
#[derive(Debug, Clone)]
#[allow(unused)]
struct ConnectionExt {
source_lane_id: u8,
source_lane_usages: Vec<UsageType>,
conn: Connection,
}
impl ConnectionExt {
fn from_lane(value: &Lane) -> Vec<Self> {
value
.connections
.iter()
.map(|conn| Self {
source_lane_id: value.id,
source_lane_usages: value.usages.clone(),
conn: *conn,
})
.collect()
}
}
/// Different view on a lane connection /// Different view on a lane connection
/// ///
/// Technically this data is redundant with the `Connection` data of a `Lane`, /// Technically this data is redundant with the `Connection` data of a `Lane`,
@ -411,7 +442,8 @@ impl From<&etsi_its_dsrc::Connection> for Connection {
pub struct SignalGroup { pub struct SignalGroup {
id: u8, id: u8,
maneuvers: Option<Maneuvers>, maneuvers: Option<Maneuvers>,
target_lanes: Vec<u8>, // mainly for debugging source_lane_usages: Vec<UsageType>, // for easier signal group evaluation
target_lanes: Vec<u8>, // mainly for debugging
// SPAT data // SPAT data
/// current signal phase /// current signal phase
@ -441,6 +473,9 @@ impl SignalGroup {
pub fn maneuvers(&self) -> Option<Maneuvers> { pub fn maneuvers(&self) -> Option<Maneuvers> {
self.maneuvers self.maneuvers
} }
pub fn source_lane_usages(&self) -> &[UsageType] {
&self.source_lane_usages
}
pub fn phase(&self) -> Option<etsi_its_dsrc::MovementPhaseState> { pub fn phase(&self) -> Option<etsi_its_dsrc::MovementPhaseState> {
self.phase self.phase
} }

3
src/screen.rs
View file

@ -356,6 +356,9 @@ where
.draw(&mut self.target)?; .draw(&mut self.target)?;
// TODO: draw lane type? // TODO: draw lane type?
// for usage in sig.usages {
// esp_println::println!("TODO: {usage}")
// }
// draw maneuver // draw maneuver
text::Text::with_alignment( text::Text::with_alignment(