Anyleaf

For use with the Anyleaf pH sensor

For use with embedded systems, and single-board computers.

Example for Rasperry Pi, or other Linux systems:

Cargo.toml: ```toml [package] name = "anyleaflinuxexample" version = "0.1.0" authors = ["Anyleaf david.alan.oconnor@gmail.com"] edition = "2018"

See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies] embedded-hal = "^0.2.3" linux-embedded-hal = "^0.3.0" anyleaf = "^0.1.0" ```

main.rs: ```rust use embeddedhal::blocking::delay::DelayMs; use linuxembedded_hal::{Delay, I2cdev}; use anyleaf::{PhSensor, CalPt, CalSlot};

fn main() { let i2c = I2cdev::new("/dev/i2c-1").unwrap();

let mut ph_sensor = PhSensor::new(i2c);

// 2 or 3 pt calibration both give acceptable results.
// Calibrate with known values
ph_sensor.calibrate_all(
    CalPt::new(0., 7., 25.), CalPt::new(-0.18, 4., 25.), Some(CalPt::new(0.18, 10., 25.))
);

// Or, call these with the sensor in the appropriate buffer solution.
// ph_sensor.calibrate(CalSlot::One, 7.);
// ph_sensor.calibrate(CalSlot::Two, 4.);

// Ideally, store the calibration parameters somewhere, so they persist
// between program runs.

let mut delay = Delay {};

loop {
    let pH = ph_sensor.read().unwrap();
    println!("pH: {}", pH);

    delay.delay_ms(500_u16);
}

} ```

Example for Stm32F3:

Cargo.toml: ```toml [package] name = "anyleafstm32example" version = "0.1.0" authors = ["Anyleaf david.alan.oconnor@gmail.com"] edition = "2018"

See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies] cortex-m = "^0.6.2" cortex-m-rt = "^0.6.12" embedded-hal = "^0.2.3" stm32f3xx-hal = { version = "^0.4.3", features=["stm32f303xc", "rt"] } anyleaf = {version = "^0.0.1"} ```

main.rs: ```rust

![no_main]

![no_std]

//pub use cortexm::{self, asm, iprint, iprintln, peripheral::{itm::Stim, ITM}}; use embeddedhal::blocking::delay::DelayMs; use cortextm::Peripherals; use cortexmsemihosting::hprintln; use cortexmrt::entry; //use core::fmt::{Debug, Write}; use stm32f3xxhal as hal; use hal::{prelude::*, delay::Delay, i2c::I2c, stm32}; use anyleaf::{PhSensor, CalPt};

//use panic_itm; // panic handler

//type Sensor:

[entry]

fn main() -> ! { // Set up i2C. let mut cp = Peripherals::take().unwrap(); let dp = stm32::Peripherals::take().unwrap();

let mut rcc = dp.RCC.constrain();
let clocks = rcc.cfgr.freeze(&mut flash.acr);

let mut gpiob = dp.GPIOB.split(&mut rcc.ahb); // PB GPIO pins
let scl = gpiob.pb6.into_af4(&mut gpiob.moder, &mut gpiob.afrl);
let sda = gpiob.pb7.into_af4(&mut gpiob.moder, &mut gpiob.afrl);

let i2c = I2c::i2c1(dp.I2C1, (scl, sda), 100.khz(), clocks, &mut rcc.apb1);

let mut ph_sensor = anyleaf_ph::PhSensor::new(i2c);

// 2 or 3 pt calibration both give acceptable results.
// Calibrate with known values
ph_sensor.calibrate_all(
    CalPt::new(0., 7., 25.), CalPt::new(-0.18, 4., 25.), Some(CalPt::new(0.18, 10., 25.))
);

// Or, call these with the sensor in the appropriate buffer solution.
// ph_sensor.calibrate(CalSlot::One, 7.);
// ph_sensor.calibrate(CalSlot::Two, 4.);

// Ideally, store the calibration parameters somewhere, so they persist
// between program runs.

let mut delay = Delay::new(cp.SYST, clocks);

loop {
    let pH = ph_sensor.read().unwrap();
    hprintln!("pH: {}", pH);

    delay.delay_ms(500_u16);
}

} ```