Skip to content

Generic framebuffer implementation in Rust for use with embedded-graphics library

License

Notifications You must be signed in to change notification settings

bernii/embedded-graphics-framebuf

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

58 Commits
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Contributors Forks Stargazers Issues Build Status MIT License LinkedIn


Embedded graphics logo

Framebuffer implementation for Rust's Embedded-graphics

Documentation

Crates.io · Report a Bug · Feature Request

About The Project

This Rust library is an implementation of the framebuffer approach for the embedded-graphics ecosystem. The goal is to perform bulk-write of all the screen pixels at once, instead of having multiple individual updates for separate primitives.

Graphic compositing in multiple operations with direct updates on a display can lead to flickering and clearing previous content on the screen is harder. A Framebuffer helps to deal with this by drawing on an in-memory display, so the final display image can be pushed all at once to your hardware display.

This technique is useful when you're updating large portions of screen or just simply don't want to deal with partial display updates but comes at the cost of higher RAM usage and more traffic to the displays. This crate also has DMA support, which can enhance the performance of larger display updates.

Getting Started

Make sure you have your rust environment configurated

Installation

  1. Add library to your Cargo.toml

    [dependencies]
    embedded-graphics-framebuf = "0.5.0"
  2. Use the library in you code

    use embedded_graphics_framebuf::FrameBuf;
    
    // ...
    
    // Backend for the buffer
    let mut data = [BinaryColor::Off; 12 * 11];
    let mut fbuf = FrameBuf::new(&mut data, 12, 11);
    
    // You would use a "real" display here...
    let mut display: MockDisplay<BinaryColor> = MockDisplay::new();
    Line::new(Point::new(2, 2), Point::new(10, 2))
        .into_styled(PrimitiveStyle::with_stroke(BinaryColor::On, 2))
        .draw(&mut fbuf)
        .unwrap();
    // Write it all to the display
    let area = Rectangle::new(Point::new(0, 0), fbuf.size());
    display.fill_contiguous(&area, data).unwrap();
  3. Your flickering problems should be solved at this point :)

Roadmap

  • add tests
  • add rustdocs
  • CI integration with GithHub Actions
  • better error generation & handling

See the open issues for a full list of proposed features (and known issues).

License

Distributed under the MIT License. See LICENSE for more information.

Contact

Bernard Kobos - @bkobos - [email protected]

Jounathaen - jounathaen at mail dot de

Project Link: https://github.com/bernii/embedded-graphics-framebuf

Acknowledgments

About

Generic framebuffer implementation in Rust for use with embedded-graphics library

Resources

License

Stars

Watchers

Forks

Packages

No packages published

Languages