max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Arbitration lost test is working. Still some test failing

Browse Source
This commit is contained in:
anton smeenk
2023-10-27 14:54:06 +02:00
parent 70a64e8dcb
commit ce066e92e7
5 changed files with 417 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
examples/stm32g0/src/bin/i2c_slave.rs
View File

@ -72,7 +72,7 @@ impl fmt::Write for SerialWriter {
#[embassy_executor::main]
async fn main(spawner: Spawner) {
let p = embassy_stm32::init(Default::default());
let mut led = Output::new(p.PA5, Level::High, Speed::Low);
let led = Output::new(p.PA5, Level::High, Speed::Low);
/*
let uart = usart::Uart::new(
@ -107,15 +107,15 @@ async fn main(spawner: Spawner) {
.unwrap();
let mut config = i2c::Config::default();
config.slave_address_7bits(0x4);
config.slave_address_7bits(0x10); // for arbitration lost test
config.slave_address_2(0x41, vals::Oamsk::MASK4);
writeln!(&mut writer, "After config:\r",).unwrap();
let mut i2c = I2c::new(p.I2C1, p.PB8, p.PB9, Irqs, NoDma, NoDma, Hertz(100_000), config);
writeln!(&mut writer, "After i2c init\r").unwrap();
let i2c = I2c::new(p.I2C1, p.PB8, p.PB9, Irqs, NoDma, NoDma, Hertz(100_000), config);
let mut buf_64 = [0; 64]; // buffer is longer than master will send: wait for STOP condition
let mut buf_20 = [0; 20]; // buffer is shorter than master will send: wait for STOP condition
let mut buf_20a = [0; 20];
let mut buf_2 = [0; 2];
let mut errors = 0;
let mut address = 0;
let mut dir = vals::Dir::READ;
@ -131,19 +131,26 @@ async fn main(spawner: Spawner) {
counter += 1;
writeln!(&mut writer, "Loop: {}\r", counter).unwrap();
// clear master write buffers for sure
_ = i2c.slave_read_buffer(&mut buf_64, i2c::AddressType::Address2);
_ = i2c.slave_read_buffer(&mut buf_64, i2c::AddressType::Address1);
for i in 0..buf_20.len() {
buf_20[i] = 0x20 + (i as u8)
}
for i in 0..buf_20a.len() {
buf_20a[i] = 0x40 - (i as u8)
}
for i in 0..buf_64.len() {
buf_64[i] = 0x60 + (i as u8)
}
// content for test 0x10
buf_2[0] = 0xFF;
buf_2[1] = 0x04;
_ = i2c.slave_write_buffer(&mut buf_2, i2c::AddressType::Address1);
writeln!(&mut writer, "Waiting for master activity\r").unwrap();
// clear write buffers for sure
_ = i2c.slave_read_buffer(&mut buf_64, i2c::AddressType::GenericAddress);
_ = i2c.slave_read_buffer(&mut buf_64, i2c::AddressType::MainAddress);
let (address, dir, size, result) = i2c.slave_transaction().await;
writeln!(
&mut writer,
@ -152,30 +159,85 @@ async fn main(spawner: Spawner) {
)
.unwrap();
tcount += 1;
// preparations for the next round
match address {
0x42 => {
// prepare for test 0x44: master write read. 20a is send to the master
_ = i2c.slave_write_buffer(&mut buf_20a, i2c::AddressType::Address2);
i2c.slave_sbc(false);
}
0x43 => {
// prepare for test 0x44: master write read. 20a is send to the master
_ = i2c.slave_write_buffer(&mut buf_20a, i2c::AddressType::Address2);
i2c.slave_sbc(false);
}
0x44 => {
// prepare for test 0x48: slave does have no buffer to read
i2c.slave_reset_buffer(i2c::AddressType::Address2);
}
0x48 => {
// 0x48 master read slave write slave did not yet prepare a buffer, master will fail
// prepare buffer for test 0x49
for i in 0..buf_20.len() {
buf_20[i] = 0x48 + (i as u8)
}
_ = i2c.slave_write_buffer(&buf_20, i2c::AddressType::Address2);
}
0x49 => {
// prepare buffer for test 0x4A
for i in 0..buf_20.len() {
buf_20[i] = 0x49 + (i as u8)
}
match i2c.slave_write_buffer(&buf_20, i2c::AddressType::Address2) {
Err(_) => writeln!(&mut writer, "Buffer error\r").unwrap(),
_ => (),
}
}
0x4A => {
// prepare buffer for test 0x4B
for i in 0..buf_64.len() {
buf_64[i] = 0x4A + (i as u8)
}
match i2c.slave_write_buffer(&buf_64, i2c::AddressType::Address2) {
Err(_) => writeln!(&mut writer, "Buffer error\r").unwrap(),
_ => (),
}
}
0x4B => {
// prepare for test 0x4F
let result: [u8; 2] = [tcount, errors];
_ = i2c.slave_write_buffer(&result, i2c::AddressType::Address2);
}
_ => (),
}
match address {
0x41 => {
writeln!(&mut writer, "Evaluate test 0x41.\r\n").unwrap();
writeln!(&mut writer, "Evaluate test 0x41: Good case master write 20 bytes\r").unwrap();
checkIsWrite!(writer, dir);
_ = i2c.slave_read_buffer(&mut buf_20, i2c::AddressType::GenericAddress);
_ = i2c.slave_read_buffer(&mut buf_20, i2c::AddressType::Address2);
match result {
None => {
writeln!(&mut writer, "Test 0x41 passed\r\n").unwrap();
writeln!(&mut writer, "Test 0x41 passed\r").unwrap();
print_buffer(&mut writer, &buf_20);
}
Some(err) => {
errors += 1;
writeln!(&mut writer, "Test 0x41 failed. Error: {:?}\r\n", err).unwrap()
writeln!(&mut writer, "Test 0x41 failed. Error: {:?}\r", err).unwrap()
}
};
}
0x42 => {
writeln!(&mut writer, "Evaluate test 0x42.\r\n").unwrap();
writeln!(
&mut writer,
"Evaluate test 0x42: edge case master write exact 64 bytes: must succeed on master and slave\r"
)
.unwrap();
checkIsWrite!(writer, dir);
_ = i2c.slave_read_buffer(&mut buf_64, i2c::AddressType::GenericAddress);
_ = i2c.slave_read_buffer(&mut buf_64, i2c::AddressType::Address2);
match result {
None => {
writeln!(&mut writer, "Test 0x42 passed. send 64 bytes\r\n").unwrap();
writeln!(&mut writer, "Test 0x42 passed. send 64 bytes\r").unwrap();
print_buffer(&mut writer, &buf_64);
}
Some(err) => {
@ -185,9 +247,9 @@ async fn main(spawner: Spawner) {
};
}
0x43 => {
writeln!(&mut writer, "Evaluate test 0x43.\r\n").unwrap();
writeln!(&mut writer, "Evaluate test 0x43.edge case master write exact 65 bytes: 1 too many must fail on master and slave\r").unwrap();
checkIsWrite!(writer, dir);
_ = i2c.slave_read_buffer(&mut buf_64, i2c::AddressType::GenericAddress);
_ = i2c.slave_read_buffer(&mut buf_64, i2c::AddressType::Address2);
match result {
None => {
errors += 1;
@ -201,9 +263,32 @@ async fn main(spawner: Spawner) {
.unwrap(),
};
}
0x44 => {
writeln!(
&mut writer,
"Evaluate test 0x44: master write read combined transaction write 20 bytes, then read 20 bytes \r"
)
.unwrap();
checkIsRead!(writer, dir);
_ = i2c.slave_read_buffer(&mut buf_20, i2c::AddressType::Address2);
match result {
None => {
writeln!(&mut writer, "Test 0x44 passed\r").unwrap();
print_buffer(&mut writer, &buf_20)
}
Some(err) => {
errors += 1;
writeln!(&mut writer, "Test 0x44 failed. Error:{:?}\r", err).unwrap()
}
};
}
0x48 => {
// 0x48 master read slave write slave did not yet prepare a buffer, master will fail
writeln!(&mut writer, "Evaluate test 0x48.\r\n").unwrap();
writeln!(
&mut writer,
"Evaluate test 0x48. master read. Slave did not prepare a buffer (buffer empty) and will NACK\r"
)
.unwrap();
checkIsRead!(writer, dir);
match result {
None => {
@ -212,16 +297,9 @@ async fn main(spawner: Spawner) {
}
Some(err) => writeln!(&mut writer, "Test 0x48 passed. Got expected error: {:?}\r", err).unwrap(),
};
// prepare buffer for test 0x49
_ = i2c.slave_write_buffer(&buf_20, i2c::AddressType::GenericAddress);
}
0x49 => {
// prepare buffer for test 0x4A
for i in 0..buf_20.len() {
buf_20[i] = 0x50 + (i as u8)
}
_ = i2c.slave_write_buffer(&buf_20, i2c::AddressType::GenericAddress);
writeln!(&mut writer, "Evaluate test 0x49\r\n").unwrap();
writeln!(&mut writer, "Evaluate test 0x49. master read 20 bytes good case.\r").unwrap();
checkIsRead!(writer, dir);
match result {
None => {
@ -232,33 +310,22 @@ async fn main(spawner: Spawner) {
writeln!(&mut writer, "Test 0x49 failed. Error: {:?}\r", err).unwrap()
}
};
// prepare buffer for test 0x4A
_ = i2c.slave_write_buffer(&buf_20, i2c::AddressType::GenericAddress);
}
0x4A => {
// 0x4A master read slave write bad case: master expects 64 does slave does prepare 20 characters
// prepare buffer for test 0x4B
for i in 0..buf_64.len() {
buf_64[i] = 0x40 + (i as u8)
}
_ = i2c.slave_write_buffer(&buf_64, i2c::AddressType::GenericAddress);
writeln!(&mut writer, "Evaluate test 0x4A.\r\n").unwrap();
writeln!(&mut writer, "Evaluate test 0x4A.master read 64 bytes, but the slave did prepair only 20 Should fail with NACK\r").unwrap();
checkIsRead!(writer, dir);
match result {
None => {
errors += 1;
writeln!(&mut writer, "Test 0x4A failed . Expected an error").unwrap();
}
Some(err) => {
errors += 1;
writeln!(&mut writer, "Test 0x4A passed. Expected error: {:?}\r", err).unwrap()
}
Some(err) => writeln!(&mut writer, "Test 0x4A passed. Expected error: {:?}\r", err).unwrap(),
}
_ = i2c.slave_write_buffer(&buf_20, i2c::AddressType::GenericAddress);
}
0x4B => {
// Master-read-slave-write Master expects 64 bytes, Should be ok
writeln!(&mut writer, "Evaluate test 0x4B. .\r\n").unwrap();
writeln!(&mut writer, "Evaluate test 0x4B. Master read 64 bytes good case.\r").unwrap();
checkIsRead!(writer, dir);
match result {
None => {
@ -269,14 +336,11 @@ async fn main(spawner: Spawner) {
writeln!(&mut writer, "Test 0x4B failed. Error: {:?}\r", err).unwrap()
}
};
// prepare for test 0x4F
let result: [u8; 2] = [tcount, errors];
_ = i2c.slave_write_buffer(&result, i2c::AddressType::GenericAddress);
}
0x4F => {
// Master-read-slave-write 2 bytes with test summary Should be ok.
checkIsRead!(writer, dir);
writeln!(&mut writer, "Evaluate test 0x4F.\r\n").unwrap();
writeln!(&mut writer, "Evaluate test 0x4F. Send test summary\r").unwrap();
match result {
None => {
writeln!(&mut writer, "Test 0x4F Result send to master\r").unwrap();
@ -296,6 +360,30 @@ async fn main(spawner: Spawner) {
tcount = 0;
errors = 0;
}
0x10 => {
// Arbitration lost test Master does read 2 bytes on address 0x10
// this slave will send 0xFF04, the other slave will send 0xFF03
// This slave should generate a arbitration lost if the other slave is online
writeln!(&mut writer, "Evaluate test 0x10: slave arbitration lost.\r").unwrap();
checkIsRead!(writer, dir);
match result {
None => {
writeln!(&mut writer, "Test 0x10 should fail if a second slave with testcase i2c_salve_arbitration.rs is connected.\r").unwrap();
errors += 1;
}
Some(err) => writeln!(&mut writer, "Test 0x10 passed. Error: {:?}\r", err).unwrap(),
};
writeln!(
&mut writer,
"Test finished. nr tests/nr errors: {}/{}!\r",
tcount, errors
)
.unwrap();
writeln!(&mut writer, "-----\r").unwrap();
tcount = 0;
errors = 0;
}
_ => (),
}
}
@ -303,6 +391,6 @@ async fn main(spawner: Spawner) {
for i in 0..buf.len() {
write!(writer, " {:2x} ", buf[i]).unwrap();
}
writeln!(writer, "\n\r").unwrap()
writeln!(writer, "\r").unwrap()
}
}