ZennDev1337/Rust-for-Arduboy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

added serial demo and fixed some issues with str

Browse source
This commit is contained in:
ZennDev1337 2023-09-20 21:34:21 +02:00
parent 5dbe66e910
commit 82650ccdd8
9 changed files with 510 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

7
Cargo.lock generated
View file

@ -194,6 +194,13 @@ version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0293b4b29daaf487284529cc2f5675b8e57c61f70167ba415a463651fd6a918"
[[package]]
name = "serial"
version = "0.1.0"
dependencies = [
"arduboy-rust",
]
[[package]]
name = "snake"
version = "0.1.0"

1
Cargo.toml
View file

@ -5,6 +5,7 @@ members = [
"Examples/Arduboy-Tutorials/eeprom-byte",
"Examples/Arduboy-Tutorials/progmem",
"Examples/Arduboy-Tutorials/tone",
"Examples/Arduboy-Tutorials/serial",
"Examples/Arduboy-Tutorials/demo2",
"Examples/Arduboy-Tutorials/demo3",
"Examples/Arduboy-Tutorials/demo4",

12
Examples/Arduboy-Tutorials/serial/Cargo.toml Normal file
View file

@ -0,0 +1,12 @@
[package]
name = "serial"
version = "0.1.0"
authors = ["ZennDev <zenndev@protonmail.com>"]
license = "MIT OR Apache-2.0"
edition = "2021"
[lib]
crate-type = ["staticlib"]
[dependencies]
arduboy-rust = { path = "../../../arduboy-rust" }

44
Examples/Arduboy-Tutorials/serial/src/lib.rs Normal file
View file

@ -0,0 +1,44 @@
#![no_std]
#![allow(non_upper_case_globals)]
//Include the Arduboy Library
#[allow(unused_imports)]
use arduboy_rust::prelude::*;
#[allow(dead_code)]
const arduboy: Arduboy2 = Arduboy2::new();
// Progmem data
// dynamic ram variables
// The setup() function runs once when you turn your Arduboy on
#[no_mangle]
pub unsafe extern "C" fn setup() {
// put your setup code here, to run once:
arduboy.begin();
arduboy.set_frame_rate(30);
arduboy.clear();
serial::begin(9600)
}
// The loop() function repeats forever after setup() is done
#[no_mangle]
#[export_name = "loop"]
pub unsafe extern "C" fn loop_() {
// put your main code here, to run repeatedly:
if !arduboy.next_frame() {
return;
}
if serial::available() > 0 {
let intcoming_byte = serial::read_as_utf8_str();
serial::print("I received: \0");
serial::println(intcoming_byte);
}
if arduboy.pressed(A) {
serial::println("kekw")
}
arduboy.display();
}

18
Project/game/src/lib.rs
View file

@ -7,13 +7,7 @@ use arduboy_rust::prelude::*;
#[allow(dead_code)]
const arduboy: Arduboy2 = Arduboy2::new();
extern "C" {
#[link_name = "arduino_serial_begin"]
fn serial_begin(serial: c_ulong);
// #[link_name = "arduino_serial_println_chars"]
// fn serial_println_chars(cstr: *const c_char);
}
// Progmem data
// dynamic ram variables
@ -25,7 +19,7 @@ pub unsafe extern "C" fn setup() {
arduboy.begin();
arduboy.set_frame_rate(30);
arduboy.clear();
serial_begin(9600)
// serial::begin(9600)
}
// The loop() function repeats forever after setup() is done
@ -36,7 +30,15 @@ pub unsafe extern "C" fn loop_() {
if !arduboy.next_frame() {
return;
}
serial::print("velo\0");
// if serial::available() > 0 {
// let intcoming_byte = serial::read_as_utf8_str();
// serial::print("I received: \0");
// serial::println(intcoming_byte);
// }
if arduboy.pressed(A) {
//serial::print("kekw")
}
//serial_println_chars(b"hallo\0" as *const [u8] as *const i8);
arduboy.display();
}

58
arduboy-rust/Wrapper-Project/src/library/arduino/arduino_serial_export.h
View file

@ -1,4 +1,4 @@
#include <HardwareSerial.h>
extern "C"
{
@ -6,6 +6,18 @@ extern "C"
{
Serial.begin(serial);
}
void arduino_serial_end()
{
Serial.end();
}
int arduino_serial_available()
{
return Serial.available();
}
int arduino_serial_read()
{
return Serial.read();
}
void arduino_serial_println_chars(const char *cstr)
{
Serial.println(cstr);
@ -14,28 +26,60 @@ extern "C"
{
return Serial.println(reinterpret_cast<const __FlashStringHelper *>(cstr));
}
size_t arduino_serial_print_char(char c)
size_t arduino_serial_println_char(char c)
{
return Serial.println(c);
}
size_t arduino_serial_print_int(int n, int base)
size_t arduino_serial_println_int(int n, int base)
{
return Serial.println(n, base);
}
size_t arduino_serial_println_long(long n, int base)
{
return Serial.println(n, base);
}
size_t arduino_serial_println_unsigned_char(unsigned char n, int base)
{
return Serial.println(n, base);
}
size_t arduino_serial_println_unsigned_int(unsigned int n, int base)
{
return Serial.println(n, base);
}
size_t arduino_serial_println_unsigned_long(unsigned long n, int base)
{
return Serial.println(n, base);
}
void arduino_serial_print_chars(const char *cstr)
{
Serial.print(cstr);
}
size_t arduino_serial_print_chars_progmem(const char *cstr)
{
return Serial.print(reinterpret_cast<const __FlashStringHelper *>(cstr));
}
size_t arduino_serial_print_char(char c)
{
return Serial.print(c);
}
size_t arduino_serial_print_int(int n, int base)
{
return Serial.print(n, base);
}
size_t arduino_serial_print_long(long n, int base)
{
return Serial.println(n, base);
return Serial.print(n, base);
}
size_t arduino_serial_print_unsigned_char(unsigned char n, int base)
{
return Serial.println(n, base);
return Serial.print(n, base);
}
size_t arduino_serial_print_unsigned_int(unsigned int n, int base)
{
return Serial.println(n, base);
return Serial.print(n, base);
}
size_t arduino_serial_print_unsigned_long(unsigned long n, int base)
{
return Serial.println(n, base);
return Serial.print(n, base);
}
}

2
arduboy-rust/Wrapper-Project/src/main.h
View file

@ -27,4 +27,6 @@ ArdVoice ardvoice;
#include "./library/arduino/eeprom_export.h"
#endif
#if defined(Arduino_Serial_Library)
#include "./library/arduino/arduino_serial_export.h"
#endif

528
arduboy-rust/src/serial_print.rs
View file

@ -2,17 +2,395 @@
//!
//! You will need to uncomment the Arduino_Serial_Library in the import_config.h file.
use crate::prelude::Pstring;
use core::ffi::{c_char, c_int, c_long, c_size_t, c_uchar, c_uint, c_ulong};
use core::ffi::{c_char, c_int, c_long, c_size_t, c_uchar, c_uint, c_ulong, CStr};
use crate::print::Base;
extern "C" {
#[link_name = "arduino_serial_begin"]
fn serial_begin(serial: c_ulong);
#[link_name = "arduino_serial_end"]
fn serial_end();
#[link_name = "arduino_serial_available"]
fn serial_available() -> c_int;
#[link_name = "arduino_serial_read"]
fn serial_read() -> c_int;
#[link_name = "arduino_serial_read_string"]
fn serial_read_string() -> CStr;
}
///The Arduino Serial Print class is available for writing text to the screen buffer.
///
///In the same manner as the Arduino arduboy.print(), etc., functions.
///
///
///Example
/// ```
/// let value: i16 = 42;
///
/// serial::print(b"Hello World\n\0"[..]); // Prints "Hello World" and then sets the
/// // text cursor to the start of the next line
/// serial::print(f!(b"Hello World\n")); // Prints "Hello World" but does not use the 2kb ram
/// serial::print(value); // Prints "42"
/// serial::print("\n\0"); // Sets the text cursor to the start of the next line
/// serial::print("hello world") // Prints normal [&str]
/// ```
pub fn print(x: impl Serialprintable) {
x.print()
}
///The Arduino Serial Print class is available for writing text to the screen buffer.
///
///In the same manner as the Arduino arduboy.print(), etc., functions.
///
///
///Example
/// ```
/// let value: i16 = 42;
///
/// serial::print(b"Hello World\n\0"[..]); // Prints "Hello World" and then sets the
/// // text cursor to the start of the next line
/// serial::print(f!(b"Hello World\n")); // Prints "Hello World" but does not use the 2kb ram
/// serial::print(value); // Prints "42"
/// serial::print("\n\0"); // Sets the text cursor to the start of the next line
/// serial::print("hello world") // Prints normal [&str]
/// ```
pub fn println(x: impl Serialprintlnable) {
x.println()
}
/// Sets the data rate in bits per second (baud) for serial data transmission. For communicating with Serial Monitor, make sure to use one of the baud rates listed in the menu at the bottom right corner of its screen. You can, however, specify other rates - for example, to communicate over pins 0 and 1 with a component that requires a particular baud rate.
///
/// ### Example
/// ```
/// serial::begin(9600)
/// ```
pub fn begin(baud_rates: u32) {
unsafe { serial_begin(baud_rates) }
}
/// Disables serial communication, allowing the RX and TX pins to be used for general input and output. To re-enable serial communication, call [begin()].
pub fn end() {
unsafe { serial_end() }
}
/// Reads incoming serial data.
/// Use only inside of [available()]:
/// ```
/// if (Serial::available() > 0) {
/// // read the incoming byte:
/// let incomingByte: i16 = Serial::read();
///
/// // say what you got:
/// Serial::print("I received: ");
/// Serial::println(incomingByte);
/// }
/// ```
/// ### Returns
///
///The first byte of incoming serial data available (or -1 if no data is available). Data type: int.
pub fn read() -> i16 {
unsafe { serial_read() }
}
/// Reads incoming serial data.
///
/// Use only inside of [available()]:
/// ```
/// if (Serial::available() > 0) {
/// // read the incoming byte:
/// let incomingByte: &str = Serial::read_as_utf8_str();
///
/// // say what you got:
/// Serial::print("I received: ");
/// Serial::println(incomingByte);
/// }
/// ```
/// ### Returns
///
///The first byte of incoming serial data available (or -1 if no data is available). Data type: &str.
pub fn read_as_utf8_str() -> &'static str {
let intcoming_byte = unsafe { serial_read() };
static mut L: [u8; 2] = [0, 0];
unsafe {
L[0] = intcoming_byte as u8;
}
unsafe { core::str::from_utf8(&L).unwrap() }
}
/// Get the number of bytes (characters) available for reading from the serial port. This is data that’s already arrived and stored in the serial receive buffer (which holds 64 bytes).
/// ### Example
/// ```
/// if (Serial::available() > 0) {
/// // read the incoming byte:
/// incomingByte = Serial::read();
///
/// // say what you got:
/// Serial::print("I received: ");
/// Serial::println(incomingByte);
/// }
/// ```
pub fn available() -> i16 {
unsafe { serial_available() }
}
pub trait Serialprintlnable
where
Self: Sized,
{
type Parameters;
fn println_2(self, params: Self::Parameters);
fn default_parameters() -> Self::Parameters;
fn println(self) {
self.println_2(Self::default_parameters());
}
}
impl Serialprintlnable for i16 {
type Parameters = Base;
fn println_2(self, params: Self::Parameters) {
unsafe {
println_int(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl Serialprintlnable for u16 {
type Parameters = Base;
fn println_2(self, params: Self::Parameters) {
unsafe {
println_unsigned_int(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl Serialprintlnable for i32 {
type Parameters = Base;
fn println_2(self, params: Self::Parameters) {
unsafe {
println_long(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl Serialprintlnable for u32 {
type Parameters = Base;
fn println_2(self, params: Self::Parameters) {
unsafe {
println_unsigned_long(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl Serialprintlnable for &[u8] {
type Parameters = ();
fn println_2(self, _params: Self::Parameters) {
unsafe {
println_chars(self as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl Serialprintlnable for &str {
type Parameters = ();
fn println_2(self, _params: Self::Parameters) {
unsafe {
println_chars(self.as_bytes() as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl<const N: usize> Serialprintlnable for crate::heapless::String<N> {
type Parameters = ();
fn println_2(self, _params: Self::Parameters) {
unsafe {
println_chars(self.as_bytes() as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl Serialprintlnable for Pstring {
type Parameters = ();
fn println_2(self, _params: Self::Parameters) {
unsafe {
println_chars_progmem(self.pointer);
}
}
fn default_parameters() -> Self::Parameters {}
}
extern "C" {
#[link_name = "arduino_serial_println_chars"]
fn print_chars(cstr: *const c_char);
fn println_chars(cstr: *const c_char);
#[doc(hidden)]
#[link_name = "arduino_serial_println_chars_progmem"]
fn println_chars_progmem(pstring: *const c_char);
// #[link_name = "arduino_serial_println_char"]
// fn println_char(c: c_char) -> c_size_t;
#[doc(hidden)]
#[link_name = "arduino_serial_println_int"]
fn println_int(n: c_int, base: c_int) -> c_size_t;
#[doc(hidden)]
#[link_name = "arduino_serial_println_long"]
fn println_long(n: c_long, base: c_int) -> c_size_t;
#[doc(hidden)]
#[link_name = "arduino_serial_println_unsigned_char"]
fn println_unsigned_char(n: c_uchar, base: c_int) -> c_size_t;
#[doc(hidden)]
#[link_name = "arduino_serial_println_unsigned_int"]
fn println_unsigned_int(n: c_uint, base: c_int) -> c_size_t;
#[doc(hidden)]
#[link_name = "arduino_serial_println_unsigned_long"]
fn println_unsigned_long(n: c_ulong, base: c_int) -> c_size_t;
}
pub trait Serialprintable
where
Self: Sized,
{
type Parameters;
fn print_2(self, params: Self::Parameters);
fn default_parameters() -> Self::Parameters;
fn print(self) {
self.print_2(Self::default_parameters());
}
}
impl Serialprintable for i16 {
type Parameters = Base;
fn print_2(self, params: Self::Parameters) {
unsafe {
print_int(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl Serialprintable for u16 {
type Parameters = Base;
fn print_2(self, params: Self::Parameters) {
unsafe {
print_unsigned_int(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl Serialprintable for i32 {
type Parameters = Base;
fn print_2(self, params: Self::Parameters) {
unsafe {
print_long(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl Serialprintable for u32 {
type Parameters = Base;
fn print_2(self, params: Self::Parameters) {
unsafe {
print_unsigned_long(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl Serialprintable for &[u8] {
type Parameters = ();
fn print_2(self, _params: Self::Parameters) {
unsafe {
print_chars(self as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl Serialprintable for &str {
type Parameters = ();
fn print_2(self, _params: Self::Parameters) {
unsafe {
print_chars(self.as_bytes() as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl<const N: usize> Serialprintable for crate::heapless::String<N> {
type Parameters = ();
fn print_2(self, _params: Self::Parameters) {
unsafe {
print_chars(self.as_bytes() as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl Serialprintable for Pstring {
type Parameters = ();
fn print_2(self, _params: Self::Parameters) {
unsafe {
print_chars_progmem(self.pointer);
}
}
fn default_parameters() -> Self::Parameters {}
}
extern "C" {
#[link_name = "arduino_serial_print_chars"]
fn print_chars(cstr: *const c_char);
#[doc(hidden)]
#[link_name = "arduino_serial_print_chars_progmem"]
fn print_chars_progmem(pstring: *const c_char);
// #[link_name = "arduino_serial_print_char"]
// fn print_char(c: c_char) -> c_size_t;
@ -32,147 +410,3 @@ extern "C" {
#[link_name = "arduino_serial_print_unsigned_long"]
fn print_unsigned_long(n: c_ulong, base: c_int) -> c_size_t;
}
///The Arduino Serial Print class is available for writing text to the screen buffer.
///
///In the same manner as the Arduino arduboy.print(), etc., functions.
///
///
///Example
/// ```
/// let value: i16 = 42;
///
/// serial::print(b"Hello World\n\0"[..]); // Prints "Hello World" and then sets the
/// // text cursor to the start of the next line
/// serial::print(f!(b"Hello World\n")); // Prints "Hello World" but does not use the 2kb ram
/// serial::print(value); // Prints "42"
/// serial::print("\n\0"); // Sets the text cursor to the start of the next line
/// serial::print("hello world") // Prints normal [&str]
/// ```
pub fn print(x: impl SerialPrintable) {
x.print()
}
/// Set the Baud rate for the serial monitor
///
/// ### Example
/// ```
/// serial::begin(9600)
/// ```
pub fn begin(baud_rates: u32) {
unsafe { serial_begin(baud_rates) }
}
pub trait SerialPrintable
where
Self: Sized,
{
type Parameters;
fn print_2(self, params: Self::Parameters);
fn default_parameters() -> Self::Parameters;
fn print(self) {
self.print_2(Self::default_parameters());
}
}
impl SerialPrintable for i16 {
type Parameters = Base;
fn print_2(self, params: Self::Parameters) {
unsafe {
print_int(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl SerialPrintable for u16 {
type Parameters = Base;
fn print_2(self, params: Self::Parameters) {
unsafe {
print_unsigned_int(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl SerialPrintable for i32 {
type Parameters = Base;
fn print_2(self, params: Self::Parameters) {
unsafe {
print_long(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl SerialPrintable for u32 {
type Parameters = Base;
fn print_2(self, params: Self::Parameters) {
unsafe {
print_unsigned_long(self, params as c_int);
}
}
fn default_parameters() -> Self::Parameters {
Base::Dec
}
}
impl SerialPrintable for &[u8] {
type Parameters = ();
fn print_2(self, _params: Self::Parameters) {
unsafe {
print_chars(self as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl SerialPrintable for &str {
type Parameters = ();
fn print_2(self, _params: Self::Parameters) {
unsafe {
print_chars(self.as_bytes() as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl<const N: usize> SerialPrintable for crate::heapless::String<N> {
type Parameters = ();
fn print_2(self, _params: Self::Parameters) {
unsafe {
print_chars(self.as_bytes() as *const [u8] as *const i8);
}
}
fn default_parameters() -> Self::Parameters {}
}
impl SerialPrintable for Pstring {
type Parameters = ();
fn print_2(self, _params: Self::Parameters) {
unsafe {
print_chars_progmem(self.pointer);
}
}
fn default_parameters() -> Self::Parameters {}
}

3
import_config.h
View file

@ -19,4 +19,5 @@
// #define ArduboyTones_Library ;
// #define ArdVoice_Library ;
#define EEPROM_Library ;
#define Arduino_Library ;
#define Arduino_Library ;
// #define Arduino_Serial_Library ;