tasosxak@tasosxak:~/Documents/RustProjects/frtos$ cargo +nightly build
   Compiling freertos_rs v0.2.0
error[E0432]: unresolved import `alloc::arc`
  --> /home/tasosxak/.cargo/registry/src/github.com-1ecc6299db9ec823/freertos_rs-0.2.0/src/prelude/no_std.rs:17:16
   |
17 | pub use alloc::arc::{Arc, Weak};
   |                ^^^ could not find `arc` in `alloc`

error[E0207]: the type parameter `O` is not constrained by the impl trait, self type, or predicates
   --> /home/tasosxak/.cargo/registry/src/github.com-1ecc6299db9ec823/freertos_rs-0.2.0/src/patterns/processor.rs:164:9
    |
164 | impl<I, O> ProcessorClient<I, SharedClientWithReplyQueue<O>> where I: ReplyableMessage + Copy, O: Copy {
    |         ^ unconstrained type parameter

error[E0207]: the type parameter `O` is not constrained by the impl trait, self type, or predicates
   --> /home/tasosxak/.cargo/registry/src/github.com-1ecc6299db9ec823/freertos_rs-0.2.0/src/patterns/processor.rs:175:9
    |
175 | impl<I, O> ProcessorClient<InputMessage<I>, SharedClientWithReplyQueue<O>> where I: Copy, O: Copy {
    |         ^ unconstrained type parameter

error: aborting due to 3 previous errors

Some errors occurred: E0207, E0432.
For more information about an error, try `rustc --explain E0207`.
error: Could not compile `freertos_rs`.

To learn more, run the command again with --verbose.

main.rs

extern crate freertos_rs;

use freertos_rs::*;
use prelude::v1::*;

#[no_mangle]
pub extern fn main_entry() {
    let mut s = Serial::new();
    s.tx_string("Hello from Rust!\n");
    loop {
        let data = s.rx_i32();
        s.tx_string("Received: ");
        s.tx_i32(data);
        s.tx_string("\n");
    }
}

Rust version:

tasosxak@tasosxak:~/Documents/RustProjects/frtos$ rustup default nightly
info: using existing install for 'nightly-x86_64-unknown-linux-gnu'
info: default toolchain set to 'nightly-x86_64-unknown-linux-gnu'

  nightly-x86_64-unknown-linux-gnu unchanged - rustc 1.35.0-nightly (26b4cb484 2019-03-09)

.cargo/config

[target.thumbv7em-none-eabi]

[target.'cfg(all(target_arch = "arm", target_os = "none"))']
runner = "gdb-multiarch -q -x openocd.gdb"


rustflags = [
  "-C", "link-arg=-Tlink.x",
]

[build]
target = "thumbv7em-none-eabi"   # Cortex-M4 and Cortex-M7 (no FPU)

Hello,

Thank you for such good crate. I tried version 0.1.0 from crates.io, basically all fine, but there is issue with Duration::ms(). As I see you made some fixes/modification since 0.1.0, would you like to publish new version to crates.io ?

Thanks in advance.

Is it possible to pass huge struct through queue without copying whole struct?

It seems that freertos.rs makes copying of item in Queue::send() (though it possibly be removed by optimizations), then FreeRTOS' xQueueSend also does copy.

Box<T> could be used for this purpose but as I see, Box doesn't implement Copy trait that required by Queue.

I assume this is due to changes in the latest Rust version. Also happens to me using rustc 1.28.0and rustc 1.30.0-nightly

error[E0207]: the type parameter `O` is not constrained by the impl trait, self type, or predicates
   --> src/patterns/processor.rs:164:9
    |
164 | impl<I, O> ProcessorClient<I, SharedClientWithReplyQueue<O>> where I: ReplyableMessage + Copy, O: Copy {
    |         ^ unconstrained type parameter
error[E0207]: the type parameter `O` is not constrained by the impl trait, self type, or predicates
   --> src/patterns/processor.rs:175:9
    |
175 | impl<I, O> ProcessorClient<InputMessage<I>, SharedClientWithReplyQueue<O>> where I: Copy, O: Copy {
    |         ^ unconstrained type parameter

Possible sources of this bug:

• FreeRTOS.rs's implementation of the Task spawning and boxing
• Memory allocation glue used by Rust/FreeRTOS (specifically, the alignment is ignored!)

The changes made in #20 allow this to successfully compile. Can you push it to crates.io? Additionally, #![feature(alloc)] can be removed, as alloc is now stable.

Once again, after the latest updates for nightly Rust, the current master is broken. I can't replicate the Travis build failure on my local machine.

https://travis-ci.org/hashmismatch/freertos.rs/builds/485077268

cc @ilya-epifanov

A small type detected by compiling with warnings

// from shim.rs
extern {
	// ...
	pub fn freertos_rs_queue_delete(queue: FreeRtosQueueHandle);
	// ...

And in C code:

// queue.c
void vQueueDelete( QueueHandle_t xQueue )
// shim.c
void freertos_rs_queue_delete(UBaseType_t queue)

There are also a few minor problems:

• uint8_t is used and passed as char * when transforming string (strict aliasing violation) (freertos_rs_spawn_task and freertos_rs_timer_create)
• freertos_rs_queue_send_isr have unused variable ret.

I can send a pull request for them later today but they should be easy enough to fix

/tmp//libkvm.a(freertos_rs-4d6cd4cda3cfed3d.freertos_rs0.rcgu.o): In function `freertos_rs::task::Task::get_stack_high_water_mark::h2ebc848c0d006b62':
/home/mpiechotka/.cargo/registry/src/github.com-1ecc6299db9ec823/freertos_rs-0.2.0/src/task.rs:257: undefined reference to `freertos_rs_get_stack_high_water_mark'
/tmp//libkvm.a(freertos_rs-4d6cd4cda3cfed3d.freertos_rs0.rcgu.o): In function `freertos_rs::task::CurrentTask::get_stack_high_water_mark::ha19f8026cb3c6f12':
/home/mpiechotka/.cargo/registry/src/github.com-1ecc6299db9ec823/freertos_rs-0.2.0/src/task.rs:275: undefined reference to `freertos_rs_get_stack_high_water_mark'

freertos_rs_get_stack_high_water_mark is not compiled as INCLUDE_uxTaskGetStackHighWaterMark is not equal to 1.

Hi,

Unfortunately currently I tied to certain version of rustc. In this version collections crate is not deprecated yet. I added feature that allows to use such old rustc versions.

Pulled this for some work on an RTL8710, looks like it doesn't compile anymore on nightly because collections has been merged into alloc. I've got it compiling on my own fork making some small changes here and there but not sure about any implications of what i've been doing.

Added delete method in Task so that users could delete a task after it was created.

Double delete can not happen, because once a task was terminated its main function will never return.

Right now Queue requires that all elements needs to be Copy. This seems correct, because xQueueSend will copy a predetermined bytes from *pvItemToQueue to the queue.

However, let's consider a type that is not Copy. Vec can be cheaply moved because it only contains ptr, capacity and length, but it is not Copy.

I believe that here we only need to require the item to be Unpin to guarantee that they can be freely moved.

Certain functions in ESP-IDR (for example uart_driver_install ) asks for an uninitialized Queue pointer. This creates an additional method in Queue to creates an uninitialized queue so that they could be initialized by something else.

It seems the Cortex-M0 doesn't have LDREX and STREX opcodes, so atomics are not implemented, so std::sync is not compiled into the alloc crate.

Either we should use our own implementation of Arc (using disabling interrupts or using the FreeRTOS critical sections), or figure out some way to avoid using them (at least) on platforms without atomic support

This is an FYI, that I just created a crate that compiles the FreeRTOS C code and creates the rust bindings for it: https://github.com/axos88/libfreertos-sys.

It's uncomplete, but it might help people get started.