m95320 1.3.0

Driver for STMicroelectronics M95320 32-Kbit serial SPI bus EEPROM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

/// These tests use a Raspberry Pi connected to the memory chip
/// and the `rppal` raspeberry pi embedded-hal library

use rppal::gpio::Gpio;
use rppal::spi::{Bus, Mode, SlaveSelect, Spi};

use m95320::prelude::*;
use m95320::m95320::Flash;
use port_expander::{ Pca9555 };
use std::collections::HashMap;

use rppal::i2c::I2c;

const GPIO_MEMORY_CHIP_SELECT: u8 = 27;

#[cfg(test)]
mod tests {
    use m95320::m95320::Status;

    use super::*;

    #[test]
    fn test() {
        let gpio = Gpio::new().unwrap();
        let cs = gpio.get(GPIO_MEMORY_CHIP_SELECT).unwrap().into_output();
        let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, 10_000_000, Mode::Mode0).unwrap();

        let mut flash = Flash::init(spi, cs).unwrap();

        let _status = flash.read_status().expect("get status");

        let mut page_buffer: [u8; 32] = [0x0; 32];

        flash.erase_sectors(0, 2).expect("erase");


        flash.read(0, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

        flash.read(5, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

        flash.read(32, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

        let hello = String::from("hello memory!");
        for (i, byte) in hello.as_bytes().into_iter().enumerate() {
            page_buffer[i] = byte.clone();
        }

        flash.write_bytes(0, &mut page_buffer).expect("write");
        flash.read(0, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [104, 101, 108, 108, 111, 32, 109, 101, 109, 111, 114, 121, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "simple write and read of first page");

        let mut page_buffer: [u8; 32] = [0x0; 32];
        for (i, byte) in hello.as_bytes().into_iter().enumerate() {
            page_buffer[i] = byte.clone();
        } 

        flash.write_bytes(30, &mut page_buffer).expect("write");
        flash.read(0, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [104, 101, 108, 108, 111, 32, 109, 101, 109, 111, 114, 121, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 104, 101], "write at address straddling page 0 and page 1, read page 1");

        flash.read(32, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [108, 108, 111, 32, 109, 101, 109, 111, 114, 121, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "write at address straddling page 0 and page 1, read page 2");

        flash.read(5, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [32, 109, 101, 109, 111, 114, 121, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 104, 101, 108, 108, 111, 32, 109], "read straddling page boundary");
    
        let chuckwudi = String::from("chuckwudi");
        let mut small_buffer: [u8; 9] = [0x0; 9];
        for (i, byte) in chuckwudi.as_bytes().into_iter().enumerate() {
            small_buffer[i] = byte.clone();
        }
        flash.write_bytes(0, &mut small_buffer).expect("write");
        flash.read(0, &mut small_buffer).expect("read");
        assert_eq!(small_buffer, [0x63, 0x68, 0x75, 0x63, 0x6b, 0x77, 0x75, 0x64, 0x69], "write and read a buffer smaller than a page");

        flash.read(1, &mut small_buffer).expect("read");
        assert_eq!(small_buffer, [0x68, 0x75, 0x63, 0x6b, 0x77, 0x75, 0x64, 0x69, 111], "write and read a buffer smaller than a page, offset 1");


        let mut small_buffer: [u8; 9] = [0x0; 9];
        for (i, byte) in chuckwudi.as_bytes().into_iter().enumerate() {
            small_buffer[i] = byte.clone();
        }
        flash.write_bytes(30, &mut small_buffer).expect("write");
        flash.read(30, &mut small_buffer).expect("read");
        assert_eq!(small_buffer, [0x63, 0x68, 0x75, 0x63, 0x6b, 0x77, 0x75, 0x64, 0x69], "write and read a buffer smaller than a page at page boundary");  
    
        // test Write Enable Latch
        let status = flash.read_status().expect("get status");
        assert_eq!(status.bits(), 0x0, "status starts clear");

        flash._write_enable().expect("set write enable latch");
        
        let status = flash.read_status().expect("get status");
        assert_eq!(status, Status::WRITE_ENABLE_LATCH, "write enable latch flag is set");

        flash._write_disable().expect("unset write enable latch");

        let status = flash.read_status().expect("get status");
        assert_eq!(status.bits(), 0x0, "write enable latch flag is not set");
    }

    #[test]
    fn testWyldcard() {

        // wyldcard prototype plinth setup
        ///////////////////////////////////////////////
        let i2c = I2c::new().unwrap();
        let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, 10_000_000, Mode::Mode0).unwrap();

        let expander_address = (false, false, false);
        let mut expander = Pca9555::new(i2c, expander_address.0, expander_address.1, expander_address.2);
        let virtual_gpios = expander.split();

        let memory_chip_select = virtual_gpios.io0_7.into_output().expect("");

        let mut flash = Flash::init(
                    spi,
                    memory_chip_select,
                  ).expect("memory");

        ////////////////////////////////////////////////

        let _status = flash.read_status().expect("get status");

        let mut page_buffer: [u8; 32] = [0x0; 32];

        flash.erase_sectors(0, 2).expect("erase");


        flash.read(0, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

        flash.read(5, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

        flash.read(32, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

        let hello = String::from("hello memory!");
        for (i, byte) in hello.as_bytes().into_iter().enumerate() {
            page_buffer[i] = byte.clone();
        }

        flash.write_bytes(0, &mut page_buffer).expect("write");
        flash.read(0, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [104, 101, 108, 108, 111, 32, 109, 101, 109, 111, 114, 121, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "simple write and read of first page");

        let mut page_buffer: [u8; 32] = [0x0; 32];
        for (i, byte) in hello.as_bytes().into_iter().enumerate() {
            page_buffer[i] = byte.clone();
        } 

        flash.write_bytes(30, &mut page_buffer).expect("write");
        flash.read(0, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [104, 101, 108, 108, 111, 32, 109, 101, 109, 111, 114, 121, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 104, 101], "write at address straddling page 0 and page 1, read page 1");

        flash.read(32, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [108, 108, 111, 32, 109, 101, 109, 111, 114, 121, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "write at address straddling page 0 and page 1, read page 2");

        flash.read(5, &mut page_buffer).expect("read");
        assert_eq!(page_buffer, [32, 109, 101, 109, 111, 114, 121, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 104, 101, 108, 108, 111, 32, 109], "read straddling page boundary");
    
        
        let chuckwudi = String::from("chuckwudi");
        let mut small_buffer: [u8; 9] = [0x0; 9];
        for (i, byte) in chuckwudi.as_bytes().into_iter().enumerate() {
            small_buffer[i] = byte.clone();
        }
        flash.write_bytes(0, &mut small_buffer).expect("write");
        flash.read(0, &mut small_buffer).expect("read");
        assert_eq!(small_buffer, [0x63, 0x68, 0x75, 0x63, 0x6b, 0x77, 0x75, 0x64, 0x69], "write and read a buffer smaller than a page");

        flash.read(1, &mut small_buffer).expect("read");
        assert_eq!(small_buffer, [0x68, 0x75, 0x63, 0x6b, 0x77, 0x75, 0x64, 0x69, 111], "write and read a buffer smaller than a page, offset 1");


        let mut small_buffer: [u8; 9] = [0x0; 9];
        for (i, byte) in chuckwudi.as_bytes().into_iter().enumerate() {
            small_buffer[i] = byte.clone();
        }
        flash.write_bytes(30, &mut small_buffer).expect("write");
        flash.read(30, &mut small_buffer).expect("read");
        assert_eq!(small_buffer, [0x63, 0x68, 0x75, 0x63, 0x6b, 0x77, 0x75, 0x64, 0x69], "write and read a buffer smaller than a page at page boundary");

    }
}