ledmatrix: Allow to dynamically set PWM Frequency (#62)

Author: JohnAZoidberg

Cargo.lock

@@ -31,7 +31,7 @@ num-derive = "0.3"
 num-traits = { version = "0.2", default-features = false }
 
 # LED Matrix
-is31fl3741 = { git = "https://github.com/JohnAZoidberg/is31fl3741", branch = "all-at-once-update-deps", optional = true }
+is31fl3741 = { git = "https://github.com/JohnAZoidberg/is31fl3741", branch = "merged", optional = true }
 
 # B1 Display
 st7306 = { git = "https://github.com/FrameworkComputer/st7306-rs", branch = "update-deps", optional = true }

fl16-inputmodules/Cargo.toml

@@ -35,6 +35,8 @@ use crate::games::snake;
 use crate::matrix::*;
 #[cfg(feature = "ledmatrix")]
 use crate::patterns::*;
+#[cfg(feature = "ledmatrix")]
+use is31fl3741::PwmFreq;
 
 #[cfg(feature = "c1minimal")]
 use smart_leds::{SmartLedsWrite, RGB8};
@@ -66,6 +68,7 @@ pub enum CommandVals {
     SetFps = 0x1A,
     SetPowerMode = 0x1B,
     AnimationPeriod = 0x1C,
+    PwmFreq = 0x1E,
     Version = 0x20,
 }
 
@@ -125,6 +128,30 @@ pub enum DisplayMode {
     Hpm = 0x01,
 }
 
+#[cfg(feature = "ledmatrix")]
+#[derive(Copy, Clone, num_derive::FromPrimitive)]
+pub enum PwmFreqArg {
+    /// 29kHz
+    P29k = 0x00,
+    /// 3.6kHz
+    P3k6 = 0x01,
+    /// 1.8kHz
+    P1k8 = 0x02,
+    /// 900Hz
+    P900 = 0x03,
+}
+#[cfg(feature = "ledmatrix")]
+impl From<PwmFreqArg> for PwmFreq {
+    fn from(val: PwmFreqArg) -> Self {
+        match val {
+            PwmFreqArg::P29k => PwmFreq::P29k,
+            PwmFreqArg::P3k6 => PwmFreq::P3k6,
+            PwmFreqArg::P1k8 => PwmFreq::P1k8,
+            PwmFreqArg::P900 => PwmFreq::P900,
+        }
+    }
+}
+
 // TODO: Reduce size for modules that don't require other commands
 pub enum Command {
     /// Get current brightness scaling
@@ -175,6 +202,9 @@ pub enum Command {
     GetPowerMode,
     SetAnimationPeriod(u16),
     GetAnimationPeriod,
+    #[cfg(feature = "ledmatrix")]
+    SetPwmFreq(PwmFreqArg),
+    GetPwmFreq,
     _Unknown,
 }
 
@@ -348,6 +378,13 @@ pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
                     Some(Command::GetAnimationPeriod)
                 }
             }
+            Some(CommandVals::PwmFreq) => {
+                if let Some(freq) = arg {
+                    FromPrimitive::from_u8(freq).map(Command::SetPwmFreq)
+                } else {
+                    Some(Command::GetPwmFreq)
+                }
+            }
             _ => None,
         }
     } else {
@@ -567,6 +604,16 @@ pub fn handle_command(
             response[0..2].copy_from_slice(&(period_ms as u16).to_le_bytes());
             Some(response)
         }
+        Command::SetPwmFreq(arg) => {
+            state.pwm_freq = *arg;
+            matrix.device.set_pwm_freq(state.pwm_freq.into()).unwrap();
+            None
+        }
+        Command::GetPwmFreq => {
+            let mut response: [u8; 32] = [0; 32];
+            response[0] = state.pwm_freq as u8;
+            Some(response)
+        }
         _ => handle_generic_command(command),
     }
 }

fl16-inputmodules/src/control.rs

@@ -1,3 +1,4 @@
+use crate::control::PwmFreqArg;
 use crate::games::game_of_life::GameOfLifeState;
 use crate::games::pong::PongState;
 use crate::games::snake::SnakeState;
@@ -22,6 +23,7 @@ pub struct LedmatrixState {
     pub sleeping: SleepState,
     pub game: Option<GameState>,
     pub animation_period: u64,
+    pub pwm_freq: PwmFreqArg,
 }
 
 #[allow(clippy::large_enum_variant)]

fl16-inputmodules/src/matrix.rs

@@ -47,6 +47,7 @@ enum Command {
     Fps = 0x1A,
     PowerMode = 0x1B,
     AnimationPeriod = 0x1C,
+    PwmFreq = 0x1E,
     Version = 0x20,
 }
 
@@ -221,6 +222,10 @@ pub fn serial_commands(args: &crate::ClapCli) {
                     animation_fps_cmd(serialdev, fps);
                 }
 
+                if let Some(freq) = ledmatrix_args.pwm_freq {
+                    pwm_freq_cmd(serialdev, freq);
+                }
+
                 if ledmatrix_args.stop_game {
                     simple_cmd(
                         serialdev,
@@ -975,12 +980,44 @@ fn animation_fps_cmd(serialdev: &str, arg: Option<u16>) {
         port.read_exact(response.as_mut_slice())
             .expect("Found no data!");
 
-        println!("Response: {:X?}", response);
         let period = u16::from_le_bytes([response[0], response[1]]);
         println!("Animation Frequency: {}ms / {}Hz", period, 1_000 / period);
     }
 }
 
+fn pwm_freq_cmd(serialdev: &str, arg: Option<u16>) {
+    let mut port = serialport::new(serialdev, 115_200)
+        .timeout(SERIAL_TIMEOUT)
+        .open()
+        .expect("Failed to open port");
+
+    if let Some(freq) = arg {
+        let hz = match freq {
+            29000 => 0,
+            3600 => 1,
+            1800 => 2,
+            900 => 3,
+            _ => panic!("Invalid frequency"),
+        };
+        simple_cmd_port(&mut port, Command::PwmFreq, &[hz]);
+    } else {
+        simple_cmd_port(&mut port, Command::PwmFreq, &[]);
+
+        let mut response: Vec<u8> = vec![0; 32];
+        port.read_exact(response.as_mut_slice())
+            .expect("Found no data!");
+
+        let hz = match response[0] {
+            0 => 29000,
+            1 => 3600,
+            2 => 1800,
+            3 => 900,
+            _ => panic!("Invalid frequency"),
+        };
+        println!("Animation Frequency: {}Hz", hz);
+    }
+}
+
 fn set_color_cmd(serialdev: &str, color: Color) {
     let args = match color {
         Color::White => &[0xFF, 0xFF, 0xFF],

inputmodule-control/src/inputmodule.rs

@@ -126,6 +126,11 @@ pub struct LedMatrixSubcommand {
     #[arg(long)]
     pub animation_fps: Option<Option<u16>>,
 
+    /// Set/get PWM Frequency in Hz
+    #[arg(long)]
+    #[clap(value_enum)]
+    pub pwm_freq: Option<Option<u16>>,
+
     /// Crash the firmware (TESTING ONLY!)
     #[arg(long)]
     pub panic: bool,

inputmodule-control/src/ledmatrix.rs

@@ -15,19 +15,19 @@ defmt-rtt = "0.4"
 rp2040-panic-usb-boot = "0.5.0"
 
 # Not using an external BSP, we've got the Framework Laptop 16 BSPs locally in this crate
-rp2040-hal = { version="0.8", features=["rt", "critical-section-impl"] }
+rp2040-hal = { version = "0.8", features = ["rt", "critical-section-impl"] }
 rp2040-boot2 = "0.3"
 
 # USB Serial
-usb-device= "0.2.9"
+usb-device = "0.2.9"
 
 heapless = "0.7.16"
 usbd-serial = "0.1.1"
 usbd-hid = "0.6.1"
 fugit = "0.3.7"
 
-is31fl3741 = { git = "https://github.com/JohnAZoidberg/is31fl3741", branch = "all-at-once-update-deps", optional = true }
+is31fl3741 = { git = "https://github.com/JohnAZoidberg/is31fl3741", branch = "merged" }
 
 [dependencies.fl16-inputmodules]
 path = "../fl16-inputmodules"
-features = [ "ledmatrix" ]
+features = ["ledmatrix"]

ledmatrix/Cargo.toml

@@ -222,6 +222,7 @@ fn main() -> ! {
         sleeping: SleepState::Awake,
         game: None,
         animation_period: 31_250, // 31,250 us = 32 FPS
+        pwm_freq: PwmFreqArg::P29k,
     };
 
     let mut matrix = LedMatrix::configure(i2c);
@@ -233,6 +234,8 @@ fn main() -> ! {
         .set_scaling(MAX_BRIGHTNESS)
         .expect("failed to set scaling");
 
+    matrix.device.set_pwm_freq(state.pwm_freq.into()).unwrap();
+
     fill_grid_pixels(&state, &mut matrix);
 
     let timer = Timer::new(pac.TIMER, &mut pac.RESETS);

ledmatrix/src/main.rs

@@ -46,6 +46,7 @@ class CommandVals(IntEnum):
     ScreenSaver = 0x19
     SetFps = 0x1A
     SetPowerMode = 0x1B
+    PwmFreq = 0x1E
     Version = 0x20
 
 
@@ -96,6 +97,12 @@ class GameControlVal(IntEnum):
     Right = 3
     Quit = 4
 
+PWM_FREQUENCIES = [
+    '29kHz',
+    '3.6kHz',
+    '1.8kHz',
+    '900Hz',
+]
 
 PATTERNS = [
     'All LEDs on',
@@ -166,6 +173,10 @@ def main():
                         help='Start/stop vertical scrolling')
     parser.add_argument('--get-animate', action='store_true',
                         help='Check if currently animating')
+    parser.add_argument("--pwm", help="Adjust the PWM frequency. Value 0-255",
+                        type=int, choices=[29000, 3600, 1800, 900])
+    parser.add_argument("--get-pwm", help="Get current PWM Frequency",
+                        action="store_true")
     parser.add_argument("--pattern", help='Display a pattern',
                         type=str, choices=PATTERNS)
     parser.add_argument("--image", help="Display a PNG or GIF image in black and white only)",
@@ -285,6 +296,18 @@ def main():
     elif args.get_brightness:
         br = get_brightness(dev)
         print(f"Current brightness: {br}")
+    elif args.pwm is not None:
+        if args.pwm == 29000:
+            pwm_freq(dev, '29kHz')
+        elif args.pwm == 3600:
+            pwm_freq(dev, '3.6kHz')
+        elif args.pwm == 1800:
+            pwm_freq(dev, '1.8kHz')
+        elif args.pwm == 900:
+            pwm_freq(dev, '900Hz')
+    elif args.get_pwm:
+        p = get_pwm_freq(dev)
+        print(f"Current PWM Frequency: {p} Hz")
     elif args.percentage is not None:
         if args.percentage > 100 or args.percentage < 0:
             print("Percentage must be 0-100")
@@ -414,6 +437,23 @@ def get_brightness(dev):
     return int(res[0])
 
 
+def get_pwm_freq(dev):
+    """Adjust the brightness scaling of the entire screen.
+    """
+    res = send_command(dev, CommandVals.PwmFreq, with_response=True)
+    freq = int(res[0])
+    if freq == 0:
+        return 29000
+    elif freq == 1:
+        return 3600
+    elif freq == 2:
+        return 1800
+    elif freq == 3:
+        return 900
+    else:
+        return None
+
+
 def get_version(dev):
     """Get the device's firmware version"""
     res = send_command(dev, CommandVals.Version, with_response=True)
@@ -963,6 +1003,18 @@ def light_leds(dev, leds):
     send_command(dev, CommandVals.Draw, vals)
 
 
+def pwm_freq(dev, freq):
+    """Display a pattern that's already programmed into the firmware"""
+    if freq == '29kHz':
+        send_command(dev, CommandVals.PwmFreq, [0])
+    elif freq == '3.6kHz':
+        send_command(dev, CommandVals.PwmFreq, [1])
+    elif freq == '1.8kHz':
+        send_command(dev, CommandVals.PwmFreq, [2])
+    elif freq == '900Hz':
+        send_command(dev, CommandVals.PwmFreq, [3])
+
+
 def pattern(dev, p):
     """Display a pattern that's already programmed into the firmware"""
     if p == 'All LEDs on':
@@ -1177,6 +1229,9 @@ def gui(devices):
                 [sg.Button("Send '2 5 degC thunder'", k='-SEND-TEXT-')],
             ])
         ],
+        [sg.HorizontalSeparator()],
+        [sg.Text("PWM Frequency")],
+        [sg.Combo(PWM_FREQUENCIES, k='-PWM-FREQ-', enable_events=True)],
 
 
         # TODO
@@ -1245,6 +1300,9 @@ def gui(devices):
                 if event == '-PATTERN-':
                     pattern(dev, values['-PATTERN-'])
 
+                if event == '-PWM-FREQ-':
+                    pwm_freq(dev, values['-PWM-FREQ-'])
+
                 if event == 'Start Animation':
                     animate(dev, True)