sani7/2023-Webservices_And_Applications
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'main' into Modbus_TCP_Obe

Browse Source
This commit is contained in:
Obe Van Lierde
2023-11-13 12:48:00 +01:00
parent 1349bd003d 2ef4f6b520
commit 4fe3e5b8d9
14 changed files with 3267 additions and 6611 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
.gitignore vendored
View File

@@ -31,6 +31,18 @@
*.out
*.app
# Log files
*.log
# Metadata directories
.metadata/
project/.metadata
# Test files
project/Core/Inc/stlogo.h
project/Core/Inc/test_img.h
project/Core/Inc/test_data.h
project/Debug/
project/.idea/
@@ -43,4 +55,6 @@ project/.mxproject
project/project.launch
project/.cproject
project/Scripts
Scripts/
project/project\ Debug.launch

92
docs/lcd_api.md Normal file
View File

@@ -0,0 +1,92 @@
# LCD API
## Introduction
The LCD API can be used to display BMP images or text onto the LCD screen.
At the moment of writing, only BMP's in C array's are supported.
Supported color schemes for BMP's are ARGB8888, RGB565, RGB888.
Displayed text that is exceeds the LCD width size, will be wrapped onto the next line and a '-' character will be injected if the wrap occurs within a word.
## Usage of LCD API
### Generating BMP C header files
#### Resizing images
To resize an image to the desired size (width and height), one can use an image editor such as Photoshop, GIMP, ImageMagick, ... .
For example, using ImageMagick:
```bash
convert in.png -resize 10% BMP3:out.bmp
#OR (depending on the version of ImageMagick)
magick in.png -resize 50x50 out.png
```
The resize option can both be used to resize in percentages or in pixels.
The BMP3 option is used to convert the PNG to Bitmap version 3.0 (note that the BMP header will still be present in the output image).
#### Generating the C array
To easily generate a BMP C array (in the desired color scheme) from an image, [lv_img_conv](https://github.com/lvgl/lv_img_conv) can be used.
See the installation instructions on Github or use the [online version](https://lvgl.io/tools/imageconverter).
Example:
```bash
./lv_img_conv.js test.png -f -c CF_TRUE_COLOR
```
The command above will generate a .c file in which arrays can be found for RGB332, RGB565, ARGB8888. It is also possible to generate a binary BMP image file in ARGB8332, ARGB8565, ARGB8565_RBSWAP, ARGB8888.
```bash
./lv_img_conv.js logo_lvgl.png -f -c CF_TRUE_COLOR -t bin --binary-format ARGB8888
```
### Using the LCD API
#### Initialization of LCD API
The `lcd_init(bool bl_on)` function initialises the LCD screen. The `bl_on` variable allows to enable or disable the LCD backlight.
```c
#include "lcd_api.h"
...
void main(void) {
...
lcd_init(true);
...
}
```
#### Drawing text on the screen
```c
void lcd_display_text(const char* text, uint16_t x_pos, uint16_t y_pos, uint32_t color, uint32_t bg_color, sFONT *font);
```
```c
#include "lcd_api.h"
...
void main(void) {
...
lcd_init(true);
...
lcd_display_text("This is a text string.", 10, 10, LCD_GREEN, LCD_BLACK, LCD_FONT16);
}
```
Display text on the LCD screen in a certain color. When text width exceeds BSP_LCD_GetXSize(), a text wrap will be performed. If the text wrap is between two will be injected.
#### Drawing a BMP (C-array) onto the screen
```c
void lcd_draw_bmp(const void* p_src, uint32_t x_pos, uint32_t y_pos, uint32_t x_size, uint32_t y_size, uint32_t color_mode);
```
```c
#include "lcd_api.h"
#include "test_image.h"
void main(void) {
...
lcd_init(true);
...
lcd_draw_bmp(bmp_array, 0, 0, 50, 50, LCD_ARGB8888);
}
```
Draw BMP image from C array to the LCD screen at position X, Y. In color mode ARGB8888, RGB888, RGB565 or ARGB1555 Supports ARGB8888, RGB565, RGB888 (see LCD_* defines in header file).

116
docs/llfs.md
View File

@@ -1,17 +1,52 @@
# LLFS (Linked List File System)
## Introduction
The llfs filesystem can be generated using the mkllfss utility.
It is a simple filesystem that uses a linked list to store files.
The filesystem is stored in a single c file (`llfs_data.c`), which can be compiled and read by the llfs library.
The llfs filesystem is a flat filesystem, meaning that it does not support directories.
The llfs filesystem can be generated using the [mkllfs](mkllfs.md) utility.
The resulting C file encapsulates the filesystem data within a linked list which can be used by the llfs library.
As a flat filesystem, llfs lacks support for directories.
Using the llfs API, information about the files in the filesystem can be retrieved,
and the files can be read using direct memory access.
Alternatively, the POSIX file functions can be used.
But this is more resource intensive, as data must be copied before using it.
It's essential to note that the llfs filesystem operates in a read-only mode,
restricting operations solely to read functions.
## Table of contents
- [Introduction](#introduction)
- [Table of contents](#table-of-contents)
- [Initialization](#initialization)
- [Usage of the llfs API](#usage-of-the-llfs-api)
- [The `llfs_file_t` struct](#the-llfs_file_t-struct)
- [Getting a list of files](#getting-a-list-of-files)
- [Iterator function (not recommended)](#iterator-function-not-recommended)
- [Reading a file](#reading-a-file)
- [Getting the number of files](#getting-the-number-of-files)
- [Using the POSIX file functions](#using-the-posix-file-functions)
## Initialization
Before using the llfs API, or the file related POSIX (fopen, fgetc, ...) functions, the filesystem must be initialized by calling `llfs_init()`.
## Usage of the llfs API
### The `llfs_file_t` struct
The `llfs_file_t` struct contains information about a file in the filesystem.
```c
typedef struct {
const uint8_t* data; // Pointer to the file data (len bytes)
const char* name; // Null-terminated string with the filename
size_t len; // Length of the file data
} llfs_file_t;
```
The data pointer points to the data of the file in the filesystem, and can be used to read the file.
### Getting a list of files
```c
#include "llfs.h"
void main(void) {
llfs_init();
// Allocate space for 10 files
llfs_file_t file_list[10];
@@ -33,13 +68,50 @@ Result:
[Info] (2031) [main]: File: file1.txt, size: 77
```
It is also possible to use a file extension filter (e.g. `*.bmp`, `*.txt`, `*.py`).
```c
// ...
size_t file_count = llfs_file_list(file_list, 10, "*.bmp");
// ...
```
This will only return files with the `.bmp` extension.
````
[Info] (2009) [main]: File: image.bmp, size: 9270
[Info] (2019) [main]: File: image2.bmp, size: 7738
````
#### Iterator function (not recommended)
It is also possible to iterate through the files without allocating an array.
When the memory pointer is `NULL`, the iterator will start at the beginning of the file list.
Each call to `llfs_next_file()` will return the next file in the list,
if a filter is specified files that don't match the filter will be skipped.
```c
#include "llfs.h"
void main(void) {
llfs_init();
// Get the file list
void* mem = NULL; // Pointer for internal use by the llfs library
llfs_file_t* file;
while ((file = llfs_next_file(&mem, ".bmp")) != NULL) {
LOG_INFO(TAG, "File: %s", file->name);
}
}
```
While this method doesn't require allocating memory for the file list,
it is slower than the previous method due to the overhead calling the function for each file.
Additionally, the required memory for the filelist is very small, so it's recommended to use the first method.
### Reading a file
```c
#include "llfs.h"
void main(void) {
llfs_init();
// Get a file by name
llfs_file_t *file = llfs_file_open("filename with a space.txt");
llfs_file_t* file = llfs_file_open("filename with a space.txt");
if (file != NULL) {
// Print the file name, size and data
@@ -55,3 +127,37 @@ Result:
[Info] (2040) [main]: File found: filename with a space.txt, size: 61
[Info] (2047) [main]: File data: This is a file with a space in it's filename.
```
### Getting the number of files
```c
#include "llfs.h"
void main(void) {
llfs_init();
// Get the number of files
size_t file_count = llfs_file_count();
// Print the number of files
LOG_INFO(TAG, "File count: %d", file_count);
}
```
## Using the POSIX file functions
The llfs library also supports the POSIX file functions.
As the file system is read-only, write functions are not implemented.
There is also a limit on the number of files that can be open concurrently,
this is set by the `POSIX_MAX_FILES` macro in `llfs.c`.
The default value is 10, but there are already 3 files in use (stdin, stdout, stderr),
so the maximum number of files that can be open is 7.
The following functions are tested and working, but other functions might also work:
- `fopen`
- `fclose`
- `fgetc`
- `fread`
- `fseek`
- `ftell`
- `rewind`
- `fstat`
- `fileno`

8845
project/Core/Inc/fsdata_custom.c
View File

File diff suppressed because it is too large Load Diff

98
project/Core/Inc/lcd_api.h Normal file
View File

@@ -0,0 +1,98 @@
/**
* @file lcd_api.h
* @brief API for LCD functionality
* @author Tim S.
*/
#ifndef INC_LCD_API_H_
#define INC_LCD_API_H_
#include <stdbool.h>
#include <string.h>
#include <ctype.h>
#define LOGGER_LEVEL_ALL
#include "log.h"
#include "../../Drivers/BSP/STM32746G-Discovery/stm32746g_discovery_lcd.h"
#define LCD_BLUE LCD_COLOR_BLUE
#define LCD_GREEN LCD_COLOR_GREEN
#define LCD_RED LCD_COLOR_RED
#define LCD_CYAN LCD_COLOR_CYAN
#define LCD_MAGENTA LCD_COLOR_MAGENTA
#define LCD_YELLOW LCD_COLOR_YELLOW
#define LCD_LIGHTBLUE LCD_COLOR_LIGHTBLUE
#define LCD_LIGHTGREEN LCD_COLOR_LIGHTGREEN
#define LCD_LIGHTRED LCD_COLOR_LIGHTRED
#define LCD_LIGHTCYAN LCD_COLOR_LIGHTCYAN
#define LCD_LIGHTMAGENTA LCD_COLOR_LIGHTMAGENTA
#define LCD_LIGHTYELLOW LCD_COLOR_LIGHTYELLOW
#define LCD_DARKBLUE LCD_COLOR_DARKBLUE
#define LCD_DARKGREEN LCD_COLOR_DARKGREEN
#define LCD_DARKRED LCD_COLOR_DARKRED
#define LCD_DARKCYAN LCD_COLOR_DARKCYAN
#define LCD_DARKMAGENTA LCD_COLOR_DARKMAGENTA
#define LCD_DARKYELLOW LCD_COLOR_DARKYELLOW
#define LCD_WHITE LCD_COLOR_WHITE
#define LCD_LIGHTGRAY LCD_COLOR_LIGHTGRAY
#define LCD_GRAY LCD_COLOR_GRAY
#define LCD_DARKGRAY LCD_COLOR_DARKGRAY
#define LCD_BLACK LCD_COLOR_BLACK
#define LCD_BROWN LCD_COLOR_BROWN
#define LCD_ORANGE LCD_COLOR_ORANGE
#define LCD_TRANSPARENT LCD_COLOR_TRANSPARENT
#define LCD_ARGB8888 0x00000000U
#define LCD_RGB888 0x00000001U
#define LCD_RGB565 0x00000002U
#define LCD_ARGB1555 0x00000003U
#define LCD_FONT8 &Font8
#define LCD_FONT12 &Font12
#define LCD_FONT16 &Font16
#define LCD_FONT20 &Font20
#define LCD_FONT24 &Font24
extern LTDC_HandleTypeDef hLtdcHandler;
/**
* @brief Initialise LCD
* Initialise the LCD screen with BackLight on or not
*
* @param[in] bl_on Bool to enable or disable the LCD backlight
*
*/
void lcd_init(bool bl_on);
/**
* @brief Display text
* Display text on the LCD screen in a certain color. When text width exceeds BSP_LCD_GetXSize(),
* a text wrap will be performed. If the text wrap is between two letters in a word, the '-' character
* will be injected.
*
* @param[in] text C-style text string to display on the LCD screen
* @param[in] x_pos X-position
* @param[in] y_pos Y-position
* @param[in] color Color in which the text will be displayed, see preset colors in defines above
* @param[in] bg_color Background color for the text
* @param[in] font Font size, see defines above in file
*/
void lcd_display_text(uint8_t* text, uint16_t x_pos, uint16_t y_pos, uint32_t color, uint32_t bg_color, sFONT *font);
/**
* @brief Draw BMP image on screen
* Draw BMP image from C array to the LCD screen at position X, Y. In color mode ARGB8888, RGB888, RGB565 or ARGB1555
* Supports ARGB8888, RGB565, RGB888
*
* @author Wim Dams
*
* @param[in] p_src C array containing the image data
* @param[in] x_pos X-position
* @param[in] y_pos Y-position
* @param[in] x_size Width of image
* @param[in] y_size Height of image
* @param[in] color_mode Color mode (see defined color modes above in file)
*/
void lcd_draw_bmp(const void* p_src, uint32_t x_pos, uint32_t y_pos, uint32_t x_size, uint32_t y_size, uint32_t color_mode);
#endif /* INC_LCD_API_H_ */

33
project/Core/Inc/llfs.h
View File

@@ -2,6 +2,7 @@
* @file llfs.h
* @brief Linked List Filesystem header (llfs)
* @author Lorenz C.
* @version 0.1.1
*/
#ifndef LLFS_H
@@ -30,20 +31,25 @@ struct llfs_data_file {
const struct llfs_data_file* next;
};
/**
* @brief Initialize the llfs filesystem
* @note This function should be called before any other llfs function or POSIX file operation (e.g. fopen, fread, ...)
* @return 0 on success
*/
int8_t llfs_init(void);
/**
* @brief Get a list of files in the filesystem
* Get a list of all the files in the filesystem.
*
* Use the filter to filter out files with a filename that do not match the filter. (e.g. "*.txt" or "*.png|*.jpg") (not
* implemented yet) Multiple filters can be used by separating them with a pipe (|).
* Use the filter to filter out files with a filename that do not match the file extension filter.
*
* The following members of the llfs_file_t struct are set: name, len and data. @ref llfs_file_t
*
* @todo Implement file filter
*
* @param[out] file_list A pointer to an array of llfs_file_t to store the files in @ref llfs_file_t
* @param[in] max_files The maximum number of files to return (size of file_list)
* @param[in] filter A string with file extensions to filter out. (e.g. "*.txt" or "*.png|*.jpg")
* @param[in] filter A string with the file extensions to filter out. (e.g. "*.txt" or "*.png")
* @return The number of files returned
*/
size_t llfs_file_list(llfs_file_t* file_list, size_t max_files, char* filter);
@@ -58,4 +64,23 @@ size_t llfs_file_list(llfs_file_t* file_list, size_t max_files, char* filter);
*/
llfs_file_t* llfs_file_open(const char* name);
/**
* @brief Iterate over all files in the filesystem
* For each call (with the same mem pointer) the next file in the filesystem is returned.
* The first call should be with mem = NULL.
* If a filter is specified, only files with a filename that matches the filter are returned.
*
* @param[in, out] mem A pointer to a void* that is used internally to keep track of the current file
* @param[in] filter A string with file extension to filter out. (e.g. "*.txt" or "*.png")
* @return The next file in the filesystem or NULL if there are no more files @ref llfs_file_t
*/
llfs_file_t* llfs_next_file(void** mem, char* filter);
/**
* @brief Get the number of files in the filesystem
*
* @return The number of files in the filesystem
*/
size_t llfs_file_count(void);
#endif // LLFS_H

1
project/Core/Inc/main.h
View File

@@ -31,6 +31,7 @@ extern "C" {
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "../../Drivers/BSP/STM32746G-Discovery/stm32746g_discovery_lcd.h"
/* USER CODE END Includes */

97
project/Core/Src/lcd_api.c Normal file
View File

@@ -0,0 +1,97 @@
/**
* @file lcd_api.c
* @brief LCD API implementation
* @author Tim S.
* @todo Implement function to read images from fs
*/
#include "lcd_api.h"
static const char* TAG = "lcd_api";
static DMA2D_HandleTypeDef hDma2dHandler2;
void lcd_init(bool bl_on) {
LOG_INFO(TAG, "Init LCD");
BSP_LCD_Init();
BSP_LCD_LayerDefaultInit(1, LCD_FB_START_ADDRESS);
BSP_LCD_LayerDefaultInit(0, LCD_FB_START_ADDRESS + (BSP_LCD_GetXSize()*BSP_LCD_GetYSize()*4));
BSP_LCD_SelectLayer(0);
BSP_LCD_Clear(LCD_COLOR_BLACK);
BSP_LCD_SelectLayer(1);
BSP_LCD_Clear(LCD_COLOR_BLACK);
if (bl_on) {
HAL_GPIO_WritePin(GPIOK, GPIO_PIN_3, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_12, GPIO_PIN_SET);
} else {
HAL_GPIO_WritePin(GPIOK, GPIO_PIN_3, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_12, GPIO_PIN_RESET);
}
}
void lcd_display_text(uint8_t* text, uint16_t x_pos, uint16_t y_pos, uint32_t color, uint32_t bg_color, sFONT *font) {
LOG_INFO(TAG, "Display text: %s @x=%d,y=%d", text, x_pos, y_pos);
uint16_t tot_length = x_pos + (strlen(text) * font->Width);
if ((x_pos % font->Width) != 0) {
x_pos -= (x_pos % font->Width);
}
BSP_LCD_SetTextColor(color);
BSP_LCD_SetBackColor(bg_color);
BSP_LCD_SetFont(font);
if (tot_length > BSP_LCD_GetXSize()) {
for (int i = 0; i < strlen(text); i++) {
if ((x_pos) > BSP_LCD_GetXSize() - (font->Width)*2) {
if (isalpha(text[i-1]) && isalpha(text[i])) {
BSP_LCD_DisplayChar(x_pos, y_pos, '-');
i -= 1;
}
x_pos = 0;
y_pos += font->Height;
} else {
BSP_LCD_DisplayChar(x_pos, y_pos, text[i]);
x_pos += font->Width;
}
}
} else {
BSP_LCD_DisplayStringAt(x_pos, y_pos, text, LEFT_MODE);
}
}
void lcd_draw_bmp(const void* p_src, uint32_t x_pos, uint32_t y_pos, uint32_t x_size, uint32_t y_size, uint32_t color_mode) {
uint32_t address = hLtdcHandler.LayerCfg[1].FBStartAdress + (((BSP_LCD_GetXSize()*y_pos) + x_pos)*(4));
void *p_dst = (void *)address;
hDma2dHandler2.Init.Mode = DMA2D_M2M_PFC;
hDma2dHandler2.Init.ColorMode = DMA2D_ARGB8888;
hDma2dHandler2.Init.OutputOffset = BSP_LCD_GetXSize()-x_size;
hDma2dHandler2.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hDma2dHandler2.LayerCfg[1].InputAlpha = 0xFF;
hDma2dHandler2.LayerCfg[1].InputColorMode = color_mode;
hDma2dHandler2.LayerCfg[1].InputOffset = 0;
LOG_INFO(TAG, "DMA2D init");
hDma2dHandler2.Instance = DMA2D;
if (HAL_DMA2D_Init(&hDma2dHandler2) != HAL_OK) {
LOG_CRIT(TAG, "HAL_DMA2D_Init error");
return;
}
LOG_INFO(TAG, "DMA2D config layer");
if (HAL_DMA2D_ConfigLayer(&hDma2dHandler2, 1) != HAL_OK) {
LOG_CRIT(TAG, "HAL_DMA2D_ConfigLayer error");
return;
}
LOG_INFO(TAG, "DMA2D start");
if (HAL_DMA2D_Start(&hDma2dHandler2, (uint32_t)p_src, (uint32_t)p_dst, x_size, y_size) != HAL_OK) {
LOG_CRIT(TAG, "HAL_DMA2D_Start error");
return;
}
LOG_INFO(TAG, "DMA2D poll");
HAL_DMA2D_PollForTransfer(&hDma2dHandler2, 10);
}

408
project/Core/Src/llfs.c
View File

@@ -2,34 +2,82 @@
* @file llfs.c
* @brief Linked List Filesystem implementation (llfs)
* @author Lorenz C.
* @todo Implement file extension filter
* @version 0.1.1
*/
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#define LOGGER_LEVEL_WARN
#include "llfs.h"
#include "log.h"
/**
* @brief The maximum number of files that can be opened concurrently using the POSIX API
*/
#define POSIX_MAX_FILES 10
extern struct llfs_data_file* llfs_root;
const char* TAG = "llfs";
size_t file_count = 0;
FILE* file_table[POSIX_MAX_FILES];
static int new_file_table_entry(void);
static int free_file_table_entry(int file_id);
static FILE* file_id_to_stream(int file_id);
static uint8_t file_ext_cmp(const char* filename, const char* ext);
int8_t llfs_init(void) {
LOG_DEBUG(TAG, "Initializing llfs");
// Initialize the file table
for (int i = 0; i < POSIX_MAX_FILES; i++) {
file_table[i] = NULL;
}
// Add stdin, stdout and stderr to the file table
file_table[STDIN_FILENO] = stdin;
file_table[STDOUT_FILENO] = stdout;
file_table[STDERR_FILENO] = stderr;
return 0;
}
// TODO: Implement file extension filter
size_t llfs_file_list(llfs_file_t* file_list, size_t max_files, char* filter) {
size_t file_count = 0;
const struct llfs_data_file* file = llfs_root;
size_t count = 0; // Number of files found
const struct llfs_data_file* file = llfs_root; // Pointer to the current file
LOG_DEBUG(TAG, "Getting file list with filter: %s", filter);
if (filter != NULL) {
LOG_DEBUG(TAG, "Filtering files with filter: %s", filter);
if (filter[0] == '*') {
filter++;
}
}
// Iterate over all files in the filesystem
while (file != NULL && file_count < max_files) {
file_list[file_count].data = file->data;
file_list[file_count].name = file->name;
file_list[file_count].len = file->len;
file_count++;
// Filter out files with a filename that does not match the filter
if (filter != NULL) {
if (!file_ext_cmp(file->name, filter)) {
file = file->next;
continue;
}
}
// Add the file to the file list
file_list[count].data = file->data;
file_list[count].name = file->name;
file_list[count].len = file->len;
// Move to the next file
count++;
file = file->next;
}
LOG_DEBUG(TAG, "Files found: %d", file_count);
return file_count;
LOG_DEBUG(TAG, "Files found: %d", count);
return count;
}
llfs_file_t* llfs_file_open(const char* name) {
@@ -48,3 +96,341 @@ llfs_file_t* llfs_file_open(const char* name) {
LOG_DEBUG(TAG, "File not found: %s", name);
return NULL;
}
llfs_file_t* llfs_next_file(void** mem, char* filter) {
struct llfs_data_file* prev_file = (struct llfs_data_file*)*mem;
uint8_t filter_ok = 0;
if (prev_file == NULL) {
prev_file = llfs_root;
} else {
prev_file = (struct llfs_data_file*)prev_file->next;
}
// If a filter is specified, only return files that match the filter
if (filter != NULL) {
LOG_DEBUG(TAG, "Filtering files with filter: %s", filter);
// Remove the '*' from the filter
if (filter[0] == '*') {
filter++;
}
while (prev_file != NULL) {
if (file_ext_cmp(prev_file->name, filter)) {
filter_ok = 1;
break;
}
prev_file = (struct llfs_data_file*)prev_file->next;
}
}
*mem = (void*)prev_file;
return (llfs_file_t*)prev_file;
}
size_t llfs_file_count(void) {
if (file_count == 0) {
const struct llfs_data_file* file = llfs_root;
while (file != NULL) {
file_count++;
file = file->next;
}
}
return file_count;
}
/**
* @brief Newlib open implementation
*
* @param path
* @param flags
* @param mode
* @return
*/
int _open(char* path, int flags, int mode) {
int file_id;
FILE* stream;
errno = 0;
llfs_file_t* llfs_file;
// Add a new entry to the file table
file_id = new_file_table_entry();
if (file_id < 0) {
LOG_WARN(TAG, "Failed to add new file table entry. %s", strerror(errno));
return -1;
}
// Get the stream associated with the file id
stream = file_id_to_stream(file_id);
if (stream == NULL) {
LOG_WARN(TAG, "Failed to get file table entry. %s", strerror(errno));
free_file_table_entry(file_id);
return -1;
}
// Get the file from the llfs filesystem
llfs_file = llfs_file_open(path);
if (llfs_file == NULL) {
LOG_DEBUG(TAG, "Failed to open file: %s", path);
free_file_table_entry(file_id);
return -1;
}
// Initialize the stream
stream->_cookie = (void*)llfs_file;
stream->_offset = 0;
stream->_flags = __SRD;
return file_id;
}
/**
* @brief Newlib close implementation
*
* @param file_id
* @return
*/
int _close(int file_id) {
FILE* stream;
// Get the stream associated with the file id
stream = file_id_to_stream(file_id);
if (stream == NULL) {
LOG_WARN(TAG, "Failed to get file table entry. %s", strerror(errno));
return -1;
}
// Remove the entry from the file table
if (free_file_table_entry(file_id) < 0) {
LOG_WARN(TAG, "Failed to remove file table entry. %s", strerror(errno));
return -1;
}
return 0;
}
/**
* @brief Newlib read implementation
*
* @param file_id
* @param ptr
* @param len
* @return
*/
int _read(int file_id, char* ptr, int len) {
FILE* stream;
llfs_file_t* llfs_file;
size_t bytes_read;
// Read from stdin, stdout and stderr is not supported
if (file_id == STDIN_FILENO || file_id == STDOUT_FILENO || file_id == STDERR_FILENO) {
LOG_DEBUG(TAG, "Trying to read from stdin, stdout or stderr: %d", file_id);
return -1;
}
// Get the stream associated with the file id
stream = file_id_to_stream(file_id);
if (stream == NULL) {
LOG_WARN(TAG, "Failed to get file table entry. %s", strerror(errno));
return -1;
}
// Get the file from the llfs filesystem associated with the stream
llfs_file = (llfs_file_t*)stream->_cookie;
if (llfs_file == NULL) {
LOG_WARN(TAG, "Failed to get llfs file associated with stream: %d", file_id);
return -1;
}
// Calculate the number of bytes to read (limited by the file size)
bytes_read = llfs_file->len - stream->_offset;
if (bytes_read > len) {
bytes_read = len;
} else if (bytes_read == 0) { // End of file
stream->_flags |= __SEOF;
return 0;
}
// Copy the data over to the dst buffer
memcpy(ptr, llfs_file->data + stream->_offset, bytes_read);
stream->_offset += (off_t)bytes_read;
return (int)bytes_read;
}
/**
* @brief Newlib isatty implementation
*
* @param file
* @return 1 if the file is stdin, stdout or stderr, 0 otherwise
*/
int isatty(int file) {
if (file == STDIN_FILENO || file == STDOUT_FILENO || file == STDERR_FILENO) {
return 1;
}
return 0;
}
/**
* @brief Newlib lseek implementation
*
* @param file
* @param ptr
* @param dir
* @return
*/
int _lseek(int file, int ptr, int dir) {
FILE* stream;
if (file == STDIN_FILENO || file == STDOUT_FILENO || file == STDERR_FILENO) {
LOG_DEBUG(TAG, "Trying to seek stdin, stdout or stderr: %d", file);
return -1;
}
stream = file_id_to_stream(file);
if (stream == NULL) {
LOG_WARN(TAG, "Failed to get file table entry. %s", strerror(errno));
return -1;
}
switch (dir) {
case SEEK_SET:
stream->_offset = ptr;
break;
case SEEK_CUR:
stream->_offset += ptr;
break;
case SEEK_END:
stream->_offset = (off_t)((llfs_file_t*)stream->_cookie)->len + ptr;
break;
default:
LOG_WARN(TAG, "Invalid seek direction: %d", dir);
return -1;
}
return 0;
}
/**
* @brief Newlib fstat implementation
*
* @param[in] file
* @param[out] st
* @return
*/
int _fstat(int file, struct stat* st) {
FILE* stream;
llfs_file_t *llfs_file;
// Check if the file is stdin, stdout or stderr
if (file == STDIN_FILENO || file == STDOUT_FILENO || file == STDERR_FILENO) {
st->st_mode = S_IFCHR; // Character special file
return 0;
}
// Get the stream associated with the file id
stream = file_id_to_stream(file);
if (stream == NULL) {
LOG_WARN(TAG, "Failed to get file table entry. %s", strerror(errno));
return -1;
}
// Get the file from the llfs filesystem associated with the stream
llfs_file = (llfs_file_t*)stream->_cookie;
if (llfs_file == NULL) {
LOG_WARN(TAG, "Failed to get llfs file associated with stream: %d", file);
return -1;
}
st->st_mode = S_IFREG; // Regular file
st->st_size = (off_t)llfs_file->len;
return 0;
}
/**
* @brief Create a new entry in the file table
*
* @return The file id or -1 if an error occurred. See errno for more information.
*/
static int new_file_table_entry(void) {
FILE* stream;
// Try to find an empty entry in the file table
for (int i = 0; i < POSIX_MAX_FILES; i++) {
if (file_table[i] == NULL) {
stream = (FILE*)malloc(sizeof(FILE));
if (stream == NULL) {
errno = ENOMEM; // Out of memory
return -1;
}
file_table[i] = stream;
return i;
}
}
// No empty entry found
errno = ENFILE; // Too many open files
return -1;
}
/**
* @brief Remove an entry from the file table
*
* @param[in] file_id The file id to remove
* @return 0 if successful, -1 if an error occurred. See errno for more information.
*/
static int free_file_table_entry(int file_id) {
// Check if the file id is valid
if (file_id < 0 || file_id >= POSIX_MAX_FILES) {
errno = EBADF; // Bad file number
return -1;
}
// Remove the entry from the file table
free(file_table[file_id]);
file_table[file_id] = NULL;
return 0;
}
/**
* @brief Get the stream associated with a file id
*
* @param[in] file_id The file id to get the stream for
* @return The stream or NULL if an error occurred. See errno for more information.
*/
static FILE* file_id_to_stream(int file_id) {
if (file_id < 0 || file_id >= POSIX_MAX_FILES) {
errno = EBADF; // Bad file number
return NULL;
}
return file_table[file_id];
}
/**
* @brief Check if a filename ends with a given extension
*
* @param[in] filename The filename to check
* @param[in] ext The extension to check for
* @return 1 if the filename ends with the extension, 0 otherwise
*/
static uint8_t file_ext_cmp(const char* const filename, const char* const ext) {
uint8_t ext_len = strlen(ext);
uint8_t filename_len = strlen(filename);
if (filename_len < ext_len) {
return 0;
}
// Compare backwards
for (uint8_t i = 0; i < ext_len; i++) {
if (filename[filename_len - i] != ext[ext_len - i]) {
return 0;
}
}
return 1;
}

2
project/Core/Src/log.c
View File

@@ -1,7 +1,7 @@
/**
* @file log.c
* @brief Logger implementation
* @authors Lorenz C. && Speetjens S.
* @authors Lorenz C. && Sander S.
*/
#include <stdarg.h>

156
project/Core/Src/main.c
View File

@@ -24,7 +24,10 @@
/* USER CODE BEGIN Includes */
#define LOGGER_LEVEL_ALL
#include "log.h"
#include "modbus-tcp.h"
#include "llfs.h"
#include "../../Drivers/BSP/STM32746G-Discovery/stm32746g_discovery_lcd.h"
#include "lcd_api.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
@@ -109,11 +112,156 @@ int main(void)
MX_FMC_Init();
MX_LWIP_Init();
MX_QUADSPI_Init();
/* USER CODE BEGIN 2 */
modbus_init();
/* USER CODE END 2 */
lcd_init(true);
llfs_init();
FILE *f = fopen("test.txt", "rw");
if (f == NULL) {
LOG_INFO(TAG, "File not found test.txt");
return 1;
} else {
LOG_INFO(TAG, "File found test.txt");
}
// Test POSIX file operations
// fgetc
int c;
printf("Printing file:\n");
while ((c = fgetc(f)) != EOF) {
printf("%c", c);
}
LOG_INFO(TAG, "File printed");
// fseek
fseek(f, 0, SEEK_SET);
LOG_INFO(TAG, "File seeked to start");
// ftell
long pos = ftell(f);
LOG_INFO(TAG, "File position: %d", pos);
// fread
char buf[100];
size_t bytes_read = fread(buf, 1, 100, f);
LOG_INFO(TAG, "Read %d bytes from file", bytes_read);
printf("Read from file:\n");
for (int i = 0; i < bytes_read; i++) {
printf("%c", buf[i]);
}
// Rewind the file
LOG_INFO(TAG, "Before File rewinded, pos: %d", ftell(f));
rewind(f);
LOG_INFO(TAG, "File rewinded, pos: %d", ftell(f));
// Get the file size fstat
struct stat st;
fstat(fileno(f), &st);
LOG_INFO(TAG, "File size: %d", st.st_size);
// Get a list of all files with the .bmp extension
llfs_file_t file_list[10];
size_t num_files = llfs_file_list(file_list, 10, "*.bmp");
LOG_INFO(TAG, "Found %d files with the .bmp extension", num_files);
for (int i = 0; i < num_files; i++) {
LOG_INFO(TAG, "File %d: %s", i, file_list[i].name);
}
// Get a list of files with .txt or .html
num_files = llfs_file_list(file_list, 10, "*.txt");
LOG_INFO(TAG, "Found %d files with the .txt or .html extension", num_files);
for (int i = 0; i < num_files; i++) {
LOG_INFO(TAG, "File %d: %s", i, file_list[i].name);
}
// Loop over all files using the iterator
LOG_INFO(TAG, "Looping over all files, using the iterator");
void *mem = NULL;
llfs_file_t *file;
while ((file = llfs_next_file(&mem, NULL)) != NULL) {
LOG_INFO(TAG, "File: %s", file->name);
}
// Loop over all files with the .bmp extension using the iterator
LOG_INFO(TAG, "Looping over all files with the .bmp extension, using the iterator");
mem = NULL;
while ((file = llfs_next_file(&mem, "*.bmp")) != NULL) {
LOG_INFO(TAG, "File: %s", file->name);
}
// Get the number of files in the filesystem
size_t num_files_in_fs = llfs_file_count();
LOG_INFO(TAG, "Number of files in the filesystem: %d", num_files_in_fs);
fclose(f);
// Try opening multiple files
LOG_INFO(TAG, "Opening an closing multiple files");
FILE * f1 = fopen("test.txt", "rw");
if (f1 == NULL) {
LOG_INFO(TAG, "File not found f1");
return 1;
} else {
LOG_INFO(TAG, "File found f1");
}
// Get the fileno
int fd = fileno(f1);
LOG_INFO(TAG, "File descriptor f1: %d", fd);
FILE * f2 = fopen("test.txt", "rw");
if (f2 == NULL) {
LOG_INFO(TAG, "File not found f2");
return 1;
} else {
LOG_INFO(TAG, "File found f2");
}
// Get the fileno
fd = fileno(f2);
LOG_INFO(TAG, "File descriptorf2: %d", fd);
LOG_INFO(TAG, "Closing f1");
fclose(f1);
FILE * f3 = fopen("test.txt", "rw");
if (f3 == NULL) {
LOG_INFO(TAG, "File not found f3");
return 1;
} else {
LOG_INFO(TAG, "File found f3");
}
// Get the fileno
fd = fileno(f3);
LOG_INFO(TAG, "File descriptor f3: %d", fd);
LOG_INFO(TAG, "Closing f2");
fclose(f2);
LOG_INFO(TAG, "Closing f3");
fclose(f3);
// Try opening a file multiple times, until it fails
int i = 0;
LOG_INFO(TAG, "Opening a file multiple times, until it fails");
while (1) {
f = fopen("test.txt", "rw");
LOG_INFO(TAG, "File descriptor: %d", fileno(f));
if (f == NULL) {
LOG_INFO(TAG, "File not found test.txt");
break;
} else {
LOG_INFO(TAG, "File found test.txt");
}
i++;
}
LOG_INFO(TAG, "File opened %d times", i);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)

10
project/Core/Src/syscalls.c
View File

@@ -89,14 +89,14 @@ __attribute__((weak)) int _write(int file, char *ptr, int len)
return len;
}
int _close(int file)
__attribute__((weak)) int _close(int file)
{
(void)file;
return -1;
}
int _fstat(int file, struct stat *st)
__attribute__((weak)) int _fstat(int file, struct stat *st)
{
(void)file;
st->st_mode = S_IFCHR;
@@ -109,7 +109,7 @@ int _isatty(int file)
return 1;
}
int _lseek(int file, int ptr, int dir)
__attribute__((weak)) int _lseek(int file, int ptr, int dir)
{
(void)file;
(void)ptr;
@@ -117,7 +117,7 @@ int _lseek(int file, int ptr, int dir)
return 0;
}
int _open(char *path, int flags, ...)
__attribute__((weak)) int _open(char *path, int flags, ...)
{
(void)path;
(void)flags;
@@ -145,7 +145,7 @@ int _times(struct tms *buf)
return -1;
}
int _stat(char *file, struct stat *st)
__attribute__((weak)) int _stat(char *file, struct stat *st)
{
(void)file;
st->st_mode = S_IFCHR;

2
project/Drivers/BSP/STM32746G-Discovery/stm32746g_discovery_lcd.c
View File

@@ -116,7 +116,7 @@ EndDependencies */
/** @defgroup STM32746G_DISCOVERY_LCD_Private_Variables STM32746G_DISCOVERY_LCD Private Variables
* @{
*/
*/
LTDC_HandleTypeDef hLtdcHandler;
static DMA2D_HandleTypeDef hDma2dHandler;

2
project/Drivers/BSP/STM32746G-Discovery/stm32746g_discovery_lcd.h
View File

@@ -43,7 +43,7 @@
/** @addtogroup STM32746G_DISCOVERY
* @{
*/
/** @addtogroup STM32746G_DISCOVERY_LCD
* @{
*/