Germany/embedded-framework
7
0
Fork 0
mirror of https://gitee.com/jiuyilian/embedded-framework.git synced 2025-01-06 10:16:51 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Improve:SD card event.

Browse Source
This commit is contained in:
Fancy code 2024-05-06 21:00:58 +08:00
parent d11518383a
commit 7abf2d7a76
17 changed files with 146 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
application/MissionManager/src/DataProcessing.h
View File

@ -23,6 +23,7 @@ using DataProcessingFunc = std::function<bool(VStateMachineData *)>;
enum class InternalStateEvent
{
STORAGE_HANDLE_STATE_INIT = static_cast<int>(MissionEvent::END),
SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED,
MEDIA_REPORT_EVENT,
END
};

8
application/MissionManager/src/MissionState.cpp
View File

@ -19,6 +19,8 @@
MissionState::MissionState(const std::string &name) : State(name)
{
mEventHandle[InternalStateEvent::MEDIA_REPORT_EVENT] = std::bind(&MissionState::MediaReportHandle, this, _1);
mEventHandle[InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED] =
std::bind(&MissionState::SdCardEventReportHandle, this, _1);
}
void MissionState::GoInState()
{
@ -37,4 +39,10 @@ bool MissionState::MediaReportHandle(VStateMachineData *msg)
MissionStateMachine::GetInstance()->DelayMessage(msg);
MissionStateMachine::GetInstance()->SwitchState(SystemState::STORAGE_HANDLE_STATE);
return EXECUTED;
}
bool MissionState::SdCardEventReportHandle(VStateMachineData *msg)
{
MissionStateMachine::GetInstance()->DelayMessage(msg);
MissionStateMachine::GetInstance()->SwitchState(SystemState::SD_CARD_HANDLE_STATE);
return EXECUTED;
}

1
application/MissionManager/src/MissionState.h
View File

@ -27,5 +27,6 @@ public:
private:
bool MediaReportHandle(VStateMachineData *msg);
bool SdCardEventReportHandle(VStateMachineData *msg);
};
#endif

4
application/MissionManager/src/MissionStateMachine.cpp
View File

@ -99,6 +99,10 @@ void MissionStateMachine::RunStateMachine(const IpcMission &mission)
mStateTree[SystemState::STORAGE_HANDLE_STATE].get());
mStateMachine->SetCurrentState(mStateTree[SystemState::TOP_STATE].get());
mStateMachine->StartStateMachine();
/**
* @brief The business can only be processed after the state machine is started.
*
*/
std::shared_ptr<VMissionData> message =
std::make_shared<VMissionData>(static_cast<MissionEvent>(InternalStateEvent::STORAGE_HANDLE_STATE_INIT));
SendStateMessage(message);

30
application/MissionManager/src/SdCardHandleState.cpp
View File

@ -17,9 +17,11 @@
#include "ILog.h"
#include "IMediaManager.h"
#include "MissionStateMachine.h"
SdCardHandleState::SdCardHandleState() : State("SdCardHandleState")
SdCardHandleState::SdCardHandleState() : State("SdCardHandleState"), mSdCardStatus(StorageEvent::END)
{
mEventHandle[InternalStateEvent::MEDIA_REPORT_EVENT] = std::bind(&SdCardHandleState::MediaReportHandle, this, _1);
mEventHandle[InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED] =
std::bind(&SdCardHandleState::SdCardEventHandle, this, _1);
}
void SdCardHandleState::GoInState()
{
@ -43,6 +45,15 @@ bool SdCardHandleState::MediaReportHandle(VStateMachineData *msg)
LogError("nullptr pointer.\n");
return NOT_EXECUTED;
}
if (StorageEvent::SD_CARD_INSERT != mSdCardStatus) {
/**
* @brief The SD card has not been mounted yet, cache the data for the quick start first.
*
*/
LogWarning("Sd card is not inserted, cache data.\n");
mFileNeedToSave = std::make_shared<SaveFileInfo>(data->mData.mFileName);
return EXECUTED;
}
LogInfo("file = %s.\n", data->mData.mFileName.c_str());
SaveFileInfo saveFileInfo(data->mData.mFileName);
StatusCode code = IFilesManager::GetInstance()->SaveFile(saveFileInfo);
@ -50,4 +61,21 @@ bool SdCardHandleState::MediaReportHandle(VStateMachineData *msg)
LogError("SaveFile failed.\n");
}
return EXECUTED;
}
bool SdCardHandleState::SdCardEventHandle(VStateMachineData *msg)
{
std::shared_ptr<MissionMessage> message = std::dynamic_pointer_cast<MissionMessage>(msg->GetMessageObj());
std::shared_ptr<VMissionDataV2<StorageEvent>> data =
std::dynamic_pointer_cast<VMissionDataV2<StorageEvent>>(message->mMissionData);
LogInfo(" SdCardEventHandle event:%s.\n", IStorageManager::GetInstance()->PrintStringStorageEvent(data->mData));
if (mFileNeedToSave && StorageEvent::SD_CARD_INSERT == data->mData) {
LogInfo("Sd card is inserted for the first time.\n");
StatusCode code = IFilesManager::GetInstance()->SaveFile(*(mFileNeedToSave.get()));
if (IsCodeOK(code) == false) {
LogError("SaveFile failed.\n");
}
mFileNeedToSave.reset();
}
mSdCardStatus = data->mData;
return EXECUTED;
}

7
application/MissionManager/src/SdCardHandleState.h
View File

@ -17,6 +17,8 @@
#include "DataProcessing.h"
#include "IMediaManager.h"
#include "IStateMachine.h"
#include "IStorageManager.h"
#include "IFilesManager.h"
class SdCardHandleState : public State, public DataProcessing, public std::enable_shared_from_this<SdCardHandleState>
{
public:
@ -28,5 +30,10 @@ public:
private:
bool MediaReportHandle(VStateMachineData *msg);
bool SdCardEventHandle(VStateMachineData *msg);
private:
StorageEvent mSdCardStatus;
std::shared_ptr<SaveFileInfo> mFileNeedToSave;
};
#endif

3
application/MissionManager/src/StorageHandleState.cpp
View File

@ -45,6 +45,9 @@ void StorageHandleState::UnInit(void)
void StorageHandleState::ReportEvent(const StorageEvent &event)
{
LogInfo("StorageHandleState::ReportEvent.\n");
std::shared_ptr<VMissionData> message = std::make_shared<VMissionDataV2<StorageEvent>>(
static_cast<MissionEvent>(InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED), event);
MissionStateMachine::GetInstance()->SendStateMessage(message);
}
bool StorageHandleState::StorageStartInitHandle(VStateMachineData *msg)
{

4
hal/include/IHalCpp.h
View File

@ -34,7 +34,9 @@ enum class SdCardHalStatus
MOUNTED = 0,
UNMOUNTED,
INSERTED,
PULL_OUT,
PULL_OUT_DEVICE_NOT_EXIST,
PULL_OUT_OPEN_FAILED,
PULL_OUT_NOT_BLOCK_DEVICE,
ERROR,
END
};

57
hal/src/SdCardHal.cpp
View File

@ -24,10 +24,8 @@
#include <sys/types.h>
#include <unistd.h>
const char *SD_CARD_DEVICE = SD_CARD_DEV;
SdCardHal::SdCardHal()
SdCardHal::SdCardHal() : mStatus(SdCardHalStatus::END), mThreadRuning(false), mDeviceFd(-1)
{
mThreadRuning = false;
mStatus = SdCardHalStatus::END;
}
void SdCardHal::SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor)
{
@ -57,35 +55,52 @@ void SdCardHal::UnInit(void)
void SdCardHal::DevDetectingThread(void)
{
constexpr int SLEEP_TIME_MS = 100;
constexpr int DEVICE_EXIST = 0;
// SdCardHalStatus status = SdCardHalStatus::END;
int fd = -1;
// const char *SD_CARD_DEVICE = "/SD_CARD_DEVICE/mmcblk1p1";
mThreadRuning = true;
while (mThreadRuning) {
fd = fx_open(SD_CARD_DEVICE, O_RDONLY);
if (fd < 0) {
// LogInfo("sdCardHal: %s open failed.\n", SD_CARD_DEVICE);
if (SdCardHalStatus::PULL_OUT != mStatus) {
mStatus = SdCardHalStatus::PULL_OUT;
if (access(SD_CARD_DEVICE, F_OK) != DEVICE_EXIST) {
if (SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST != mStatus) {
mStatus = SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST;
ReportDetecedChangedResult(mStatus);
}
if (mDeviceFd > 0) {
close(mDeviceFd);
mDeviceFd = -1;
}
goto CONTINUE;
}
if (mDeviceFd < 0) {
mDeviceFd = fx_open(SD_CARD_DEVICE, O_RDONLY);
if (mDeviceFd < 0) {
// LogInfo("sdCardHal: %s open failed.\n", SD_CARD_DEVICE);
if (SdCardHalStatus::PULL_OUT_OPEN_FAILED != mStatus) {
mStatus = SdCardHalStatus::PULL_OUT_OPEN_FAILED;
ReportDetecedChangedResult(mStatus);
}
goto CONTINUE;
}
}
struct stat sdStat;
if (fx_fstat(fd, &sdStat) < 0) {
if (fx_fstat(mDeviceFd, &sdStat) < 0) {
// LogInfo("sdCardHal: %s fstat failed.\n", SD_CARD_DEVICE);
if (SdCardHalStatus::ERROR != mStatus) {
mStatus = SdCardHalStatus::ERROR;
ReportDetecedChangedResult(mStatus);
}
close(mDeviceFd);
mDeviceFd = -1;
goto CONTINUE;
}
if (!S_ISBLK(sdStat.st_mode)) {
// LogInfo("sdCardHal: %s is not block device.\n", SD_CARD_DEVICE);
if (SdCardHalStatus::PULL_OUT != mStatus) {
mStatus = SdCardHalStatus::PULL_OUT;
if (SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE != mStatus) {
mStatus = SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE;
ReportDetecedChangedResult(mStatus);
}
close(mDeviceFd);
mDeviceFd = -1;
}
else {
// LogInfo("sdCardHal: %s is inserted.\n", SD_CARD_DEVICE);
@ -97,22 +112,32 @@ void SdCardHal::DevDetectingThread(void)
CONTINUE:
std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
}
if (mDeviceFd > 0) {
close(mDeviceFd);
mDeviceFd = -1;
}
}
void SdCardHal::ReportDetecedChangedResult(const SdCardHalStatus &status)
{
LogInfo("SdCardHalStatus changed: %s.\n", PrintfStatusString(status));
SdCardHalStatus mountedStatus = SdCardHalStatus::END;
if (SdCardHalStatus::INSERTED == status) {
LogInfo("mount sd SD_CARD_DEVICE %s.\n", SD_CARD_MOUNT_PATH);
constexpr int BUF_LENGTH = 128;
char cmd[BUF_LENGTH] = {0};
snprintf(cmd, BUF_LENGTH, "mount %s %s", SD_CARD_DEV, SD_CARD_MOUNT_PATH);
fx_system(cmd);
mountedStatus = SdCardHalStatus::MOUNTED;
}
auto monitor = mMonitor.lock();
if (mMonitor.expired()) {
LogWarning("SdCardHal: monitor is expired.\n");
return;
}
if (SdCardHalStatus::END != mountedStatus) {
monitor->ReportEvent(mountedStatus);
return;
}
monitor->ReportEvent(status);
}
const char *SdCardHal::PrintfStatusString(const SdCardHalStatus &status)
@ -124,8 +149,12 @@ const char *SdCardHal::PrintfStatusString(const SdCardHalStatus &status)
return "UNMOUNTED.";
case SdCardHalStatus::INSERTED:
return "INSERTED.";
case SdCardHalStatus::PULL_OUT:
return "PULL_OUT.";
case SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST:
return "PULL_OUT_DEVICE_NOT_EXIST.";
case SdCardHalStatus::PULL_OUT_OPEN_FAILED:
return "PULL_OUT_OPEN_FAILED.";
case SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE:
return "PULL_OUT_NOT_BLOCK_DEVICE.";
case SdCardHalStatus::END:
return "END.";
default:

1
hal/src/SdCardHal.h
View File

@ -36,5 +36,6 @@ private:
bool mThreadRuning;
std::thread mDevDetectingThread;
std::weak_ptr<VSdCardHalMonitor> mMonitor;
int mDeviceFd;
};
#endif

1
middleware/StorageManager/include/IStorageManager.h
View File

@ -43,5 +43,6 @@ public:
virtual StatusCode UnInit(void);
virtual StatusCode SetMonitor(std::shared_ptr<VStorageMoniter> &monitor);
virtual StatusCode SaveFile(const std::string &sourceFile, const std::string &savePaht);
virtual const char *PrintStringStorageEvent(const StorageEvent &event);
};
#endif

4
middleware/StorageManager/src/IStorageManager.cpp
View File

@ -46,4 +46,8 @@ StatusCode IStorageManager::SetMonitor(std::shared_ptr<VStorageMoniter> &monitor
StatusCode IStorageManager::SaveFile(const std::string &sourceFile, const std::string &savePaht)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
const char *IStorageManager::PrintStringStorageEvent(const StorageEvent &event)
{
return "STATUS_CODE_VIRTUAL_FUNCTION";
}

4
middleware/StorageManager/src/SdCardHandle.cpp
View File

@ -69,7 +69,9 @@ StorageEvent SdCardHandle::StorageEventConvert(const SdCardHalStatus &status)
return StorageEvent::SD_CARD_REMOVE;
case SdCardHalStatus::INSERTED:
return StorageEvent::SD_ABNORMAL;
case SdCardHalStatus::PULL_OUT:
case SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST:
case SdCardHalStatus::PULL_OUT_OPEN_FAILED:
case SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE:
return StorageEvent::SD_CARD_REMOVE;
case SdCardHalStatus::ERROR:
return StorageEvent::SD_ABNORMAL;

30
middleware/StorageManager/src/StorageBase.cpp
View File

@ -58,4 +58,34 @@ bool StorageBase::CheckDirectory(const char *filepath)
// TODO: check if files exist finally here.
free(path);
return true;
}
const char *StorageBase::PrintStringStorageEvent(const StorageEvent &event)
{
switch (event) {
case StorageEvent::SD_CARD_INSERT: {
return "SD_CARD_INSERT";
break;
}
case StorageEvent::SD_CARD_REMOVE: {
return "SD_CARD_REMOVE";
break;
}
case StorageEvent::SD_ABNORMAL: {
return "SD_ABNORMAL";
break;
}
case StorageEvent::EMMC_NORMAL: {
return "EMMC_NORMAL";
break;
}
case StorageEvent::END: {
return "END";
break;
}
default: {
return "UNDEFINE";
break;
}
}
}

3
middleware/StorageManager/src/StorageBase.h
View File

@ -23,6 +23,9 @@ public:
virtual ~StorageBase() = default;
bool CheckDirectory(const char *filepath);
protected:
const char *PrintStringStorageEvent(const StorageEvent &event);
protected:
std::weak_ptr<VStorageMoniter> mStorageMonitor;
};

4
middleware/StorageManager/src/StorageManagerImpl.cpp
View File

@ -33,4 +33,8 @@ StatusCode StorageManagerImpl::SetMonitor(std::shared_ptr<VStorageMoniter> &moni
StatusCode StorageManagerImpl::SaveFile(const std::string &sourceFile, const std::string &savePaht)
{
return SdCardHandle::SdSaveFile(sourceFile, savePaht);
}
const char *StorageManagerImpl::PrintStringStorageEvent(const StorageEvent &event)
{
return StorageBase::PrintStringStorageEvent(event);
}

1
middleware/StorageManager/src/StorageManagerImpl.h
View File

@ -27,5 +27,6 @@ public:
StatusCode UnInit(void) override;
StatusCode SetMonitor(std::shared_ptr<VStorageMoniter> &monitor) override;
StatusCode SaveFile(const std::string &sourceFile, const std::string &savePaht) override;
const char *PrintStringStorageEvent(const StorageEvent &event) override;
};
#endif