SOFBlock.cpp

00001 /*
00002 * @file SOFBlock.cpp
00003 * @author hillkim7@gmail.com
00004 *
00005 * @brief Simple storage implementation on internal MCU flash memory.
00006 *
00007 */
00008 
00009 #include "SOFBlock.h"
00010 #include <string.h>
00011 #include <stdlib.h>
00012 
00013 
00014 SOFBlock::SOFBlock()
00015     : hblock_(NULL)
00016 {
00017 }
00018 
00019 SOFBlock::~SOFBlock()
00020 {
00021     close();
00022 }
00023 
00024 void SOFBlock::close()
00025 {
00026     if (hblock_ != NULL) {
00027         SOF_block_close(hblock_);
00028         hblock_ = NULL;
00029     }
00030 }
00031 
00032 bool SOFBlock::format( uint8_t sector_index )
00033 {
00034     return SOF_block_format(sector_index);
00035 }
00036 
00037 bool SOFBlock::get_stat( uint8_t sector_index, SOF_Statics_t &statics )
00038 {
00039     return SOF_block_get_statics(sector_index, &statics) ==  kSOF_ErrNone;
00040 }
00041 
00042 SOFWriter::SOFWriter()
00043 {
00044 
00045 }
00046 
00047 SOFWriter::~SOFWriter()
00048 {
00049 
00050 }
00051 
00052 SOF_Error_t SOFWriter::open( uint8_t sector_index )
00053 {
00054     if (is_open()) {
00055         return kSOF_ErrBusyBlock;
00056     }
00057 
00058     SOF_Error_t err;
00059 
00060     hblock_ = SOF_block_create_storage(sector_index, &err);
00061 
00062     return err;
00063 }
00064 
00065 bool SOFWriter::write_byte_data( uint8_t c )
00066 {
00067     if (!is_open()) {
00068         return false;
00069     }
00070 
00071     return SOF_block_putc(hblock_, c);
00072 }
00073 
00074 size_t SOFWriter::write_data( const uint8_t *p, size_t p_size )
00075 {
00076     if (!is_open()) {
00077         return false;
00078     }
00079 
00080     return SOF_block_write(hblock_, p, p_size);
00081 }
00082 
00083 size_t SOFWriter::get_free_size()
00084 {
00085     if (!is_open()) {
00086         return 0;
00087     }
00088 
00089     return SOF_block_get_free_size(hblock_);
00090 }
00091 
00092 
00093 SOFReader::SOFReader()
00094 {
00095 
00096 }
00097 
00098 SOFReader::~SOFReader()
00099 {
00100 
00101 }
00102 
00103 SOF_Error_t SOFReader::open( uint8_t sector_index )
00104 {
00105     if (is_open()) {
00106         return kSOF_ErrBusyBlock;
00107     }
00108 
00109     SOF_Error_t err;
00110 
00111     hblock_ = SOF_block_open_storage(sector_index, &err);
00112 
00113     return err;
00114 }
00115 
00116 uint8_t * SOFReader::get_physical_data_addr()
00117 {
00118     if (!is_open()) {
00119         return NULL;
00120     }
00121 
00122     return SOF_block_base_addr(hblock_);
00123 }
00124 
00125 size_t SOFReader::get_data_size()
00126 {
00127     if (!is_open()) {
00128         return 0;
00129     }
00130 
00131     return SOF_block_storage_size(hblock_);
00132 }
00133 
00134 bool SOFReader::read_byte_data( uint8_t *c )
00135 {
00136     if (!is_open()) {
00137         return false;
00138     }
00139 
00140     return SOF_block_getc(hblock_, c);
00141 }
00142 
00143 size_t SOFReader::read_data( uint8_t *p, size_t p_size )
00144 {
00145     if (!is_open()) {
00146         return 0;
00147     }
00148 
00149     return SOF_block_read(hblock_, p, p_size);
00150 }
00151 
00152 
00153