ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #32 from ARMmbed/Readme_update 

Update Readme
pull/7774/head
Deepika 2017-08-03 13:01:24 -05:00 committed by GitHub
parent 5abee1e078 fcd2f3db51
commit 2d247581c6
1 changed files with 195 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

551
README.md
View File

@ -5,32 +5,32 @@ Simon Hughes
20170329 20170329
Version 1.00 Version 0.1.1
# Executive Summary # Executive Summary
The purpose of this document is to describe how to use the mbed OS SDCard The purpose of this document is to describe how to use the mbed OS SDCard
driver (sd-driver) so applications can read/write driver (sd-driver) so applications can read/write
data to flash storage cards using the standard POSIX File API data to flash storage cards using the standard POSIX File API
programming interface. The sd-driver uses the SDCard SPI-mode of operation programming interface. The sd-driver uses the SDCard SPI-mode of operation
which is a subset of possible SDCard functionality. which is a subset of possible SDCard functionality.
This repository contains the mbed-os SDCard driver for generic SPI This repository contains the mbed-os SDCard driver for generic SPI
SDCard support and other resources, as outlined below: SDCard support and other resources, as outlined below:
- `SDBlockDevice.h` and `SDBlockDevice.cpp`. This is the SDCard driver module presenting - `SDBlockDevice.h` and `SDBlockDevice.cpp`. This is the SDCard driver module presenting
a Block Device API (derived from BlockDevice) to the underlying SDCard. a Block Device API (derived from BlockDevice) to the underlying SDCard.
- POSIX File API test cases for testing the FAT32 filesystem on SDCard. - POSIX File API test cases for testing the FAT32 filesystem on SDCard.
- basic.cpp, a basic set of functional test cases. - basic.cpp, a basic set of functional test cases.
- fopen.cpp, more functional tests reading/writing greater volumes of data to SDCard, for example. - fopen.cpp, more functional tests reading/writing greater volumes of data to SDCard, for example.
- `mbed_app.json` mbed-os application configuration file with SPI pin configurations for the CI shield and overrides for specific targets. - `mbed_lib.json` mbed-os application configuration file with SPI pin configurations for the CI shield and overrides for specific targets.
This file allows the SPI pins to be specified for the target without having to edit the implementation files. This file allows the SPI pins to be specified for the target without having to edit the implementation files.
- This README which includes [Summary of POSIX File API Documentation](#summary-posix-api-documentation) - This README which includes [Summary of POSIX File API Documentation](#summary-posix-api-documentation)
including detailed instruction on how to use the FAT filesystem and SDBlockDevice driver. including detailed instruction on how to use the FAT filesystem and SDBlockDevice driver.
The SDCard driver is maintained in this repository as a component separate from the main mbed OS repository. The SDCard driver is maintained in this repository as a component separate from the main mbed OS repository.
Hence the 2 repositories (mbed-os and sd-driver) have to be used together Hence the 2 repositories (mbed-os and sd-driver) have to be used together
to deliver the FAT32 Filesystem/SDCard support. This document explains how to do this. to deliver the FAT32 Filesystem/SDCard support. This document explains how to do this.
@ -39,59 +39,62 @@ to deliver the FAT32 Filesystem/SDCard support. This document explains how to do
### Overview ### Overview
The scope of this document is to describe how applications use the FAT filesystem and sd-driver The scope of this document is to describe how applications use the FAT filesystem and sd-driver
components to persistently store data on SDCards. The document is intended to help developers adopt the components to persistently store data on SDCards. The document is intended to help developers adopt the
mbed OS POSIX File API support, and in particular to help explain: mbed OS POSIX File API support, and in particular to help explain:
- How the software components work together to deliver the storage functionality. - How the software components work together to deliver the storage functionality.
- How to work with the sd-driver and mbed OS to build the examples. The example code can easily - How to work with the sd-driver and mbed OS to build the examples. The example code can easily
be copied into your new application code. be copied into your new application code.
- How to work with the CI Test Shield, which adds an SDCard slot to those targets that do not have already have one. - How to work with the CI Test Shield, which adds an SDCard slot to those targets that do not have already have one.
- How to run the POSIX File API mbed Greentea test cases, which provide further example code of how to use - How to run the POSIX File API mbed Greentea test cases, which provide further example code of how to use
the POSIX File API. the POSIX File API.
Section 1 provides an Executive Summary, describing the purpose of the sd-driver, the supporting Section 1 provides an Executive Summary, describing the purpose of the sd-driver, the supporting
software, examples, test cases and documentation. software, examples, test cases and documentation.
Section 2 provides an an overview of the material covered including descriptions of the major sections. Section 2 provides an an overview of the material covered including descriptions of the major sections.
Section 3 provides an overview of the mbed OS filesystem software components, Section 3 provides an overview of the mbed OS filesystem software components,
including the inter-relationships between the application, POSIX file API, the standard c-library, including the inter-relationships between the application, POSIX file API, the standard c-library,
the mbed OS filesystem and the SDCard driver (sd-driver). the mbed OS filesystem and the SDCard driver (sd-driver).
Section 4 describes how to build and run an example application for reading Section 4 describes how to build and run an example application for reading
and writing data to an SDCard using the POSIX File API. The example begins by describing and writing data to an SDCard using the POSIX File API. The example begins by describing
the procedure for building and testing on the K64F target. The final sub-sections the procedure for building and testing on the K64F target. The final sub-sections
describe how to use the test shield to add an SDCard slot to any mbed target, describe how to use the test shield to add an SDCard slot to any mbed target,
and hence enable the persistent storage of data on any supported target. and hence enable the persistent storage of data on any supported target.
Section 5 describes an example application which uses the raw Section 5 describes an example application which uses the raw
BlockDevice API to read and write data to the SDCard. BlockDevice API to read and write data to the SDCard.
Section 6 describes how to build and run the SDCard POSIX File API mbed Greentea test cases. Section 6 describes how to build and run the SDCard POSIX File API mbed Greentea test cases.
There are a number of functional test cases demonstrating how to use the There are a number of functional test cases demonstrating how to use the
mbed OS POSIX File API. mbed OS POSIX File API.
Section 7 describes the POSIX File API and provides links to useful API documentation web pages. Section 7 describes the POSIX File API and provides links to useful API documentation web pages.
### Known mbed-os and sd-driver Compatible Versions ### Known mbed-os and sd-driver Compatible Versions
The following versions of the mbed-os and sd-driver repositories are known to work together: The following versions of the mbed-os and sd-driver repositories are known to work together:
- {mbed-os, sd-driver} = {mbed-os-5.4.0-rc2, sd-driver-0.0.1-mbed-os-5.4.0-rc2}. - {mbed-os, sd-driver} = {mbed-os-5.4.0-rc2, sd-driver-0.0.1-mbed-os-5.4.0-rc2}.
`K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2` fopen and basic filesystem tests working. `K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2` fopen and basic filesystem tests working.
- {mbed-os, sd-driver} = {mbed-os-5.4.0, sd-driver-0.0.2-mbed-os-5.4.0}. - {mbed-os, sd-driver} = {mbed-os-5.4.0, sd-driver-0.0.2-mbed-os-5.4.0}.
`K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2` fopen and basic filesystem tests working. `K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2` fopen and basic filesystem tests working.
- {mbed-os, sd-driver} = {mbed-os-5.4.1, sd-driver-0.0.3-mbed-os-5.4.1}. - {mbed-os, sd-driver} = {mbed-os-5.4.1, sd-driver-0.0.3-mbed-os-5.4.1}.
- {mbed-os, sd-driver} = {mbed-os-5.5.1, sd-driver-0.1.0-mbed-os-5.5.1}.
- {mbed-os, sd-driver} = {mbed-os-5.5.4, sd-driver-0.1.1-mbed-os-5.5.4}.
To find the latest compatible versions, use the following command to see the messages attached to the tags To find the latest compatible versions, use the following command to see the messages attached to the tags
in the sd-driver repository: in the sd-driver repository:
ex_app7/$ cd sd-driver ex_app7/$ cd sd-driver
ex_app7/sd-driver$ git tag -n ex_app7/sd-driver$ git tag -n
sd-driver-0.0.1-mbed-os-5.3.4 Version compatible with mbed-os-5.3.4, and private_mbedos_filesystems-0.0.1-mbed-os-5.3.4. sd-driver-0.0.1-mbed-os-5.3.4 Version compatible with mbed-os-5.3.4, and private_mbedos_filesystems-0.0.1-mbed-os-5.3.4.
sd-driver-0.0.2-mbed-os-5.4.0 Updated README.md to include worked exmaples and restructuring of information. sd-driver-0.0.2-mbed-os-5.4.0 Updated README.md to include worked exmaples and restructuring of information.
sd-driver-0.0.3-mbed-os-5.4.1 Version compatible with mbed-os-5.4.1. sd-driver-0.0.3-mbed-os-5.4.1 Version compatible with mbed-os-5.4.1.
sd-driver-0.1.1-mbed-os-5.5.4 Version compatible with mbed-os-5.5.4
### Known Issues With This Document ### Known Issues With This Document
@ -104,7 +107,7 @@ There are no known issues with this document.
------------------------ ------------------------
| | | |
| Application | // This application uses the POSIX File API | Application | // This application uses the POSIX File API
| | // to read/write data to persistent storage backends. | | // to read/write data to persistent storage backends.
------------------------ ------------------------
@ -112,7 +115,7 @@ There are no known issues with this document.
------------------------ ------------------------
| | | |
| libc | // The standard c library implementation | libc | // The standard c library implementation
| | // e.g. newlib. | | // e.g. newlib.
------------------------ ------------------------
@ -124,7 +127,7 @@ There are no known issues with this document.
| | | |
------------------------ ------------------------
------------------------ // Filesystem Upper Edge API. ------------------------ // Filesystem Upper Edge API.
------------------------ ------------------------
| | | |
@ -137,9 +140,9 @@ There are no known issues with this document.
------------------------ ------------------------
| Block API | | Block API |
| Device Driver | // The SDCard driver, for example. | Device Driver | // The SDCard driver, for example.
| e.g. sd-driver | | e.g. sd-driver |
------------------------ ------------------------
------------------------ // SPI.h interface. ------------------------ // SPI.h interface.
------------------------ ------------------------
@ -147,204 +150,43 @@ There are no known issues with this document.
| SPI | // SPI subsystem (C++ classes and C-HAL implementation). | SPI | // SPI subsystem (C++ classes and C-HAL implementation).
| | | |
------------------------ ------------------------
Figure 1. mbedOS generic architecture of filesystem software stack. Figure 1. mbedOS generic architecture of filesystem software stack.
The figure above shows the mbed OS software component stack used for data The figure above shows the mbed OS software component stack used for data
storage on SDCard: storage on SDCard:
- At the top level is the application component which uses the standard POSIX File API - At the top level is the application component which uses the standard POSIX File API
to read and write application data to persistent storage. to read and write application data to persistent storage.
- The newlib standard library (libc) stdio.h interface (POSIX File API) - The newlib standard library (libc) stdio.h interface (POSIX File API)
implementation is used as it's optimised for resource limited embedded systems. implementation is used as it's optimised for resource limited embedded systems.
- mbed_retarget.cpp implements the libc back-end file OS handlers and maps them - mbed_retarget.cpp implements the libc back-end file OS handlers and maps them
to the FileSystem. to the FileSystem.
- The File System code (hosted in mbed-os) is composed of 2 parts: - The File System code (hosted in mbed-os) is composed of 2 parts:
- The mbed OS file system wrapper classes (e.g. FileSystem, File, FileBase classes) - The mbed OS file system wrapper classes (e.g. FileSystem, File, FileBase classes)
which are used to present a consistent API to the retarget module for different which are used to present a consistent API to the retarget module for different
(third-party) file system implementations. (third-party) file system implementations.
- The FAT filesystem implementation code. - The FAT filesystem implementation code.
The [FATFS: Generic FAT File System Module](http://elm-chan.org/fsw/ff/00index_e.html) The [FATFS: Generic FAT File System Module](http://elm-chan.org/fsw/ff/00index_e.html)
(ChanFS) has been integrated within mbed-os. (ChanFS) has been integrated within mbed-os.
- The Block API Device Driver. The SDCard driver is an example of a persistent storage driver. - The Block API Device Driver. The SDCard driver is an example of a persistent storage driver.
It's maintained as a separate component from the mbed OS repository (in this repository). It's maintained as a separate component from the mbed OS repository (in this repository).
- The SPI module provides the mbed OS generic SPI API. This functionality is maintained in - The SPI module provides the mbed OS generic SPI API. This functionality is maintained in
mbed OS. mbed OS.
# SDCard POSIX File API Example App for Reading/Writing Data # SDCard POSIX File API Example App for Reading/Writing Data
### Overview Refer to [SD driver Example](https://github.com/ARMmbed/mbed-os-example-sd-driver)
This section describes how to build and run an example application that
uses the POSIX File API to read and write data to SDCard. The discussion begins by
descibing how to run the example on the FRDM K64F target, but this is later
generalised to all target platforms that have the standard
Arduino form factor headers. Tthe Continuous Integration (CI) Test Shield
can be inserted into the headers to add a SDCard slot to the target.
The example code is a modified version of the
[mbed-os-example-fat-filesystem](https://github.com/ARMmbed/mbed-os-example-fat-filesystem) example
modified for use with the sd-driver.
The following sub-sections describe the steps for building and running the example:
- The [Pre-Requisites](#pre-requisites) section describes the development environment used for this example.
Other similar development environments can be used.
- The [Create the Example Project](#create-the-example-project) section describes how the application project is created
by including the mbed-os and sd-driver code.
- The [Build the Example Project](#build-the-example-project) section describes how to build the example application.
- The [Insert SDCard into K64F](#insert-sdcard-into-k64f) section describes how to select a card and insert it into the
SDCard slot on the K64F.
- The [Run the Example Binary on the K64F](#run-the-example-binary-on-the-k64f) section describes how to run the
example binary on the target and verify the example has run correctly.
- The [Testing with an SDCard on Target XYZ](#testing-with-an-sdcard-on-target-xyx) section describes the use
of Continuous Integration Test Shield, which hosts an SDCard slot. By inserting the CI test shield into the
Arduino headers of an mbed target platform, the SDCard/FAT Filesystem components can be used to store data
persistently on any standard mbed target development board.
### <a name="pre-requisites"></a> Pre-Requisites
To work through this example, you should have a working development environment on your machine. For example,
the following tools should be installed:
- A compiler e.g. arm-none-eabi-gcc.
- Python 2.7.9 or later.
- [mbed Greentea](https://github.com/armmbed/greentea), the mbed OS test tool.
- Git Bash or a similar git command line tool to interact with the ARM mbed GitHub repositories.
- [mbed-cli](https://github.com/armmbed/mbed-cli), the tool used to make mbed OS application and test builds.
For more information on how to setup a development environment, please review the documentation on the
[mbed documentation site](https://docs.mbed.com).
### <a name="create-the-example-project"></a> Create the Example Project
First create the top level application directory sd_ex1 and move into it:
shell:/d/demo_area$ mkdir sd_ex1
shell:/d/demo_area$ cd sd_ex1
shell:/d/demo_area/sd_ex1$
Next, perform the "mbed new" operation to download the mbed-os repository into this directory:
shell:/d/demo_area/sd_ex1$ mbed new .
[mbed] Creating new program "ex_sdcard" (git)
[mbed] Adding library "mbed-os" from "https://github.com/ARMmbed/mbed-os" at branch latest
[mbed] Updating reference "mbed-os" -> "https://github.com/ARMmbed/mbed-os/#5faf4b26c5954d15c7c1cccac6498e0c690ad101"
warning: LF will be replaced by CRLF in mbed-os.lib.
The file will have its original line endings in your working directory.
shell:/d/demo_area/sd_ex1$ ls -1
mbed-os
mbed-os.lib
mbed_settings.py
shell:/d/demo_area/sd_ex1$
Next, get add the sd-driver component to the application project:
shell:/d/demo_area/sd_ex1$ mbed add sd-driver
<trace removed>
shell:/d/demo_area/sd_ex1$
Next, copy the example1.cpp file and `mbed_app.json` files from inside the sd-driver directory to the top level sd_ex1 directory:
shell:/d/demo_area/sd_ex1$ cp sd-driver/features/TESTS/examples/example1.cpp .
shell:/d/demo_area/sd_ex1$ cp sd-driver/config/mbed_app.json .
shell:/d/demo_area/sd_ex1$
The `mbed_app.json` file specifies the SPI bus pin configuration for different targets.
The file includes a specific configuration of the K64F which is used
because the mbed compile command specifies the K64F build target. The `mbed_app.json` file
is described in more detail in the [Testing with an SDCard on Target XYZ](#testing-with-an-sdcard-on-target-xyx) section.
### <a name="build-the-example-project"></a> Build the Example Project
Next, build the example application:
shell:/d/demo_area/sd_ex1$ mbed compile -m K64F -t GCC_ARM
#### WARNING: "mbed new ." command and possible mbed-os sd-driver versioning incompatibilities
If you experience problems building the example then it may mean the version
of the mbed-os repository created with the "mbed new ." command is not compatible with
the sd-driver repository version created with "mbed add sd-driver" command. This is because:
- The "mbed new ." creates the mbed-os repository at the latest "Release" e.g. `mbed-os-5.4.0`.
- The "mbed add sd-driver" command creates the sd-driver repository at the latest version of
master i.e. the tip of master. Changes may be present that are not compatible with
the latest mbed-os release e.g. in preparation for the next release.
This situation can be resolved by checking out compatible versions of the repositories as
described in the section [Setting mbed-os/sd-driver Repositories To Compatible Versions](#settting-repos-to-compatible-versions)
### <a name="insert-sdcard-into-k64f"></a> Insert SDCard into K64F
The examples and test cases have been run on a K64F with the following pre-formatted microSDHC cards:
- Kingston 2GB mircoSDHC card.
- Kingston 8GB mircoSDHC card.
- SanDisk 16GB mircoSDHC ultra card.
If the card requires formatting then the following procedure is known to work:
- Insert microSD card into SD adapter in USB stick (or similar) so the microSD card can be insert into windows PC.
- Within file explorer, right click/Format on the USB drive.
- Select FAT32, 4096 cluster size, Quick Format.
- Format the drive.
The microSD card should then be ready for use in the K64F. Insert the formatted card
into the SDCard slot on the K64F PCB.
### <a name="run-the-example-binary-on-the-k64f"></a> Run the Example Binary on the K64F
Once the binary is built, copy the binary from `/d/demo_area/sd_ex1/BUILD/K64F/GCC_ARM/example1.bin` to the K64F.
After connecting a serial console and resetting the target, the following trace should be seen:
Welcome to the filesystem example.
Opening a new file, numbers.txt. done.
Writing decimal numbers to a file (20/20) done.
Closing file. done.
Re-opening file read-only. done.
Dumping file to screen.
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
EOF.
Closing file. done.
Opening root directory. done.
Printing all filenames:
numbers.txt
Closeing root directory. done.
Filesystem Demo complete.
### <a name="testing-with-an-sdcard-on-target-xyx"></a> Testing with an SDCard on Target XYZ ### <a name="testing-with-an-sdcard-on-target-xyx"></a> Testing with an SDCard on Target XYZ
The standard way to test is with the mbed CI Test Shield plugged into the The standard way to test is with the mbed CI Test Shield plugged into the
target board. This pin mapping for this configuration is parameterised in target board. This pin mapping for this configuration is parameterised in
the `mbed_app.json` file. the `mbed_lib.json` file.
The following is an example of the `mbed_app.json` file available in the repository: The following is an example of the `mbed_lib.json` file available in the repository:
{ {
"config": { "config": {
@ -465,15 +307,15 @@ The following is an example of the `mbed_app.json` file available in the reposit
} }
} }
Note the following things about the `mbed_app.json` file: Note the following things about the `mbed_lib.json` file:
- The `mbed_app.json` file is used to define target specific symbols for the SPI pins connecting the SDCard slot to the target MCU: - The `mbed_lib.json` file is used to define target specific symbols for the SPI pins connecting the SDCard slot to the target MCU:
- "SPI\_CS". This is the Chip Select line. - "SPI\_CS". This is the Chip Select line.
- "SPI\_MOSI". This is the Master Out Slave In data line. - "SPI\_MOSI". This is the Master Out Slave In data line.
- "SPI\_MISO". This is the Master In Slave Out data line. - "SPI\_MISO". This is the Master In Slave Out data line.
- "SPI\_CLK". This is the serial Clock line. - "SPI\_CLK". This is the serial Clock line.
- The default configuration defined in the "config" section is for the standard Arduino header pin mappings for the SPI bus. - The default configuration defined in the "config" section is for the standard Arduino header pin mappings for the SPI bus.
The "config" section defines a dictionary mapping functional names to target board Arduino header pins: The "config" section defines a dictionary mapping functional names to target board Arduino header pins:
- "SPI\_CS": "D10". This causes the MBED\_CONF\_APP\_SPI\_CS symbol to be defined in mbed\_config.h as D10, which is used in the filesystem test implementation. - "SPI\_CS": "D10". This causes the MBED\_CONF\_APP\_SPI\_CS symbol to be defined in mbed\_config.h as D10, which is used in the filesystem test implementation.
D10 is defined in the target specific PinNames.h file. D10 is defined in the target specific PinNames.h file.
- "SPI\_MOSI": "D11". This causes the MBED\_CONF\_APP\_SPI\_MOSI symbol to be defined in mbed\_config.h. - "SPI\_MOSI": "D11". This causes the MBED\_CONF\_APP\_SPI\_MOSI symbol to be defined in mbed\_config.h.
@ -489,42 +331,29 @@ Note the following things about the `mbed_app.json` file:
"SPI_CLK": "PTE2", "SPI_CLK": "PTE2",
"SPI_CS": "PTE4" "SPI_CS": "PTE4"
} }
``` ```
- Thus, in the absence of any target specific definitions in the `"target_overrides"` section, all boards will default to - Thus, in the absence of any target specific definitions in the `"target_overrides"` section, all boards will default to
using the Arduino header configuration. For those platforms with a `"target_overrides"` section then this configuration using the Arduino header configuration. For those platforms with a `"target_overrides"` section then this configuration
will be used in preference. will be used in preference.
- Hence in the case that you want to test a platform with an SDCard inserted into a - Hence in the case that you want to test a platform with an SDCard inserted into a
fitted CI test shield (rather than the on-board SDCard slot) fitted CI test shield (rather than the on-board SDCard slot)
and there is a `"target_overrides"` section present in the `mbed_app.json` file, you must then delete the `"target_overrides"` and there is a `"target_overrides"` section present in the `mbed_lib.json` file, you must then delete the `"target_overrides"`
section before building. This will result in the default configuration being used (suitable for the CI section before building. This will result in the default configuration being used (suitable for the CI
Test Shield). Test Shield).
- Note when inserting the v1.0.0 CI Test Shield into the Arduino header of the target platform, the shield pins D0 and - Note when inserting the v1.0.0 CI Test Shield into the Arduino header of the target platform, the shield pins D0 and
D1 should be bent to be parallel to the shield PCB so they are not inserted into the Arduino header. This is because D1 should be bent to be parallel to the shield PCB so they are not inserted into the Arduino header. This is because
some boards use the same UART on DAPLINK and D0/D1, which means the serial debug channel breaks and hence the mbed greentea some boards use the same UART on DAPLINK and D0/D1, which means the serial debug channel breaks and hence the mbed greentea
test suite will not work correctly. This is mainly on older ST boards and should not be a problem on test suite will not work correctly. This is mainly on older ST boards and should not be a problem on
`K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2`. Note also that the v2.0.0 CI Test Shield doesn't suffer from this `K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2`. Note also that the v2.0.0 CI Test Shield doesn't suffer from this
problem and the pins don't need to be bent. problem and the pins don't need to be bent.
- When inserting the SDCard into the card slot on the CI test shield, make sure the card is fully inserted. - When inserting the SDCard into the card slot on the CI test shield, make sure the card is fully inserted.
On insertion, there should be a small clicking sound when the card registers, and the back edge of the card On insertion, there should be a small clicking sound when the card registers, and the back edge of the card
should protrude no more than ~1mm over the edge of the CI test shield PCB. If the SDCard fails to register, should protrude no more than ~1mm over the edge of the CI test shield PCB. If the SDCard fails to register,
try gently pushing the metal flexible strip in the shape of a spade at the top edge of the SDCard metal slot try gently pushing the metal flexible strip in the shape of a spade at the top edge of the SDCard metal slot
casing with a pair of tweezers, bending it a little to lower it into the slot casing. This helps with the casing with a pair of tweezers, bending it a little to lower it into the slot casing. This helps with the
insertion mechanism. insertion mechanism.
### Target K64F with CI Test Shield fitted
![alt text](docs/pics/sd_driver_k64_with_ci_test_shield.jpg "unseen title text")
**Figure 2. The figure shows the K64F platform with the CI shield fitted.**
The above figure shows the K64F with the v1.0.0 CI test shield fitted. Note:
- The pins D0/D1 (top right of CI test shield) are bent sideways so as not to insert into the header.
- The SDCard is fully inserted into the slot and overhangs the PCB by ~1mm.
### Wiring instructions for target NUCLEO_F429ZI with CI Test Shield ### Wiring instructions for target NUCLEO_F429ZI with CI Test Shield
![alt text](docs/pics/NUCLEO_F429ZI_wiring_with_ci_test_shield.png "unseen title text") ![alt text](docs/pics/NUCLEO_F429ZI_wiring_with_ci_test_shield.png "unseen title text")
**Figure 3. The figure shows how to connect the NUCLEO_F429ZI platform with the CI shield.** **Figure 3. The figure shows how to connect the NUCLEO_F429ZI platform with the CI shield.**
@ -533,17 +362,17 @@ The above figure shows how to connect the NUCLEO_F429ZI with the v1.0.0 CI test
- To get the SD Card to work with this platform the CI test shield cannot be connected directly to this board, instead follow the instructions above. - To get the SD Card to work with this platform the CI test shield cannot be connected directly to this board, instead follow the instructions above.
- Any SD-card adapter will work as long as you connect all the relevant pins (MOSI, MISO, SCLK, CS, 3.3V and GND) as illustrated in figure 3. - Any SD-card adapter will work as long as you connect all the relevant pins (MOSI, MISO, SCLK, CS, 3.3V and GND) as illustrated in figure 3.
- The SDCard is fully inserted into the slot and overhangs the PCB by ~1mm. - The SDCard is fully inserted into the slot and overhangs the PCB by ~1mm.
# SDBlockDevice Example Application # SDBlockDevice Example Application
The following sample code illustrates how to use the sd-driver Block Device API: The following sample code illustrates how to use the sd-driver Block Device API:
#include "mbed.h" #include "mbed.h"
#include "SDBlockDevice.h" #include "SDBlockDevice.h"
// Instantiate the SDBlockDevice by specifying the SPI pins connected to the SDCard // Instantiate the SDBlockDevice by specifying the SPI pins connected to the SDCard
// socket. The PINS are: // socket. The PINS are:
// MOSI (Master Out Slave In) // MOSI (Master Out Slave In)
// MISO (Master In Slave Out) // MISO (Master In Slave Out)
@ -551,21 +380,37 @@ The following sample code illustrates how to use the sd-driver Block Device API:
// CS (Chip Select) // CS (Chip Select)
SDBlockDevice sd(MBED_CONF_SD_SPI_MOSI, MBED_CONF_SD_SPI_MISO, MBED_CONF_SD_SPI_CLK, MBED_CONF_SD_SPI_CS); SDBlockDevice sd(MBED_CONF_SD_SPI_MOSI, MBED_CONF_SD_SPI_MISO, MBED_CONF_SD_SPI_CLK, MBED_CONF_SD_SPI_CS);
uint8_t block[512] = "Hello World!\n"; uint8_t block[512] = "Hello World!\n";
int main() int main()
{ {
// call the SDBlockDevice instance initialisation method. // call the SDBlockDevice instance initialisation method.
sd.init(); if ( 0 != sd.init()) {
printf("Init failed \n");
// Write some the data block to the device return -1;
sd.program(block, 0, 512); }
printf("sd size: %llu\n", sd.size());
// read the data block from the device printf("sd read size: %llu\n", sd.get_read_size());
sd.read(block, 0, 512); printf("sd program size: %llu\n", sd.get_program_size());
printf("sd erase size: %llu\n", sd.get_erase_size());
// print the contents of the block
printf("%s", block); // set the frequency
if ( 0 != sd.frequency(5000000)) {
printf("Error setting frequency \n");
}
if ( 0 != sd.erase(0, sd.get_erase_size())) {
printf("Error Erasing block \n");
}
// Write some the data block to the device
if ( 0 == sd.program(block, 0, 512)) {
// read the data block from the device
if ( 0 == sd.read(block, 0, 512)) {
// print the contents of the block
printf("%s", block);
}
}
// call the SDBlockDevice instance de-initialisation method. // call the SDBlockDevice instance de-initialisation method.
sd.deinit(); sd.deinit();
} }
@ -573,30 +418,30 @@ The following sample code illustrates how to use the sd-driver Block Device API:
# SDCard POSIX File API mbed Greentea Test Cases # SDCard POSIX File API mbed Greentea Test Cases
This section describes how to build and run the POSIX file API test cases. This section describes how to build and run the POSIX file API test cases.
The following steps are covered: The following steps are covered:
- [Create the FAT/SDCard Application Project](#create-fat-sdcard-application-project). - [Create the FAT/SDCard Application Project](#create-fat-sdcard-application-project).
This section describes how to git clone the mbed OS and sd-driver repositories containing the This section describes how to git clone the mbed OS and sd-driver repositories containing the
code and test cases of interest. code and test cases of interest.
- [Build the mbed OS Test Cases](#build-the-mbedos-test-cases). This section - [Build the mbed OS Test Cases](#build-the-mbedos-test-cases). This section
describes how to build the mbed OS test cases. describes how to build the mbed OS test cases.
- [Insert a microSD Card Into the K64F for Greentea Testing](#greentea-insert-sdcard-into-k64f).This section - [Insert a microSD Card Into the K64F for Greentea Testing](#greentea-insert-sdcard-into-k64f).This section
describes how to format (if required) a microSD card prior to running the tests. describes how to format (if required) a microSD card prior to running the tests.
- [Run the POSIX File Test Case](#run-the-posix-file-test-cases).This section - [Run the POSIX File Test Case](#run-the-posix-file-test-cases).This section
describes how to run the POSIX file test cases. describes how to run the POSIX file test cases.
### <a name="create-fat-sdcard-application-project"></a> Create the FAT/SDCard Application Project ### <a name="create-fat-sdcard-application-project"></a> Create the FAT/SDCard Application Project
This section describes how to create an application project combining the This section describes how to create an application project combining the mbed-os and
mbed-os and sd-driver repositories into a single project. sd-driver repositories into a single project.
In summary the following steps will be covered in this section: In summary the following steps will be covered in this section:
- A top level application project directory is created. The directory name is ex_app1. - A top level application project directory is created. The directory name is ex_app1.
- In the ex_app1 directory, the mbed-os repository is cloned. - In the ex_app1 directory, the mbed-os repository is cloned.
- In the ex_app1 directory at the same level as the mbed-os directory, the sd-driver repository is cloned. - In the ex_app1 directory at the same level as the mbed-os directory, the sd-driver repository is cloned.
- The `mbed_app.json` file is copied from the `sd-driver/config/mbed_app.json` to the ex_app1 directory. - The `mbed_lib.json` file is copied from the `sd-driver/config/mbed_lib.json` to the ex_app1 directory.
First create the top level application directory ex_app1 and move into it: First create the top level application directory ex_app1 and move into it:
@ -614,69 +459,63 @@ Next, get a clone of the sd-driver repository:
shell:/d/demo_area/ex_app1$ git clone git@github.com:/armmbed/sd-driver shell:/d/demo_area/ex_app1$ git clone git@github.com:/armmbed/sd-driver
<trace removed> <trace removed>
shell:/d/demo_area/ex_app1$ shell:/d/demo_area/ex_app1$
Finally, copy the `mbed_app.json` application configuration file from `sd-driver/config/mbed_app.json` to the ex_app1 directory:
shell:/d/demo_area/ex_app1$ cp sd-driver/config/mbed_app.json .
shell:/d/demo_area/ex_app1$
The `mbed_app.json` file specifies the SPI bus pin configuration for different targets,
and is discussed in the [Testing with an SDCard on Target XYZ](#testing-with-an-sdcard-on-target-xyx) section.
Note: The `mbed_lib.json` file specifies the SPI bus pin configuration for different targets,
and is discussed in the [Testing with an SDCard on Target XYZ](#testing-with-an-sdcard-on-target-xyx) section.
### <a name="build-the-mbedos-test-cases"></a> Build the mbed OS Test Cases ### <a name="build-the-mbedos-test-cases"></a> Build the mbed OS Test Cases
Build the test cases for the K64F target using the following command: Build the test cases for the K64F target using the following command:
shell:/d/demo_area/ex_app1$ mbed -v test --compile -t GCC_ARM -m K64F --app-config mbed_app.json shell:/d/demo_area/ex_app1$ mbed -v test --compile -t GCC_ARM -m K64F
<trace removed> <trace removed>
shell:/d/demo_area/ex_app1$ shell:/d/demo_area/ex_app1$
The build trace is quite extensive but on a successful build you should see the following output at the end of the log: The build trace is quite extensive but on a successful build you should see the following output at the end of the log:
Build successes: Build successes:
* K64F::GCC_ARM::MBED-BUILD * K64F::GCC_ARM::MBED-BUILD
* K64F::GCC_ARM::MBED-OS-FEATURES-FEATURE_LWIP-TESTS-MBEDMICRO-NET-CONNECTIVITY * K64F::GCC_ARM::MBED-OS-FEATURES-FEATURE_LWIP-TESTS-MBEDMICRO-NET-CONNECTIVITY
<trace removed> <trace removed>
* K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-FAT_FILE_SYSTEM * K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-FAT_FILE_SYSTEM
* K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-HEAP_BLOCK_DEVICE * K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-HEAP_BLOCK_DEVICE
* K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-UTIL_BLOCK_DEVICE * K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-UTIL_BLOCK_DEVICE
<trace removed> <trace removed>
* K64F::GCC_ARM::SD-DRIVER-FEATURES-TESTS-FILESYSTEM-BASIC * K64F::GCC_ARM::SD-DRIVER-TESTS-FILESYSTEM-BASIC
* K64F::GCC_ARM::SD-DRIVER-FEATURES-TESTS-FILESYSTEM-FOPEN * K64F::GCC_ARM::SD-DRIVER-TESTS-FILESYSTEM-FOPEN
Build skips: Build skips:
* K64F::GCC_ARM::MBED-OS-FEATURES-FEATURE_LWIP-TESTS-MBEDMICRO-NET-TCP_PACKET_PRESSURE * K64F::GCC_ARM::MBED-OS-FEATURES-FEATURE_LWIP-TESTS-MBEDMICRO-NET-TCP_PACKET_PRESSURE
<trace removed> <trace removed>
Notice the following tests in the sd-driver tree are listed above: Notice the following tests in the sd-driver tree are listed above:
- `K64F::GCC_ARM::SD-DRIVER-FEATURES-TESTS-FILESYSTEM-BASIC` - `K64F::GCC_ARM::SD-DRIVER-TESTS-FILESYSTEM-BASIC`
- `K64F::GCC_ARM::SD-DRIVER-FEATURES-TESTS-FILESYSTEM-FOPEN` - `K64F::GCC_ARM::SD-DRIVER-TESTS-FILESYSTEM-FOPEN`
The FAT32/SDCard test cases are at following locations in the source code tree: The FAT32/SDCard test cases are at following locations in the source code tree:
/d/demo_area/ex_app1/sd-driver/features/TESTS/filesystem/basic/basic.cpp /d/demo_area/ex_app1/sd-driver/TESTS/filesystem/basic/basic.cpp
/d/demo_area/ex_app1/sd-driver/features/TESTS/filesystem/fopen/fopen.cpp /d/demo_area/ex_app1/sd-driver/TESTS/filesystem/fopen/fopen.cpp
#### <a name="settting-repos-to-compatible-versions"></a> Setting mbed-os/sd-driver Repositories To Compatible Versions #### <a name="settting-repos-to-compatible-versions"></a> Setting mbed-os/sd-driver Repositories To Compatible Versions
The sd-driver master HEAD and the mbed-os master HEAD should be compatible The sd-driver master HEAD and the mbed-os master HEAD should be compatible
with one another and therefore no specific tagged versions need to be checked out. with one another and therefore no specific tagged versions need to be checked out.
However, in the case that you experience problems building, checkout out the compatible However, in the case that you experience problems building, checkout out the compatible
tagged version of each repository, as shown below: tagged version of each repository, as shown below:
shell:/d/demo_area/ex_app1$ pushd mbed-os shell:/d/demo_area/ex_app1$ pushd mbed-os
shell:/d/demo_area/ex_app1$ git checkout tags/mbed-os-5.4.0 shell:/d/demo_area/ex_app1$ git checkout tags/mbed-os-5.4.0
shell:/d/demo_area/ex_app1$ popd shell:/d/demo_area/ex_app1$ popd
shell:/d/demo_area/ex_app1$ pushd sd-driver shell:/d/demo_area/ex_app1$ pushd sd-driver
shell:/d/demo_area/ex_app1$ git checkout tags/sd-driver-0.0.2-mbed-os-5.4.0 shell:/d/demo_area/ex_app1$ git checkout tags/sd-driver-0.0.2-mbed-os-5.4.0
shell:/d/demo_area/ex_app1$ popd shell:/d/demo_area/ex_app1$ popd
In the above: In the above:
- `mbed-os-5.4.0` should be replaced with the latest mbed-os release tag. - `mbed-os-5.4.0` should be replaced with the latest mbed-os release tag.
- For an mbed-os release tag `mbed-os-x.y.z`, use the equivalent sd-driver tag `sd-driver-a.b.c-mbed-os-x.y.z` - For an mbed-os release tag `mbed-os-x.y.z`, use the equivalent sd-driver tag `sd-driver-a.b.c-mbed-os-x.y.z`
@ -689,7 +528,7 @@ See the previous section for [Insert SDCard into K64F](#insert-sdcard-into-k64f)
### <a name="run-the-posix-file-test-cases"></a> Run the POSIX File Test Case ### <a name="run-the-posix-file-test-cases"></a> Run the POSIX File Test Case
To setup for running the test cases, connect the K64F development board to your To setup for running the test cases, connect the K64F development board to your
PC using a suitable USB cable. PC using a suitable USB cable.
All tests can be run using the following command: All tests can be run using the following command:
@ -700,51 +539,51 @@ All tests can be run using the following command:
However, it's possible to run a particular test case using the following form of the mbedgt command: However, it's possible to run a particular test case using the following form of the mbedgt command:
shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=<test-name> shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=<test-name>
The names of the tests can be listed using: The names of the tests can be listed using:
shell:/d/demo_area/ex_app1$ mbedgt -VS --list shell:/d/demo_area/ex_app1$ mbedgt -VS --list
For example, to run the basic test use: For example, to run the basic test use:
shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=sd-driver-features-tests-filesystem-basic shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=sd-driver-tests-filesystem-basic
To run the fopen test use: To run the fopen test use:
shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=sd-driver-features-tests-filesystem-fopen shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=sd-driver-tests-filesystem-fopen
On a successful run, results similar to the following will be shown: On a successful run, results similar to the following will be shown:
mbedgt: test suite report: mbedgt: test suite report:
+--------------+---------------+-------------------------------------------+--------+--------------------+-------------+ +--------------+---------------+-------------------------------------------+--------+--------------------+-------------+
| target | platform_name | test suite | result | elapsed_time (sec) | copy_method | | target | platform_name | test suite | result | elapsed_time (sec) | copy_method |
+--------------+---------------+-------------------------------------------+--------+--------------------+-------------+ +--------------+---------------+-------------------------------------------+--------+--------------------+-------------+
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | OK | 151.46 | shell | | K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | OK | 151.46 | shell |
+--------------+---------------+-------------------------------------------+--------+--------------------+-------------+ +--------------+---------------+-------------------------------------------+--------+--------------------+-------------+
mbedgt: test suite results: 1 OK mbedgt: test suite results: 1 OK
mbedgt: test case report: mbedgt: test case report:
+--------------+---------------+-------------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+ +--------------+---------------+------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+
| target | platform_name | test suite | test case | passed | failed | result | elapsed_time (sec) | | target | platform_name | test suite | test case | passed | failed | result | elapsed_time (sec) |
+--------------+---------------+-------------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+ +--------------+---------------+------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_01: fopen()/fwrite()/fclose() directories/file in multi-dir filepath. | 1 | 0 | OK | 7.57 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_01: fopen()/fwrite()/fclose() directories/file in multi-dir filepath. | 1 | 0 | OK | 7.57 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_02: fopen(r) pre-existing file try to write it. | 1 | 0 | OK | 0.2 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_02: fopen(r) pre-existing file try to write it. | 1 | 0 | OK | 0.2 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_03: fopen(w+) pre-existing file try to write it. | 1 | 0 | OK | 0.41 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_03: fopen(w+) pre-existing file try to write it. | 1 | 0 | OK | 0.41 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_04: fopen() with a filename exceeding the maximum length. | 1 | 0 | OK | 0.11 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_04: fopen() with a filename exceeding the maximum length. | 1 | 0 | OK | 0.11 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_06: fopen() with bad filenames (minimal). | 1 | 0 | OK | 0.1 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_06: fopen() with bad filenames (minimal). | 1 | 0 | OK | 0.1 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_07: fopen()/errno handling. | 1 | 0 | OK | 0.07 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_07: fopen()/errno handling. | 1 | 0 | OK | 0.07 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_08: ferror()/clearerr()/errno handling. | 1 | 0 | OK | 0.1 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_08: ferror()/clearerr()/errno handling. | 1 | 0 | OK | 0.1 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_09: ftell() handling. | 1 | 0 | OK | 0.17 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_09: ftell() handling. | 1 | 0 | OK | 0.17 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_10: remove() test. | 1 | 0 | OK | 1.28 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_10: remove() test. | 1 | 0 | OK | 1.28 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_11: rename(). | 1 | 0 | OK | 2.3 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_11: rename(). | 1 | 0 | OK | 2.3 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_12: opendir(), readdir(), closedir() test. | 1 | 0 | OK | 3.57 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_12: opendir(), readdir(), closedir() test. | 1 | 0 | OK | 3.57 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_13: mkdir() test. | 1 | 0 | OK | 1.21 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_13: mkdir() test. | 1 | 0 | OK | 1.21 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_14: stat() test. | 1 | 0 | OK | 1.47 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_14: stat() test. | 1 | 0 | OK | 1.47 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_15: format() test. | 1 | 0 | OK | 26.12 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_15: format() test. | 1 | 0 | OK | 26.12 |
| K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | FSFAT_FOPEN_TEST_16: write/check n x 25kB data files. | 1 | 0 | OK | 87.11 | | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_16: write/check n x 25kB data files. | 1 | 0 | OK | 87.11 |
+--------------+---------------+-------------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+ +--------------+---------------+------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+
mbedgt: test case results: 15 OK mbedgt: test case results: 15 OK
mbedgt: completed in 152.35 sec mbedgt: completed in 152.35 sec
# <a name="summary-posix-api-documentation"></a> Summary of POSIX File API Documentation # <a name="summary-posix-api-documentation"></a> Summary of POSIX File API Documentation
@ -757,8 +596,8 @@ mbed OS supports a subset of the POSIX File API, as outlined below:
- [fclose()](https://linux.die.net/man/3/fclose). - [fclose()](https://linux.die.net/man/3/fclose).
- STATUS: Basic testing implemented. Working. - STATUS: Basic testing implemented. Working.
- [ferror()](https://linux.die.net/man/3/clearerr). - [ferror()](https://linux.die.net/man/3/clearerr).
- STATUS: Basic testing implemented. - STATUS: Basic testing implemented.
- STATUS: GCC_ARM: Working. - STATUS: GCC_ARM: Working.
- STATUS: ARMCC: ARMCC has problem with ferror(filep) where filep is NULL. Appears to work for non-NULL pointer. - STATUS: ARMCC: ARMCC has problem with ferror(filep) where filep is NULL. Appears to work for non-NULL pointer.
- [fgetc()](https://linux.die.net/man/3/fgets). - [fgetc()](https://linux.die.net/man/3/fgets).
- STATUS: Basic testing implemented. Working. - STATUS: Basic testing implemented. Working.
@ -771,7 +610,7 @@ mbed OS supports a subset of the POSIX File API, as outlined below:
- [fprintf()](https://linux.die.net/man/3/fprintf). - [fprintf()](https://linux.die.net/man/3/fprintf).
- STATUS: Basic testing implemented. Working. - STATUS: Basic testing implemented. Working.
- [fopen()](https://linux.die.net/man/3/fopen). - [fopen()](https://linux.die.net/man/3/fopen).
- STATUS: Basic testing implemented. Working. - STATUS: Basic testing implemented. Working.
- [freopen()](https://linux.die.net/man/3/fopen). - [freopen()](https://linux.die.net/man/3/fopen).
- STATUS: This is not tested. - STATUS: This is not tested.
- [fread()](https://linux.die.net/man/3/fread). - [fread()](https://linux.die.net/man/3/fread).
@ -795,22 +634,22 @@ mbed OS supports a subset of the POSIX File API, as outlined below:
- [remove()](https://linux.die.net/man/3/remove) - [remove()](https://linux.die.net/man/3/remove)
- STATUS: Basic testing implemented. Working. - STATUS: Basic testing implemented. Working.
- [rewind()](https://linux.die.net/man/3/rewind). - [rewind()](https://linux.die.net/man/3/rewind).
- STATUS: Basic testing implemented. Working. - STATUS: Basic testing implemented. Working.
- [stat()](https://linux.die.net/man/2/stat) - [stat()](https://linux.die.net/man/2/stat)
- STATUS: Implemented. Working. - STATUS: Implemented. Working.
- STATUS: Not supported by ARMCC/IAR libc. - STATUS: Not supported by ARMCC/IAR libc.
- [tmpfile()](https://linux.die.net/man/3/tmpfile). - [tmpfile()](https://linux.die.net/man/3/tmpfile).
- STATUS: Not implemented. - STATUS: Not implemented.
- [tmpnam()](https://linux.die.net/man/3/tmpnam). - [tmpnam()](https://linux.die.net/man/3/tmpnam).
- STATUS: Not implemented. - STATUS: Not implemented.
Supported directory related operations are as follows: Supported directory related operations are as follows:
- [closedir()](https://linux.die.net/man/3/closedir). - [closedir()](https://linux.die.net/man/3/closedir).
- STATUS: Implemented. Working. - STATUS: Implemented. Working.
- [mkdir()](https://linux.die.net/man/3/mkdir). - [mkdir()](https://linux.die.net/man/3/mkdir).
- STATUS: Basic testing implemented. Working. - STATUS: Basic testing implemented. Working.
- [opendir()](https://linux.die.net/man/3/opendir). - [opendir()](https://linux.die.net/man/3/opendir).
- STATUS: Implemented. Working. - STATUS: Implemented. Working.
- [readdir()](https://linux.die.net/man/3/readdir). - [readdir()](https://linux.die.net/man/3/readdir).
- STATUS: Implemented. Working. - STATUS: Implemented. Working.
@ -821,11 +660,11 @@ Supported directory related operations are as follows:
- [rewinddir()](https://linux.die.net/man/3/rewinddir). - [rewinddir()](https://linux.die.net/man/3/rewinddir).
- STATUS: Implemented. Found not to work. Test case not present in repo. - STATUS: Implemented. Found not to work. Test case not present in repo.
- [seekdir()](https://linux.die.net/man/3/seekdir). - [seekdir()](https://linux.die.net/man/3/seekdir).
- STATUS: Implemented. Found not to work. Test case not present in repo. - STATUS: Implemented. Found not to work. Test case not present in repo.
- [telldir()](https://linux.die.net/man/3/telldir). - [telldir()](https://linux.die.net/man/3/telldir).
- STATUS: Implemented. Found not to work. Test case not present in repo. - STATUS: Implemented. Found not to work. Test case not present in repo.
### errno ### errno
Basic errno reporting is supported, tested and known to be working. Basic errno reporting is supported, tested and known to be working.
@ -839,9 +678,9 @@ The following are related mbed storage projects and useful resources:
This is an example project for the mbed OS FAT filesystem. This is an example project for the mbed OS FAT filesystem.
- The [spiflash-driver](https://github.com/armmbed/spiflash-driver) repository. - The [spiflash-driver](https://github.com/armmbed/spiflash-driver) repository.
- The [i2ceeprom-driver](https://github.com/ARMmbed/i2ceeprom-driver.git) repository. - The [i2ceeprom-driver](https://github.com/ARMmbed/i2ceeprom-driver.git) repository.
- The [ci-test-shield](https://github.com/ARMmbed/ci-test-shield) repository. This is the project describing - The [ci-test-shield](https://github.com/ARMmbed/ci-test-shield) repository. This is the project describing
the mbed-os Continuous Integration test shield, together with standard tests. the mbed-os Continuous Integration test shield, together with standard tests.
- The [mbed-HDK](https://github.com/ARMmbed/mbed-HDK) repository containing Hardware Development Kit resources - The [mbed-HDK](https://github.com/ARMmbed/mbed-HDK) repository containing Hardware Development Kit resources
including the schematics for the CI test shield. including the schematics for the CI test shield.
- [POSIX File Interface ISO/IEC 9899:TC2 Documentation](http://www.eng.utah.edu/~cs5785/slides-f10/n1124.pdf). - [POSIX File Interface ISO/IEC 9899:TC2 Documentation](http://www.eng.utah.edu/~cs5785/slides-f10/n1124.pdf).
- [FATFS: Generic FAT File System Module used in mbed OS](http://elm-chan.org/fsw/ff/00index_e.html) - [FATFS: Generic FAT File System Module used in mbed OS](http://elm-chan.org/fsw/ff/00index_e.html)