#include "hardware_config.h"
#include "hardware/watchdog.h"
#include "hardware/structs/watchdog.h"
void watchdog_en(uint32_t delay_ms) {
watchdog_enable(delay_ms, 1); // pause_on_debug true, should allow us to debug normally
}
void watchdog_dis(void) {
watchdog_disable();
}
void watchdog_kick(void) {
watchdog_update(); // reset the watchdog timer
}
void force_watchdog_reboot(void) {
// force watchdog reboot
watchdog_reboot(0, 0, WATCHDOG_DELAY_REBOOT_MS);
// loop until watchdog reboot
while(1);
}
================================================
FILE: hardware/rp2xxx/hw_wifi.c
================================================
/******************************************************************************
* @file hw_wifi.c
*
* @brief Function implementations for WiFi connectivity using the CYW43
* wireless module. The implementation of these functions is hardware and
* SDK-specific and will need to be changed if ported to a new device.
*
* @author Alec Lanter (Github @Kintar)
* @author Cavin McKinley (Github @mcknly)
*
* @date 01-24-2025
*
* @copyright Copyright (c) 2025 Alec Lanter, Cavin McKinley
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include "hw_wifi.h"
#include "pico/cyw43_arch.h"
#include "pico/stdlib.h"
#include "hardware/gpio.h"
static hw_wifi_mode_t current_mode = HW_WIFI_MODE_NONE;
void hw_wifi_hard_reset(void) {
// toggle CYW43 WL_ON GPIO to make sure we are starting from POR
gpio_init(23);
gpio_set_dir(23, GPIO_OUT);
gpio_put(23, 0); // set WL_ON low to hold in reset
busy_wait_us(1000);
gpio_put(23,1); // release reset
// note: per the CYW43 data sheet, "wait at least 150ms after VDDC and
// VDDIO are available before initiating SDIO access". Should we have
// a hard pause here?
}
bool hw_wifi_is_initialized() {
return cyw43_is_initialized(&cyw43_state);
}
bool hw_wifi_init() {
if (hw_wifi_is_initialized()) {
return true;
}
else {
// force POR on wifi module if we are unsure of state
// hw_wifi_hard_reset();
// initialize the wifi module
return !cyw43_arch_init();
}
}
bool hw_wifi_init_with_country(hw_wifi_country_t country_code) {
if (hw_wifi_is_initialized()) {
return true;
}
else {
// force POR on wifi module if we are unsure of state
// hw_wifi_hard_reset();
// initialize the wifi module
return !cyw43_arch_init_with_country(country_code);
}
}
void hw_wifi_deinit() {
if (hw_wifi_is_initialized()) return;
cyw43_arch_deinit();
}
static uint32_t hw_wifi_auth_to_cyw43(hw_wifi_auth_t auth) {
switch (auth) {
case HW_WIFI_AUTH_MIXED:
return CYW43_AUTH_WPA2_MIXED_PSK;
case HW_WIFI_AUTH_WPA_TPIK_PSK:
return CYW43_AUTH_WPA_TKIP_PSK;
case HW_WIFI_AUTH_WPA2_AES_PSK:
return CYW43_AUTH_WPA2_AES_PSK;
default:
return CYW43_AUTH_OPEN;
}
}
void hw_wifi_enable_sta_mode() {
hw_wifi_disable_ap_mode();
cyw43_arch_enable_sta_mode();
current_mode = HW_WIFI_MODE_STA;
}
void hw_wifi_disable_sta_mode() {
if (current_mode == HW_WIFI_MODE_STA) {
cyw43_arch_disable_sta_mode();
current_mode = HW_WIFI_MODE_NONE;
}
}
void hw_wifi_enable_ap_mode(const char *ssid, const char *password, hw_wifi_auth_t auth_type) {
hw_wifi_disable_sta_mode();
cyw43_arch_enable_ap_mode(ssid, password, hw_wifi_auth_to_cyw43(auth_type));
current_mode = HW_WIFI_MODE_AP;
}
void hw_wifi_disable_ap_mode() {
if (current_mode == HW_WIFI_MODE_AP) {
cyw43_arch_disable_ap_mode();
current_mode = HW_WIFI_MODE_NONE;
}
}
bool hw_wifi_connect(const char *ssid, const char *password, hw_wifi_auth_t auth_type) {
uint32_t cw_auth = hw_wifi_auth_to_cyw43(auth_type);
return !cyw43_arch_wifi_connect_blocking(ssid, password, cw_auth);
}
bool hw_wifi_connect_async(const char *ssid, const char *password, hw_wifi_auth_t auth_type) {
uint32_t cw_auth = hw_wifi_auth_to_cyw43(auth_type);
return !cyw43_arch_wifi_connect_async(ssid, password, cw_auth);
}
void hw_wifi_reset_connection(void) {
// disable and re-enable AP mode to reset connection
hw_wifi_disable_ap_mode();
hw_wifi_disable_sta_mode();
cyw43_arch_enable_sta_mode();
current_mode = HW_WIFI_MODE_STA;
}
const ip_addr_t *hw_wifi_get_addr() {
// query lwIP for address
return netif_ip4_addr(netif_list);
}
hw_wifi_status_t hw_wifi_get_status() {
// AP mode always returns LINKDOWN from cyw43
if (current_mode == HW_WIFI_MODE_AP) {
return HW_WIFI_STATUS_LINK_DOWN;
}
// TODO: the cyw43_arch_wifi_link_status function will not actually return
// all the statuses below. In fact, it appears that it always returns
// CYW43_LINK_JOIN. This function is somewhat useless for now, it may be
// that the pico-sdk implementation is flawed, needs more research.
uint32_t status = cyw43_wifi_link_status(&cyw43_state, CYW43_ITF_STA);
switch (status) {
case CYW43_LINK_DOWN:
return HW_WIFI_STATUS_LINK_DOWN;
case CYW43_LINK_JOIN:
return HW_WIFI_STATUS_JOINED;
case CYW43_LINK_NOIP:
return HW_WIFI_STATUS_NOIP;
case CYW43_LINK_UP:
return HW_WIFI_STATUS_UP;
case CYW43_LINK_FAIL:
return HW_WIFI_STATUS_FAIL;
case CYW43_LINK_NONET:
return HW_WIFI_STATUS_NONET;
case CYW43_LINK_BADAUTH:
return HW_WIFI_STATUS_BADAUTH;
default:
return HW_WIFI_STATUS_UNKNOWN;
}
}
================================================
FILE: hardware/rp2xxx/net_inc/httpd_content/404.html
================================================
BBOS
BreadboardOS
404 - Page not found
...:::-------::::...
.:--=+*##%%%%%%%%%%%%###########%%%%###*++=-:.
.:=+*#%%@%%##*+=--:. .....::::::.......::--=++**##**+-:.
:-+#%@@%%#+=-: ..::-==+++***###%%%%%%%###***++=======++***+=:
:+%@@%#+=:. .:-=+##%@@@@@@@@@@%%%###****+++++++++**###%%@@@@@%%####%%#+:
.+@@%*-..::. :-+#%@@@@@@%#**+=--::.. ..:-=+*#%@@@@@%=.
.*@@+: -=-..-+%@@@@%*+=--::.. ....:::::-----:::.. .:=+#@@@#:
=@@+... :=:.:+@@@%*=::::--::::::::------:::.. ..:-----::.. ...-#@@#:
*@%: ::-=: .*@@%+:..:--::..:-----:. ..:::::. .::: .*@@+
#@#. ::-: +@@#-:..::. .:::::. .. ::-: -@@*
+@% :- .#@@=:. .--:. .=.:= -@@=
:@@: .: .#@%-:. . :: - :- +@@.
*@+ . .=@@-:. -. .. . . @@=
.@@. .:#@*.. =. *@*
-@% :-@@-. -: =@%
+@* :-@%: = . -@%
+@+ :-@%: .: -. :.:@@
=@* . .-@%. . -: = -@%
.@% - -::.:%@- -. + =@#
*@= - =::.+@# -+ :- : :: *@=
+@+:=-+. :#@* .-+@@* =@@#=: . @@
.*@+=+%*--#@%: =%%%@%#=. -+#%@%%#. #@-
*@:..:=++--*@= .-::. .:: =%%-
@#. ..:@@-. . . :@@:
*@: - .:%@+. : :+**=. .*@@@%+ : +@@:
-@= .: .:*@#: : *@@@@@@+ %@@@@@@# :. %@%
@#. .=@%: :: . =@@@@@@@@- :@@@@@@@@: - :@@*
*@-- .:.-@@= .- :: #@@@@@@@@= .@@@@@@@@. - +@@-
:@+=. ..:%@+. = .= =@@@@@@@@. =@@@@@%- :: %@@
%%=: : : .*@#: =. = =@@@@@#: .-==: = .@@#
=@=- -.:. .=@@: -: - .-=-. . . + =@@=
.@#: .-.- .-@@= .- : -. . . -- . -: .: :- #@@:
#@. = = .:#@+. - :: . :: -=++++- . . :. =. @@%
-@= : =. :*@#. : -+-. .-+: = + :@@*
.@% := :=@@: -: : .= -= +@@-
#@. + :-@@= =: +. #@@.
=@= = .:%@+. + .+ .@@#
:@# :..:*@#. :- =- -@@+
@@ .. :+@%: : - + +@@-
#@. :-@@- - - : := %@@
+@- ::@@= = = =. .@@#
=@+ .:%@+ + + = =@@=
:@# .:*@#. + = :: #@@.
@@ .+@%. + - - .@@#
#@: .=@%: = .. +@@-
=@+ .-@@: -. . .@@#
@@ .-@@- .. .::..... .%@@:
..:::---+@# ::%@= .:::. ... .....-+%@@#++==---:::..
.:--==--====+++#@%=: .+@%: .::::::. ......:::::--====+++****#%@@@@@@@@@@@%+=======---:.
=====-=+*#%%@@@@@@@@@%#+=-#@%-. ..... ..:::--===++***##%%%%@@@@@@@@@@@@@@@@@@@@@@@@@%#**+================.
:--===*@@@@@@@@@@@@@@@@@@@@@@@%##******####%%%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%%%##*++==-----===========--:.
.:::-=+*#%%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%%%%######******+++++++========---==========----:::..
..::---==++++******#####********+++++========----------------------------::::....
....................................
Sorry, the slice you are requesting was not baked in this server.
================================================
FILE: hardware/rp2xxx/net_inc/httpd_content/index.shtml
================================================
BBOS
[[ Welcome to BreadboardOS! ]]
Platform:
Uptime:
Free RAM:
Free flash:
CGI tests:
led-on
led-off
404 test: /nonexistent
================================================
FILE: hardware/rp2xxx/net_inc/httpd_content/test.shtml
================================================
BBOS
cgi test
The onboard LED should be [
]!
This test demonstrates how to use CGI key/value pairs
to pass information to the http server, and provide status
feedback via SSI tags. Note the URI including led-state query.
Go back
================================================
FILE: hardware/rp2xxx/net_inc/hw_net.h
================================================
/******************************************************************************
* @file hw_net.h
*
* @brief Settings, definitions, and function prototypes for various network
* stacks, much of it tied to lwIP. Hardware and SDK-specific
* implementation resides within these functions.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-06-2025
*
* @copyright Copyright (c) 2025 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#ifndef HW_NET_H
#define HW_NET_H
#include
#include "lwip/arch.h"
/**
* @brief Initialize mDNS
*
* This function intializes the lwIP mDNS stack. Once running, the device will
* be discoverable on the local network via the assigned hostname (set by the
* HOSTNAME plus BOARD variables in project.cmake). The resulting mDNS host will
* be accessible at '-.local'.
*
* @param none
*
* @return nothing
*/
void net_mdns_init(void);
/**
* @brief Initialize the httpd stack
*
* This function is called to initialize the lwIP httpd (web server) stack. Once
* running, the web server is available on the standard http port (80) and can
* serve dynamic content via SSI. Must already be connected to a network and have
* an assigned IP.
*
* @param none
*
* @return nothing
*/
void net_httpd_stack_init(void);
/**
* @brief lwIP httpd CGI handler
*
* This function is called by the lwIP httpd stack when a CGI request is made
* (i.e. the key/value pair in the URI after the '?' character). This function
* must be assigned to a path in the httpd_cgi_paths array. Note that multiple
* CGI handler functions can be defined and assigned to different paths.
*
* @param tCGIHandler Params given by lwIP typedef tCGIHandler. See lwip/apps/httpd.h
*
* @return pointer to URI path string returned to the browser
*/
static const char *httpd_cgi_handler(int iIndex, int iNumParams, char *pcParam[], char *pcValue[]);
/**
* @brief lwIP httpd SSI handler
*
* This function is called by the lwIP httpd stack when an SSI request is made
* (i.e. the server found a SSI tag in the html file). This function contains
* logic which matches the iIndex tag index number defined by the httpd_ssi_tags
* array. The function will return the string to be inserted into the HTML file
* in place of the tag. Note that there is only one SSI handler function assigned
* to the lwIP httpd stack.
*
* @param tSSIHandler Params given by lwIP typedef tSSIHandler. See lwip/apps/httpd.h
*
* @return number of characters written in place of the SSI tag
*/
u16_t httpd_ssi_handler(int iIndex, char *pcInsert, int iInsertLen, uint16_t current_tag_part, uint16_t *next_tag_part);
#endif /* HW_NET_H */
================================================
FILE: hardware/rp2xxx/net_inc/hw_wifi.h
================================================
/******************************************************************************
* @file hw_wifi.h
*
* @brief settings, definitions, typedefs and function prototypes for WiFi and
* interacting with the CYW43 wireless module. Hardware and SDK-specific
* implementation resides within these functions.
*
* @author Alec Lanter (Github @Kintar)
* @author Cavin McKinley (Github @mcknly)
*
* @date 01-24-2025
*
* @copyright Copyright (c) 2025 Alec Lanter, Cavin McKinley
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#ifndef HW_WIFI_H
#define HW_WIFI_H
#include
#include
#include "pico/cyw43_arch.h"
typedef uint32_t hw_wifi_country_t ;
// create a country code from the two character country and revision number
#define HW_WIFI_COUNTRY(A, B, REV) (hw_wifi_country_t)((unsigned char)(A) | ((unsigned char)(B) << 8) | ((REV) << 16))
// Worldwide Locale (passive Ch12-14)
#define HW_WIFI_COUNTRY_WORLDWIDE HW_WIFI_COUNTRY('X', 'X', 0)
#define HW_WIFI_COUNTRY_AUSTRALIA HW_WIFI_COUNTRY('A', 'U', 0)
#define HW_WIFI_COUNTRY_AUSTRIA HW_WIFI_COUNTRY('A', 'T', 0)
#define HW_WIFI_COUNTRY_BELGIUM HW_WIFI_COUNTRY('B', 'E', 0)
#define HW_WIFI_COUNTRY_BRAZIL HW_WIFI_COUNTRY('B', 'R', 0)
#define HW_WIFI_COUNTRY_CANADA HW_WIFI_COUNTRY('C', 'A', 0)
#define HW_WIFI_COUNTRY_CHILE HW_WIFI_COUNTRY('C', 'L', 0)
#define HW_WIFI_COUNTRY_CHINA HW_WIFI_COUNTRY('C', 'N', 0)
#define HW_WIFI_COUNTRY_COLOMBIA HW_WIFI_COUNTRY('C', 'O', 0)
#define HW_WIFI_COUNTRY_CZECH_REPUBLIC HW_WIFI_COUNTRY('C', 'Z', 0)
#define HW_WIFI_COUNTRY_DENMARK HW_WIFI_COUNTRY('D', 'K', 0)
#define HW_WIFI_COUNTRY_ESTONIA HW_WIFI_COUNTRY('E', 'E', 0)
#define HW_WIFI_COUNTRY_FINLAND HW_WIFI_COUNTRY('F', 'I', 0)
#define HW_WIFI_COUNTRY_FRANCE HW_WIFI_COUNTRY('F', 'R', 0)
#define HW_WIFI_COUNTRY_GERMANY HW_WIFI_COUNTRY('D', 'E', 0)
#define HW_WIFI_COUNTRY_GREECE HW_WIFI_COUNTRY('G', 'R', 0)
#define HW_WIFI_COUNTRY_HONG_KONG HW_WIFI_COUNTRY('H', 'K', 0)
#define HW_WIFI_COUNTRY_HUNGARY HW_WIFI_COUNTRY('H', 'U', 0)
#define HW_WIFI_COUNTRY_ICELAND HW_WIFI_COUNTRY('I', 'S', 0)
#define HW_WIFI_COUNTRY_INDIA HW_WIFI_COUNTRY('I', 'N', 0)
#define HW_WIFI_COUNTRY_ISRAEL HW_WIFI_COUNTRY('I', 'L', 0)
#define HW_WIFI_COUNTRY_ITALY HW_WIFI_COUNTRY('I', 'T', 0)
#define HW_WIFI_COUNTRY_JAPAN HW_WIFI_COUNTRY('J', 'P', 0)
#define HW_WIFI_COUNTRY_KENYA HW_WIFI_COUNTRY('K', 'E', 0)
#define HW_WIFI_COUNTRY_LATVIA HW_WIFI_COUNTRY('L', 'V', 0)
#define HW_WIFI_COUNTRY_LIECHTENSTEIN HW_WIFI_COUNTRY('L', 'I', 0)
#define HW_WIFI_COUNTRY_LITHUANIA HW_WIFI_COUNTRY('L', 'T', 0)
#define HW_WIFI_COUNTRY_LUXEMBOURG HW_WIFI_COUNTRY('L', 'U', 0)
#define HW_WIFI_COUNTRY_MALAYSIA HW_WIFI_COUNTRY('M', 'Y', 0)
#define HW_WIFI_COUNTRY_MALTA HW_WIFI_COUNTRY('M', 'T', 0)
#define HW_WIFI_COUNTRY_MEXICO HW_WIFI_COUNTRY('M', 'X', 0)
#define HW_WIFI_COUNTRY_NETHERLANDS HW_WIFI_COUNTRY('N', 'L', 0)
#define HW_WIFI_COUNTRY_NEW_ZEALAND HW_WIFI_COUNTRY('N', 'Z', 0)
#define HW_WIFI_COUNTRY_NIGERIA HW_WIFI_COUNTRY('N', 'G', 0)
#define HW_WIFI_COUNTRY_NORWAY HW_WIFI_COUNTRY('N', 'O', 0)
#define HW_WIFI_COUNTRY_PERU HW_WIFI_COUNTRY('P', 'E', 0)
#define HW_WIFI_COUNTRY_PHILIPPINES HW_WIFI_COUNTRY('P', 'H', 0)
#define HW_WIFI_COUNTRY_POLAND HW_WIFI_COUNTRY('P', 'L', 0)
#define HW_WIFI_COUNTRY_PORTUGAL HW_WIFI_COUNTRY('P', 'T', 0)
#define HW_WIFI_COUNTRY_SINGAPORE HW_WIFI_COUNTRY('S', 'G', 0)
#define HW_WIFI_COUNTRY_SLOVAKIA HW_WIFI_COUNTRY('S', 'K', 0)
#define HW_WIFI_COUNTRY_SLOVENIA HW_WIFI_COUNTRY('S', 'I', 0)
#define HW_WIFI_COUNTRY_SOUTH_AFRICA HW_WIFI_COUNTRY('Z', 'A', 0)
#define HW_WIFI_COUNTRY_SOUTH_KOREA HW_WIFI_COUNTRY('K', 'R', 0)
#define HW_WIFI_COUNTRY_SPAIN HW_WIFI_COUNTRY('E', 'S', 0)
#define HW_WIFI_COUNTRY_SWEDEN HW_WIFI_COUNTRY('S', 'E', 0)
#define HW_WIFI_COUNTRY_SWITZERLAND HW_WIFI_COUNTRY('C', 'H', 0)
#define HW_WIFI_COUNTRY_TAIWAN HW_WIFI_COUNTRY('T', 'W', 0)
#define HW_WIFI_COUNTRY_THAILAND HW_WIFI_COUNTRY('T', 'H', 0)
#define HW_WIFI_COUNTRY_TURKEY HW_WIFI_COUNTRY('T', 'R', 0)
#define HW_WIFI_COUNTRY_UK HW_WIFI_COUNTRY('G', 'B', 0)
#define HW_WIFI_COUNTRY_USA HW_WIFI_COUNTRY('U', 'S', 0)
// wifi auth types
typedef enum{
HW_WIFI_AUTH_OPEN,
HW_WIFI_AUTH_WPA_TPIK_PSK,
HW_WIFI_AUTH_WPA2_AES_PSK,
HW_WIFI_AUTH_MIXED,
} hw_wifi_auth_t ;
// wifi modes
typedef enum{
HW_WIFI_MODE_NONE,
HW_WIFI_MODE_STA,
HW_WIFI_MODE_AP,
} hw_wifi_mode_t ;
// wifi status
typedef enum{
HW_WIFI_STATUS_LINK_DOWN,
HW_WIFI_STATUS_JOINED,
HW_WIFI_STATUS_NOIP,
HW_WIFI_STATUS_UP,
HW_WIFI_STATUS_FAIL,
HW_WIFI_STATUS_BADAUTH,
HW_WIFI_STATUS_NONET,
HW_WIFI_STATUS_UNKNOWN,
} hw_wifi_status_t ;
// IP address (IPv4)
typedef uint32_t hw_wifi_ip_addr_t;
/**************************************************
* Wireless module (CYW43) initialization functions
***************************************************/
/**
* @brief Perform a hard reset of the CYW43 module.
*
* Force a hard reset of the CYW43 module by toggling the reset pin with the
* appropriate RP2xxx GPIO pin.
*
* @param none
*
* @return nothing
*/
void hw_wifi_hard_reset(void);
/**
* @brief Check if the CYW43 module is initialized.
*
* Performs a check to determine if the CYW43 module has already been initialized
* so that it is not tried multiple times, with a boolean response to indicate.
*
* @param none
*
* @return true if the CYW43 module is already initialized, otherwise false
*/
bool hw_wifi_is_initialized(void);
/**
* @brief Initialize the CYW43 module without country code.
*
* Check weather the CYW43 module has already been initialized, and if not,
* perform the initialization routine. This routine will also initialze the lwIP
* stack. Note that this function does not use a country code, and will default
* to the worldwide locale. This may not give the best performance in all regions.
*
* @param none
*
* @return true if initialization was successful, otherwise false
*/
bool hw_wifi_init(void);
/**
* @brief Initialize the CYW43 module with country code.
*
* Check weather the CYW43 module has already been initialized, and if not,
* perform the initialization routine using the given country code. This routine
* will also initialze the lwIP stack.
*
* @param country_code country code from the list of definitions in this file
*
* @return true if initialization was successful, otherwise false
*/
bool hw_wifi_init_with_country(hw_wifi_country_t country_code);
/**
* @brief De-initialize the CYW43 module.
*
* This will de-initialize the CYW43 driver and the lwIP stack.
*
* @param none
*
* @return nothing
*/
void hw_wifi_deinit(void);
/*****************************
* WiFi mode control functions
******************************/
// NOTE: the pico_w will _technically_ support simultaneous AP and STA mode
// connections, but this implementation does not.
/**
* @brief Enable STA mode for the WiFi module.
*
* This function will enable the STA mode for the WiFi module, disabling AP mode
* if it is currently enabled.
*
* @param none
*
* @return nothing
*/
void hw_wifi_enable_sta_mode(void);
/**
* @brief Disable STA mode for the WiFi module.
*
* This function will disable the STA mode for the WiFi module.
*
* @param none
*
* @return nothing
*/
void hw_wifi_disable_sta_mode(void);
/**
* @brief Enable AP mode for the WiFi module.
*
* This function will enable the AP mode for the WiFi module, disabling STA mode
* if it is currently enabled.
*
* @param ssid SSID string for the AP to broadcast
* @param password password string for the AP
* @param auth_type authentication type for the AP
*
* @return nothing
*/
void hw_wifi_enable_ap_mode(const char *ssid, const char *password, hw_wifi_auth_t auth_type);
/**
* @brief Disable AP mode for the WiFi module.
*
* This function will disable the AP mode for the WiFi module.
*
* @param none
*
* @return nothing
*/
void hw_wifi_disable_ap_mode(void);
/**************************************
* WiFi connection and status functions
***************************************/
/**
* @brief Connect to a WiFi network (blocking).
*
* Connect to a WiFi network with the given SSID, password, and authentication
* type. This function will block until the connection is established.
*
* @param ssid SSID string of the network to connect to
* @param password password string for the network
* @param auth_type authentication type for the network
*
* @return true if the connection was successful, false if connection error detected
*/
bool hw_wifi_connect(const char *ssid, const char *password, hw_wifi_auth_t auth_type);
/**
* @brief Connect to a WiFi network (non-blocking).
*
* Connect to a WiFi network with the given SSID, password, and authentication
* type. This function can be called in a non-blocking fashion.
*
* @param ssid SSID string of the network to connect to
* @param password password string for the network
* @param auth_type authentication type for the network
*
* @return true if the connection was successful, false if connection error detected
*/
bool hw_wifi_connect_async(const char *ssid, const char *password, hw_wifi_auth_t auth_type);
/**
* @brief Reset the WiFi network connection.
*
* This function will disable and re-enable AP mode (using hw_wifi_disable_ap_mode
* and hw_wifi_enable_ap_mode) to effectively disconnect/reset the WiFi connection.
* It is essentially a helper function since there is no direct disconnect function.
*
* @param none
*
* @return nothing
*/
void hw_wifi_reset_connection(void);
/**
* @brief Get the IP address of the WiFi module.
*
* This function will return the 32-bit integer representation of the IP address
* of the WiFi module, assuming it is connected to a network. The returned address
* will be zero if it has not yet been assigned. The IP address is provided with
* a pointer to a struct with member 'addr' containing the 32-bit address.
*
* @param none
*
* @return pointer to the IP address struct for the WiFi module
*/
const ip_addr_t *hw_wifi_get_addr(void);
/**
* @brief Get the current status of the WiFi connection.
*
* This function will return the current status of the WiFi connection, given by
* the hw_wifi_status_t enum.
*
* @param none
*
* @return enumeration providing the current status of the WiFi connection
*/
hw_wifi_status_t hw_wifi_get_status(void);
#endif /* HW_WIFI_H */
================================================
FILE: hardware/rp2xxx/net_inc/lwipopts.h
================================================
#ifndef LWIPOPTS_H
#define LWIPOPTS_H
// Common settings used in most of the pico_w examples
// from: https://github.com/raspberrypi/pico-examples/blob/master/pico_w/wifi/lwipopts_examples_common.h
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)
// NO_SYS true, since we are running the entire lwIP stack in a single thread.
// This causes some issue with CYW43 init and blocking things like cyw43_arch_enable_sta_mode(),
// so watchdog timeout needs to be sufficiently long to allow for this, assuming WD is running.
#define NO_SYS 1
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 1
#define LWIP_IPV4 1
#define LWIP_TCP 1
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 1
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif
#define ETHARP_DEBUG LWIP_DBG_OFF
#define NETIF_DEBUG LWIP_DBG_OFF
#define PBUF_DEBUG LWIP_DBG_OFF
#define API_LIB_DEBUG LWIP_DBG_OFF
#define API_MSG_DEBUG LWIP_DBG_OFF
#define SOCKETS_DEBUG LWIP_DBG_OFF
#define ICMP_DEBUG LWIP_DBG_OFF
#define INET_DEBUG LWIP_DBG_OFF
#define IP_DEBUG LWIP_DBG_OFF
#define IP_REASS_DEBUG LWIP_DBG_OFF
#define RAW_DEBUG LWIP_DBG_OFF
#define MEM_DEBUG LWIP_DBG_OFF
#define MEMP_DEBUG LWIP_DBG_OFF
#define SYS_DEBUG LWIP_DBG_OFF
#define TCP_DEBUG LWIP_DBG_OFF
#define TCP_INPUT_DEBUG LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
#define TCP_RTO_DEBUG LWIP_DBG_OFF
#define TCP_CWND_DEBUG LWIP_DBG_OFF
#define TCP_WND_DEBUG LWIP_DBG_OFF
#define TCP_FR_DEBUG LWIP_DBG_OFF
#define TCP_QLEN_DEBUG LWIP_DBG_OFF
#define TCP_RST_DEBUG LWIP_DBG_OFF
#define UDP_DEBUG LWIP_DBG_OFF
#define TCPIP_DEBUG LWIP_DBG_OFF
#define PPP_DEBUG LWIP_DBG_OFF
#define SLIP_DEBUG LWIP_DBG_OFF
#define DHCP_DEBUG LWIP_DBG_OFF
/*******************************
* Application-specific settings
********************************/
// Enable mDNS responder
#define LWIP_MDNS_RESPONDER 1
#define LWIP_IGMP 1
#define LWIP_NUM_NETIF_CLIENT_DATA 1
#define MDNS_RESP_USENETIF_EXTCALLBACK 1
#define MEMP_NUM_SYS_TIMEOUT (LWIP_NUM_SYS_TIMEOUT_INTERNAL + 3)
#define MEMP_NUM_TCP_PCB 12
#ifdef ENABLE_HTTPD
// Enable cgi and ssi
#define LWIP_HTTPD_CGI 1
#define LWIP_HTTPD_SSI 1
#define LWIP_HTTPD_SSI_MULTIPART 1
// not necessary, can be done either way
#define LWIP_TCPIP_CORE_LOCKING_INPUT 1
// filename for httpd content generated with pico_set_lwip_httpd_content
#define HTTPD_FSDATA_FILE "pico_fsdata.inc"
#endif /* ENABLE_HTTPD */
#endif /* LWIPOPTS_H */
================================================
FILE: hardware/rp2xxx/onboard_flash.c
================================================
/******************************************************************************
* @file onboard_flash.c
*
* @brief Functions for accessing the 'onboard' flash memory (application
* storage mem). Intended to be used with a fixed chunk of leftover storage at
* the end of flash not used by the application. Note that the functions may be
* used standalone, however the argument format was structured so that they
* could be leveraged by LittleFS. The implementation of these functions is
* MCU-specific and will need to be changed if ported to a new hardware family.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include
#include
#include "hardware_config.h"
#include "hardware/flash.h"
#include "hardware/regs/addressmap.h"
#include "hardware/sync.h"
#include "lfs.h"
#include "semphr.h"
const char* FLASH0_FS_BASE = (char*)(PICO_FLASH_SIZE_BYTES - FLASH0_FS_SIZE); // 'flash0' filesystem start address is at the end of flash
SemaphoreHandle_t onboard_flash_mutex; // global onboard flash mutex
void onboard_flash_init(void) {
// create onboard flash mutex
onboard_flash_mutex = xSemaphoreCreateMutex();
}
int onboard_flash_read(const struct lfs_config *c, uint32_t block, uint32_t offset, void* buffer, uint32_t size) {
if(xSemaphoreTake(onboard_flash_mutex, 10) == pdTRUE) { // try to acquire flash access
// copy from address of memory-mapped flash location - read address includes RAM offset XIP_NOCACHE_NOALLOC_BASE
memcpy(buffer, FLASH0_FS_BASE + XIP_NOCACHE_NOALLOC_BASE + (block * FLASH_SECTOR_SIZE) + offset, size); // note "block" and "sector" are synonomous here
xSemaphoreGive(onboard_flash_mutex);
return 0;
}
else return -1;
}
int onboard_flash_write(const struct lfs_config *c, uint32_t block, uint32_t offset, const void* buffer, uint32_t size) {
uint32_t addr = (uint32_t)FLASH0_FS_BASE + (block * FLASH_SECTOR_SIZE) + offset;
if(xSemaphoreTake(onboard_flash_mutex, 10) == pdTRUE) { // try to acquire flash access
uint32_t interrupts = save_and_disable_interrupts(); // disable interrupts since we are writing to program memory
flash_range_program(addr, buffer, size);
restore_interrupts(interrupts); // re-enable interrupts
xSemaphoreGive(onboard_flash_mutex);
return 0;
}
else return -1;
}
int onboard_flash_erase(const struct lfs_config *c, uint32_t block) {
uint32_t addr = (uint32_t)FLASH0_FS_BASE + (block * FLASH_SECTOR_SIZE);
if(xSemaphoreTake(onboard_flash_mutex, 10) == pdTRUE) { // try to acquire flash access
uint32_t interrupts = save_and_disable_interrupts(); // disable interrupts since we are erasing within program memory
flash_range_erase(addr, FLASH_SECTOR_SIZE); // erase entire block/sector
restore_interrupts(interrupts); // re-enable interrupts
xSemaphoreGive(onboard_flash_mutex);
return 0;
}
else return -1;
}
int onboard_flash_sync(const struct lfs_config *c) {
return 0; // always success, this is a dummy function
}
flash_usage_t onboard_flash_usage(void) {
flash_usage_t flash_usage; // the structure to hold flash usage details
extern char __flash_binary_end; // the last byte in the program binary (page-aligned)
uintptr_t prog_bin_end_addr = (uintptr_t) &__flash_binary_end; // the address of the binary upper bound
// calculate flash usage
flash_usage.flash_total_size = PICO_FLASH_SIZE_BYTES; // assuming the correct board/flash is identified by the SDK
flash_usage.program_used_size = prog_bin_end_addr - XIP_BASE;
flash_usage.fs_reserved_size = FLASH0_FS_SIZE;
flash_usage.flash_free_size = flash_usage.flash_total_size - flash_usage.program_used_size - flash_usage.fs_reserved_size;
return flash_usage;
}
================================================
FILE: hardware/rp2xxx/onboard_led.c
================================================
/******************************************************************************
* @file onboard_led.c
*
* @brief Functions to interact with the onboard LED GPIO. The implementation of
* these functions is MCU-specific and will need to be changed if ported
* to a new hardware family.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include "hardware_config.h"
#include "pico/stdlib.h"
#ifdef HAS_CYW43
#include "pico/cyw43_arch.h"
void onboard_led_init(void) {
// no work to do with CYW43 LED pin
}
void onboard_led_set(bool led_state) {
cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, led_state);
}
bool onboard_led_get(void) {
return cyw43_arch_gpio_get(CYW43_WL_GPIO_LED_PIN);
}
#else
void onboard_led_init(void) {
gpio_init(PIN_NO_ONBOARD_LED);
gpio_set_dir(PIN_NO_ONBOARD_LED, GPIO_OUT);
}
void onboard_led_set(bool led_state) {
gpio_put(PIN_NO_ONBOARD_LED, led_state);
}
bool onboard_led_get(void) {
return gpio_get(PIN_NO_ONBOARD_LED);
}
#endif
================================================
FILE: hardware/rp2xxx/pico_sdk_import.cmake
================================================
# This is a copy of /external/pico_sdk_import.cmake
# This can be dropped into an external project to help locate this SDK
# It should be include()ed prior to project()
if (DEFINED ENV{PICO_SDK_PATH} AND (NOT PICO_SDK_PATH))
set(PICO_SDK_PATH $ENV{PICO_SDK_PATH})
message("Using PICO_SDK_PATH from environment ('${PICO_SDK_PATH}')")
endif ()
if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT} AND (NOT PICO_SDK_FETCH_FROM_GIT))
set(PICO_SDK_FETCH_FROM_GIT $ENV{PICO_SDK_FETCH_FROM_GIT})
message("Using PICO_SDK_FETCH_FROM_GIT from environment ('${PICO_SDK_FETCH_FROM_GIT}')")
endif ()
if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_PATH} AND (NOT PICO_SDK_FETCH_FROM_GIT_PATH))
set(PICO_SDK_FETCH_FROM_GIT_PATH $ENV{PICO_SDK_FETCH_FROM_GIT_PATH})
message("Using PICO_SDK_FETCH_FROM_GIT_PATH from environment ('${PICO_SDK_FETCH_FROM_GIT_PATH}')")
endif ()
if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_TAG} AND (NOT PICO_SDK_FETCH_FROM_GIT_TAG))
set(PICO_SDK_FETCH_FROM_GIT_TAG $ENV{PICO_SDK_FETCH_FROM_GIT_TAG})
message("Using PICO_SDK_FETCH_FROM_GIT_TAG from environment ('${PICO_SDK_FETCH_FROM_GIT_TAG}')")
endif ()
if (PICO_SDK_FETCH_FROM_GIT AND NOT PICO_SDK_FETCH_FROM_GIT_TAG)
set(PICO_SDK_FETCH_FROM_GIT_TAG "master")
message("Using master as default value for PICO_SDK_FETCH_FROM_GIT_TAG")
endif()
set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the Raspberry Pi Pico SDK")
set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of SDK from git if not otherwise locatable")
set(PICO_SDK_FETCH_FROM_GIT_PATH "${PICO_SDK_FETCH_FROM_GIT_PATH}" CACHE FILEPATH "location to download SDK")
set(PICO_SDK_FETCH_FROM_GIT_TAG "${PICO_SDK_FETCH_FROM_GIT_TAG}" CACHE FILEPATH "release tag for SDK")
if (NOT PICO_SDK_PATH)
if (PICO_SDK_FETCH_FROM_GIT)
include(FetchContent)
set(FETCHCONTENT_BASE_DIR_SAVE ${FETCHCONTENT_BASE_DIR})
if (PICO_SDK_FETCH_FROM_GIT_PATH)
get_filename_component(FETCHCONTENT_BASE_DIR "${PICO_SDK_FETCH_FROM_GIT_PATH}" REALPATH BASE_DIR "${CMAKE_SOURCE_DIR}")
endif ()
# GIT_SUBMODULES_RECURSE was added in 3.17
if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.17.0")
FetchContent_Declare(
pico_sdk
GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk
GIT_TAG ${PICO_SDK_FETCH_FROM_GIT_TAG}
GIT_SUBMODULES_RECURSE FALSE
)
else ()
FetchContent_Declare(
pico_sdk
GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk
GIT_TAG ${PICO_SDK_FETCH_FROM_GIT_TAG}
)
endif ()
if (NOT pico_sdk)
message("Downloading Raspberry Pi Pico SDK")
FetchContent_Populate(pico_sdk)
set(PICO_SDK_PATH ${pico_sdk_SOURCE_DIR})
endif ()
set(FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR_SAVE})
else ()
message(FATAL_ERROR
"SDK location was not specified. Please set PICO_SDK_PATH or set PICO_SDK_FETCH_FROM_GIT to on to fetch from git."
)
endif ()
endif ()
get_filename_component(PICO_SDK_PATH "${PICO_SDK_PATH}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}")
if (NOT EXISTS ${PICO_SDK_PATH})
message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' not found")
endif ()
set(PICO_SDK_INIT_CMAKE_FILE ${PICO_SDK_PATH}/pico_sdk_init.cmake)
if (NOT EXISTS ${PICO_SDK_INIT_CMAKE_FILE})
message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' does not appear to contain the Raspberry Pi Pico SDK")
endif ()
set(PICO_SDK_PATH ${PICO_SDK_PATH} CACHE PATH "Path to the Raspberry Pi Pico SDK" FORCE)
include(${PICO_SDK_INIT_CMAKE_FILE})
================================================
FILE: hardware/rp2xxx/prebuild.cmake
================================================
# PICO_BOARD should be one of the boards listed in Pico SDK header files
# see: https://github.com/raspberrypi/pico-sdk/tree/master/src/boards/include/boards
# Set BOARD in project.cmake accordingly (i.e. pico, pico_w, pico2, etc)
set(PICO_BOARD ${BOARD})
# Raspberry Pi Pico (RP2040/RP2350) SDK
include(${hardware_dir}/pico_sdk_import.cmake)
# Platform-specific variable for paths/libraries/etc
set(hardware_includes ${hardware_dir})
set(hardware_libs "pico_unique_id"
"pico_stdlib"
"hardware_i2c"
"hardware_spi"
"hardware_flash"
"hardware_adc"
"cmsis_core"
"tinyusb_device"
)
# FreeRTOS port subdirectory for this platform (relative to $FREERTOS_KERNEL_PATH)
# all of the "boards" from the link above should be handled here to categorize
# them as RP2040 or RP2350 type
if(PICO_BOARD STREQUAL "pico" OR PICO_BOARD STREQUAL "pico_w")
set(freertos_port_path "portable/ThirdParty/GCC/RP2040/FreeRTOS_Kernel_import.cmake")
elseif(PICO_BOARD STREQUAL "pico2" OR PICO_BOARD STREQUAL "pico2_w")
set(freertos_port_path "portable/ThirdParty/Community-Supported-Ports/GCC/RP2350_ARM_NTZ/FreeRTOS_Kernel_import.cmake")
else()
message(FATAL_ERROR "Board type unknown to BBOS: ${PICO_BOARD} - see hardware/rp2xxx/prebuild.cmake for instructions")
endif()
# If using a Pico wireless variant, include the cyw43 library
# Any other board names that use cyw43 would have to be added here too
if(PICO_BOARD STREQUAL "pico_w" OR PICO_BOARD STREQUAL "pico2_w")
add_compile_definitions(HAS_CYW43)
if(ENABLE_WIFI)
# include CY43 lwIP support
list(APPEND hardware_libs #"pico_cyw43_arch_lwip_sys_freertos" # for lwip NO_SYS=0
"pico_cyw43_arch_lwip_threadsafe_background" # for lwip NO_SYS=1
)
list(APPEND hardware_includes ${hardware_dir}/net_inc)
if(ENABLE_HTTPD)
list(APPEND hardware_libs "lwip_httpd_content"
"pico_lwip_mdns"
"pico_lwip_http"
)
list(APPEND hardware_includes ${PICO_LWIP_CONTRIB_PATH}/apps/httpd)
endif()
else()
list(APPEND hardware_libs pico_cyw43_arch_none) # basic CYW43 support
set(ENABLE_WIFI false)
endif()
else()
if(ENABLE_WIFI)
message(WARNING "Board does not support WiFi, disabling this option")
set(ENABLE_WIFI false)
endif()
endif()
# Make sure no networking features are enabled if WiFi is disabled
if(NOT ENABLE_WIFI AND ENABLE_HTTPD)
message(WARNING "Disabling httpd due to WiFi option being disabled")
set(ENABLE_HTTPD false)
endif()
================================================
FILE: hardware/rp2xxx/rtos_config.h
================================================
/******************************************************************************
* @file rtos_config.h
*
* @brief Hardware-specific configuration options for FreeRTOS, included by
* rtos/FreeRTOSConfig.h, which contains all the basic settings.
* Only FreeRTOS settings that are MCU-specific are defined here.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 01-14-2025
*
* @copyright Copyright (c) 2025 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#ifndef RTOS_CONFIG_H
#define RTOS_CONFIG_H
// FreeRTOS total heap size settings - trial and error to find what linker will accept
// RP2040 has 264KB RAM total, RP2350 has 520KB RAM total. RTOS heap will be something less than this.
// Using the wireless stack appears to chew up about 30-40KB.
#if defined(USING_RP2350) && !defined(HW_USE_WIFI)
#define RTOS_HEAP_SIZE (489*1024) // RP2350 without wireless stack
#elif defined(USING_RP2350) && defined(HW_USE_WIFI)
#define RTOS_HEAP_SIZE (439*1024) // RP2350 with wireless stack
#elif defined(USING_RP2040) && !defined(HW_USE_WIFI)
#define RTOS_HEAP_SIZE (235*1024) // RP2040 without wireless stack
#elif defined(USING_RP2040) && defined(HW_USE_WIFI)
#define RTOS_HEAP_SIZE (186*1024) // RP2040 with wireless stack
#endif
// For FreeRTOS SMP (multicore) support only
#define RTOS_NUM_CORES 1
#define RTOS_TICK_CORE 0
#define RTOS_RUN_MULTIPLE_PRIORITIES 1
#define RTOS_USE_CORE_AFFINITY 1
#define RTOS_USE_PASSIVE_IDLE_HOOK 0
// RP2040/RP2350-specific FreeRTOS settings
#define configSUPPORT_PICO_SYNC_INTEROP 1
#define configSUPPORT_PICO_TIME_INTEROP 1
// timer init to be called before runtime stats
#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()
extern uint64_t get_time_us(void); // extern declared so we can use here, defined in hw_clocks.c
// divider for proper runtime stats granularity
#define RUN_TIME_STATS_time_us_64_divider (1e6 / configTICK_RATE_HZ)
// function to use for run time stats timer
#define portGET_RUN_TIME_COUNTER_VALUE() (get_time_us() / RUN_TIME_STATS_time_us_64_divider)
// RP2350-specific - ARMv8m/Cortex-m33 options
#ifdef USING_RP2350
#define configENABLE_TRUSTZONE 0
#define configRUN_FREERTOS_SECURE_ONLY 1
#define configENABLE_FPU 1
#define configENABLE_MPU 0
#define configMAX_SYSCALL_INTERRUPT_PRIORITY 16
#endif
#endif /* RTOS_CONFIG_H */
================================================
FILE: littlefs/CMakeLists.txt
================================================
# This file configures the build for the littlefs submodule, which is built
# as a static library to be used by the main application.
# The littlefs submodule is nested within another littlefs directory for ease
# of wrapping in CMake (littlefs project is Makefile-based)
# create littlefs library to use at top level
add_library(littlefs STATIC
${CMAKE_CURRENT_LIST_DIR}/littlefs/lfs_util.c
${CMAKE_CURRENT_LIST_DIR}/littlefs/lfs.c
)
target_include_directories(littlefs PUBLIC
${CMAKE_CURRENT_LIST_DIR}/littlefs
)
target_compile_options(
littlefs
PRIVATE
-Werror -g -O0
)
# TODO: try to add -Wall and -Wextra to compile options to clean up more warnings
================================================
FILE: main.c
================================================
/******************************************************************************
* @file main.c
*
* @brief Main entrypoint of the application.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include "hardware_config.h"
#include "device_drivers.h"
#include "services/services.h"
#include "task.h"
/************************
* Here be main
*************************/
void main()
{
// initialize hardware
hardware_init();
// initialize any connected peripheral devices
driver_init();
// register the taskmanager base service
taskman_service();
// start the rtos scheduler (boot the system!)
vTaskStartScheduler();
// will not reach here unless rtos crashes, reboot if that happens
force_watchdog_reboot();
}
================================================
FILE: project.cmake
================================================
# PROJECT NAME - in quotes, no spaces
set(PROJ_NAME "my-bbos-proj")
# PROJECT VERSION - in quotes, no spaces, can contain alphanumeric if necessary
set(PROJ_VER "0.0")
# CLI INTERFACE - 0: use UART for CLI (default), 1: use USB for CLI
set(CLI_IFACE 0)
# MCU PLATFORM - set the MCU platform being used (i.e. the subdir in 'hardware/')
set(PLATFORM rp2xxx)
# BOARD - set the board being used (platform-specific prebuild.cmake contains more information about boards)
set(BOARD pico2_w)
# HOSTNAME - hostname will be shown at CLI prompt, and used for network connections
set(HOSTNAME "bbos")
# BUILD OPTIONS - individual features which can be enabled or disabled
option(ENABLE_MOTD "Enable Message of the Day print at boot" true)
option(ENABLE_WIFI "Enable WiFi support" true)
option(ENABLE_HTTPD "Enable httpd web server" true)
================================================
FILE: rtos/CMakeLists.txt
================================================
# add source files to the top-level project
target_sources(${PROJ_NAME} PRIVATE
rtos_utils.c
)
================================================
FILE: rtos/FreeRTOSConfig.h
================================================
/******************************************************************************
* @file FreeRTOSConfig.h
*
* @brief Configuration file for FreeRTOS.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
*
* See rtos_config.h in the hardware/[platform]/ folder for platform-specific
* FreeRTOS configuration settings.
*
* FreeRTOS
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* https://www.FreeRTOS.org
* https://github.com/FreeRTOS
*
******************************************************************************/
#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H
/*-----------------------------------------------------------
* Application specific definitions.
*
* These definitions should be adjusted for your particular hardware and
* application requirements.
*
* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
*
* See http://www.freertos.org/a00110.html
*----------------------------------------------------------*/
#include "rtos_config.h"
/* Scheduler Related */
#define configUSE_PREEMPTION 1
#define configUSE_TICKLESS_IDLE 0
#define configUSE_IDLE_HOOK 0
#define configUSE_TICK_HOOK 0
#define configTICK_RATE_HZ ( ( TickType_t ) 1000 )
#define configMAX_PRIORITIES 32
#define configMINIMAL_STACK_SIZE ( configSTACK_DEPTH_TYPE ) 256
#define configUSE_16_BIT_TICKS 0
#define configIDLE_SHOULD_YIELD 1
/* Synchronization Related */
#define configUSE_MUTEXES 1
#define configUSE_RECURSIVE_MUTEXES 1
#define configUSE_APPLICATION_TASK_TAG 0
#define configUSE_COUNTING_SEMAPHORES 1
#define configQUEUE_REGISTRY_SIZE 8
#define configUSE_QUEUE_SETS 1
#define configUSE_TIME_SLICING 1
#define configUSE_NEWLIB_REENTRANT 0
#define configENABLE_BACKWARD_COMPATIBILITY 1 // needed for lwip FreeRTOS compatibility
#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 5
/* System */
#define configSTACK_DEPTH_TYPE uint32_t
#define configMESSAGE_BUFFER_LENGTH_TYPE size_t
/* Memory allocation related definitions. */
#define configSUPPORT_STATIC_ALLOCATION 0
#define configSUPPORT_DYNAMIC_ALLOCATION 1
#define configTOTAL_HEAP_SIZE RTOS_HEAP_SIZE // defined in hardware-specific CMakeLists.txt
#define configAPPLICATION_ALLOCATED_HEAP 0
/* Hook function related definitions. */
#define configCHECK_FOR_STACK_OVERFLOW 0
#define configUSE_MALLOC_FAILED_HOOK 0
#define configUSE_DAEMON_TASK_STARTUP_HOOK 0
/* Run time and task stats gathering related definitions. */
#define configGENERATE_RUN_TIME_STATS 1
#define configUSE_TRACE_FACILITY 1
#define configUSE_STATS_FORMATTING_FUNCTIONS 1
#define configRECORD_STACK_HIGH_ADDRESS 1
/* Co-routine related definitions. */
#define configUSE_CO_ROUTINES 0
#define configMAX_CO_ROUTINE_PRIORITIES 1
/* Software timer related definitions. */
#define configUSE_TIMERS 1
#define configTIMER_TASK_PRIORITY ( configMAX_PRIORITIES - 1 )
#define configTIMER_QUEUE_LENGTH 10
#define configTIMER_TASK_STACK_DEPTH 1024
/* Interrupt nesting behaviour configuration. */
/*
#define configKERNEL_INTERRUPT_PRIORITY [dependent of processor]
#define configMAX_SYSCALL_INTERRUPT_PRIORITY [dependent on processor and application]
#define configMAX_API_CALL_INTERRUPT_PRIORITY [dependent on processor and application]
*/
/* SMP port only - this is in mainline FreeRTOS 11 and up */
/* these are defined in hardware/[platform]/rtos_config.h */
#define configNUMBER_OF_CORES RTOS_NUM_CORES
#define configTICK_CORE RTOS_TICK_CORE
#define configRUN_MULTIPLE_PRIORITIES RTOS_RUN_MULTIPLE_PRIORITIES
#if configNUMBER_OF_CORES > 1
#define configUSE_CORE_AFFINITY RTOS_USE_CORE_AFFINITY
#endif
#define configUSE_PASSIVE_IDLE_HOOK RTOS_USE_PASSIVE_IDLE_HOOK
#include
/* Define to trap errors during development. */
#define configASSERT(x) assert(x)
/* Set the following definitions to 1 to include the API function, or zero
to exclude the API function. */
#define INCLUDE_vTaskPrioritySet 1
#define INCLUDE_uxTaskPriorityGet 1
#define INCLUDE_vTaskDelete 1
#define INCLUDE_vTaskSuspend 1
#define INCLUDE_vTaskDelayUntil 1
#define INCLUDE_vTaskDelay 1
#define INCLUDE_xTaskGetSchedulerState 1
#define INCLUDE_xTaskGetCurrentTaskHandle 1
#define INCLUDE_uxTaskGetStackHighWaterMark 1
#define INCLUDE_xTaskGetIdleTaskHandle 1
#define INCLUDE_eTaskGetState 1
#define INCLUDE_xTimerPendFunctionCall 1
#define INCLUDE_xTaskAbortDelay 1
#define INCLUDE_xTaskGetHandle 1
#define INCLUDE_xTaskResumeFromISR 1
#define INCLUDE_xQueueGetMutexHolder 1
/* A header file that defines trace macro can be included here. */
#endif /* FREERTOS_CONFIG_H */
================================================
FILE: rtos/rtos_utils.c
================================================
/******************************************************************************
* @file rtos_utils.c
*
* @brief Utility functions to use for various RTOS interactions
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include
#include "hardware_config.h"
#include "rtos_utils.h"
#include "FreeRTOSConfig.h"
#include "FreeRTOS.h"
#include "task.h"
void task_sched_update(uint32_t repeat, const TickType_t delay) {
#ifdef SCHED_TEST_DELAY
// used for OS scheduler testing - force task to take at least this
// much time for more usable data from vTaskGetRunTimeStats()
// set this to at least the OS tick rate
wait_here_us(1000);
#endif
if (xTaskGetTickCount() % repeat == 0) {
vTaskDelay(delay);
}
}
void task_delay_ms(uint32_t delay_ms) {
TickType_t delay_ticks = (TickType_t)(delay_ms * configTICK_RATE_HZ / 1000); // convert millisecond delay to OS ticks
vTaskDelay(delay_ticks);
}
================================================
FILE: rtos/rtos_utils.h
================================================
/******************************************************************************
* @file rtos_utils.h
*
* @brief Utility functions to use for various RTOS interactions
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#ifndef RTOS_UTILS_H
#define RTOS_UTILS_H
#include
#include "FreeRTOS.h"
#include "task.h"
/**
* @brief Check and update task against scheduler parameters.
*
* Checks the current task's OS scheduler info and compares against pre-defined
* schedule parameters (see services.h), blocking the task if necessary per the
* given parameters.
*
* @param repeat number of times to repeat a task, see services.h
* @param delay number of OS ticks to block a task, see services.h
*
* @return nothing
*/
void task_sched_update(uint32_t repeat, const TickType_t delay);
#endif
/**
* @brief Delay a task by a specified number of milliseconds.
*
* Converts the provided millisecond value into OS ticks, and calls the FreeRTOS
* vTaskDelay function to block the calling task for at least that amount of time.
*
* @param delay_ms time in milliseconds for the calling task to block itself
*
* @return nothing
*/
void task_delay_ms(uint32_t delay_ms);
================================================
FILE: services/CMakeLists.txt
================================================
# add source files to the top-level project
target_sources(${PROJ_NAME} PRIVATE
services.c
service_queues.c
cli_service.c
usb_service.c
taskman_service.c
storman_service.c
watchdog_service.c
heartbeat_service.c
)
if (ENABLE_WIFI)
target_sources(${PROJ_NAME} PRIVATE
netman_service.c
)
endif()
================================================
FILE: services/cli_service.c
================================================
/******************************************************************************
* @file cli_service.c
*
* @brief CLI service implementation and FreeRTOS task creation.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include
#include
#include
#include "version.h"
#include "hardware_config.h"
#include "rtos_utils.h"
#include "shell.h"
#include "cli_utils.h"
#include "services.h"
#include "service_queues.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#ifndef PRINT_MOTD_AT_BOOT
#define PRINT_MOTD_AT_BOOT false
#endif
static void prvCliTask(void *pvParameters); // microshell cli task
TaskHandle_t xShellTask;
char BBOS_VERSION_MOD; // global "modified version" variable - declared in version.h
// main service function, creates FreeRTOS task from prvCliTask
BaseType_t cli_service(void)
{
BaseType_t xReturn;
shell_init(); // init microshell cli
// spawn the cli task
xReturn = xTaskCreate(
prvCliTask,
xstr(SERVICE_NAME_CLI),
STACK_CLI,
NULL,
PRIORITY_CLI,
&xShellTask
);
// print timestamp value
cli_uart_puts(timestamp());
if (xReturn == pdPASS) {
cli_uart_puts("CLI service started\r\n");
}
else {
cli_uart_puts("Error starting the CLI service\r\n");
}
return xReturn;
}
// FreeRTOS task created by cli_service
static void prvCliTask(void *pvParameters)
{
char print_string[PRINT_QUEUE_ITEM_SIZE];
extern const char *bbos_header_ascii;
// Set the global "modified version" indicator if on a branch other than main
BBOS_VERSION_MOD = strcmp(git_Branch(), "main") ? '+' : ' ';
// delay CLI startup to allow taskmanager to finish with its startup status prints
vTaskDelay(DELAY_TASKMAN * 5);
// print MOTD for additional YouTube likes
if (PRINT_MOTD_AT_BOOT) {
// initialize toasty graphics - make sure your MCU is liquid cooled...
cli_uart_puts(timestamp());
cli_uart_puts("Initializing toasty graphics");
for (int i = 0; i < 10; i++) {
wait_here_us(2E5); // waste a bunch of cycles for no reason
cli_uart_putc('.');
}
cli_uart_puts("\r\n");
print_motd();
}
// copy the CLI ASCII header into RAM
char *cli_header = pvPortMalloc(strlen(bbos_header_ascii+2)); // two extra bytes for BBOS_VERSION_MOD and NULL
strcpy(cli_header, bbos_header_ascii);
// add the "modified version" indicator to the header
memcpy( (cli_header + strlen(cli_header) - 78) , &BBOS_VERSION_MOD, 1); // manually offset to the correct position
// print the ASCII header before dropping into the CLI
shell_print(cli_header);
// free up the RAM
vPortFree(cli_header);
while(true) {
// peek into the print queue to see if an item is available
if (xQueuePeek(print_queue, (void *)&print_string, 0) == pdTRUE) {
// only pull an item from the queue if microshell is available to process it
// note that if any characters have been entered at the prompt, it will
// block prints from the queue so as not to interfere with user input
if (ush.state == USH_STATE_READ_CHAR && ush.in_pos == 0) {
if (xQueueReceive(print_queue, (void *)&print_string, 0) == pdTRUE) {
shell_print(print_string);
}
}
}
shell_service(); // the main cli service gets called forever in a loop
// update this task's schedule
task_sched_update(REPEAT_CLI, DELAY_CLI);
}
}
================================================
FILE: services/heartbeat_service.c
================================================
/******************************************************************************
* @file heartbeat_service.c
*
* @brief Heartbeat service implementation and FreeRTOS task creation.
* This can be used as a reference for how to create a simple "service"
* (FreeRTOS task), and how to pass output strings to the CLI service
* (in lieu of stdout/printf) via the 'cli_print' functions which utilize
* inter-task queues.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include "hardware_config.h"
#include "rtos_utils.h"
#include "services.h"
#include "service_queues.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
// when using this example to implement a new service, replace all references
// to "hearbeat" with the new service name.
static void prvHeartbeatTask(void *pvParameters); // entry function for this service, implementation below
TaskHandle_t xHeartbeatTask; // FreeRTOS task handle for this service
// service creation function, creates FreeRTOS task xHeartbeatTask from entry function prvHeartbeatTask
// this is the function pointer added to the service_functions[] array in services.h
BaseType_t heartbeat_service(void)
{
BaseType_t xReturn;
xReturn = xTaskCreate(
prvHeartbeatTask, // main function of this service, defined below
xstr(SERVICE_NAME_HEARTBEAT), // name defined in services.h
STACK_HEARTBEAT, // stack size defined in services.h
NULL, // parameters passed to created task (not used)
PRIORITY_HEARTBEAT, // priority of this service, defined in services.h
&xHeartbeatTask // FreeRTOS task handle
);
if (xReturn == pdPASS) {
cli_print_raw("heartbeat service started");
}
else {
cli_print_raw("Error starting the heartbeat service");
}
return xReturn;
}
// FreeRTOS task created by heartbeat_service
static void prvHeartbeatTask(void *pvParameters)
{
//
// Service startup (run once) code can be placed here
// (similar to Arduino setup(), if that's your thing)
//
static char *heartbeat_string = "ba-bump";
while(true) {
//
// Main service (run continuous) code can be placed here
// (similar to Arduino loop(), if that's your thing)
//
cli_print_timestamped(heartbeat_string);
// always include the below, with REPEAT & DELAY settings in services.h,
// otherwise the service will starve out other RTOS tasks
// update this task's schedule
task_sched_update(REPEAT_HEARTBEAT, DELAY_HEARTBEAT);
}
// the task runs forever unless the RTOS kernel suspends or kills it.
// for a one-shot service, just eliminate the infinite loop.
}
================================================
FILE: services/netman_service.c
================================================
/******************************************************************************
* @file netman_service.c
*
* @brief networkmanager service implementation and FreeRTOS task creation.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 01-24-2025
*
* @copyright Copyright (c) 2025 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include
#include "hardware_config.h"
#include "rtos_utils.h"
#include "services.h"
#include "service_queues.h"
#include "shell.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "hw_wifi.h"
#include "hw_net.h"
static void prvNetworkManagerTask(void *pvParameters); // network manager task
TaskHandle_t xNetManTask;
struct netman_info_t nmi_glob; // global network manager status info
extern void shell_net_mount(void); // declared in this file so /net can be mounted on-the-fly
// main service function, creates FreeRTOS task from prvNetworkManagerTask
BaseType_t netman_service(void)
{
BaseType_t xReturn;
xReturn = xTaskCreate(
prvNetworkManagerTask,
xstr(SERVICE_NAME_NETMAN),
STACK_NETMAN,
NULL,
PRIORITY_NETMAN,
&xNetManTask
);
// print timestamp value
cli_uart_puts(timestamp());
if (xReturn == pdPASS) {
cli_uart_puts("Network manager service started\r\n");
} else {
cli_uart_puts("Error starting the network manager service\r\n");
}
return xReturn;
}
static void prvNetworkManagerTask(void *pvParameters) {
// network manager action queue item
netman_action_t nm_action;
// initialize the wireless module. Note that this is done here in the task
// because many network stacks/libraries are FreeRTOS-specific and so need
// to be initialized when the OS is already running.
if (hw_wifi_init()) { // todo: wifi country should be configurable
hw_wifi_enable_sta_mode();
cli_print_timestamped("WiFi hardware ready to connect");
shell_net_mount(); // create '/net' node in the shell
netman_request(NETJOIN); // auto-connect (will fail if '/net/wifi setauth' never used)
} else {
cli_print_timestamped("WiFi init failed");
}
while(true) {
// Check the networkmanager action queue to see if an item is available
if (xQueueReceive(netman_action_queue, (void *)&nm_action, 0) == pdTRUE)
{
// determine what action to perform
switch(nm_action)
{
case NETJOIN: // join a network (connect)
struct storman_item_t smi;
char *wifi_ssid;
char *wifi_pass;
bool continue_connect = false;
// make sure we aren't already connected
if (nmi_glob.status == HW_WIFI_STATUS_UP) {
cli_print_raw("already connected to network");
break;
}
// get network credentials from the filesystem
smi.action = CHKFILE;
strcpy(smi.sm_item_name, "wifi_auth");
storman_request(&smi);
// wait for storagemanager to provide semaphore indicating file exists
if (xSemaphoreTake(smi_glob_sem, DELAY_STORMAN * 2) == pdTRUE) {
// read credentials file
smi.action = DUMPFILE;
strcpy(smi.sm_item_name, "wifi_auth");
storman_request(&smi);
// wait for storagemanager to provide semaphore indicating data is ready
if (xSemaphoreTake(smi_glob_sem, DELAY_STORMAN * 2) == pdTRUE) {
// Split the credentials into SSID and password
wifi_ssid = strtok(smi_glob.sm_item_data, ",");
wifi_pass = strtok(NULL, ",");
// check for valid credentials
if (wifi_ssid == NULL || wifi_pass == NULL) {
cli_print_raw("invalid wifi credentials format");
break;
} else {
continue_connect = true;
}
}
} else {
// this will print if the semaphore was never given by storagemanager
cli_print_raw("no wifi credentials found");
break;
}
if (continue_connect) { // attempt to connect to the network
char connect_msg[60];
uint64_t start_time = get_time_us(); // used to set a timeout
bool timed_out = false;
sprintf(connect_msg, "connecting to %s network...", wifi_ssid);
if (hw_wifi_connect_async(wifi_ssid, wifi_pass, HW_WIFI_AUTH_WPA2_AES_PSK)) {
cli_print_raw(connect_msg);
while(hw_wifi_get_addr()->addr == 0) {
if (get_time_us() - start_time > 20000000) { // 20 seconds
timed_out = true;
hw_wifi_reset_connection();
break;
}
vTaskDelay(100); // spin every 100 OS ticks until connection is up
}
if (!timed_out) {
nmi_glob.status = HW_WIFI_STATUS_UP;
char ip_msg[32];
snprintf(ip_msg, 32, "wifi connected: %s", ip4addr_ntoa(hw_wifi_get_addr()));
cli_print_raw(ip_msg);
nmi_glob.ip = hw_wifi_get_addr()->addr;
/* enable optional networking features */
#ifdef ENABLE_HTTPD
net_mdns_init();
net_httpd_stack_init();
char httpd_msg[40+strlen(CYW43_HOST_NAME)];
sprintf(httpd_msg, "web console accessible at http://%s.local", CYW43_HOST_NAME);
cli_print_raw(httpd_msg);
#endif
/* end enable optional networking features */
} else {
cli_print_raw("wifi connection timed out");
}
} else {
cli_print_raw("could not start wifi connection");
}
}
break;
case NETLEAVE: // leave a network (disconnect)
if (nmi_glob.status == HW_WIFI_STATUS_UP) {
hw_wifi_reset_connection();
nmi_glob.status = HW_WIFI_STATUS_LINK_DOWN;
nmi_glob.ip = 0;
cli_print_raw("wifi disconnected");
} else {
cli_print_raw("not connected to a network");
}
break;
default:
break;
}
}
// update this task's schedule
task_sched_update(REPEAT_NETMAN, DELAY_NETMAN);
}
}
================================================
FILE: services/service_queues.c
================================================
/******************************************************************************
* @file service_queues.c
*
* @brief Initialization and helper functions for interaction with the queues
* used by FreeRTOS tasks.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include
#include "services.h"
#include "service_queues.h"
#include "shell.h"
#include "FreeRTOS.h"
#include "queue.h"
// global declarations in services.h
QueueHandle_t print_queue;
QueueHandle_t taskman_queue;
QueueHandle_t storman_queue;
QueueHandle_t usb0_rx_queue;
QueueHandle_t usb0_tx_queue;
QueueHandle_t netman_action_queue;
// create task queues
bool init_queues(void) {
// initialize all queues
print_queue = xQueueCreate(PRINT_QUEUE_DEPTH, PRINT_QUEUE_ITEM_SIZE);
taskman_queue = xQueueCreate(TASKMAN_QUEUE_DEPTH, TASKMAN_QUEUE_ITEM_SIZE);
storman_queue = xQueueCreate(STORMAN_QUEUE_DEPTH, STORMAN_QUEUE_ITEM_SIZE);
usb0_rx_queue = xQueueCreate(USB0_RX_QUEUE_DEPTH, USB0_RX_QUEUE_ITEM_SIZE);
usb0_tx_queue = xQueueCreate(USB0_TX_QUEUE_DEPTH, USB0_TX_QUEUE_ITEM_SIZE);
#ifdef HW_USE_WIFI
netman_action_queue = xQueueCreate(NETMAN_ACTION_QUEUE_DEPTH, NETMAN_ACTION_QUEUE_ITEM_SIZE);
#endif
// make sure they were all created successfully
if (print_queue != NULL &&
taskman_queue != NULL &&
storman_queue != NULL &&
usb0_rx_queue != NULL &&
usb0_tx_queue != NULL &&
netman_action_queue != NULL ) {
return 0;
} else {
return 1;
}
}
/*******************************************
* helper functions to interact with queues
********************************************/
bool cli_print_raw(char *string) {
if (xQueueSend(print_queue, string, 10) == pdTRUE) { // add string to print queue, waiting 10 os ticks max
return true;
}
else return false;
}
bool cli_print_timestamped(char *string) {
bool queue_post_result;
char *timestamped_string = pvPortMalloc(TIMESTAMP_LEN + strlen(string));
sprintf(timestamped_string, timestamp());
sprintf(timestamped_string + strlen(timestamped_string), string);
if (xQueueSend(print_queue, timestamped_string, 10) == pdTRUE) { // add string to print queue, waiting 10 os ticks max
queue_post_result = true;
}
else queue_post_result = false;
vPortFree(timestamped_string);
return queue_post_result;
}
bool taskman_request(struct taskman_item_t *tmi) {
if (xQueueSend(taskman_queue, tmi, 10) == pdTRUE) { // add request item to taskmanager queue, waiting 10 os ticks max
return true;
}
else return false;
}
bool storman_request(struct storman_item_t *smi) {
if (xQueueSend(storman_queue, smi, 10) == pdTRUE) { // add request item to storagemanager queue, waiting 10 os ticks max
return true;
}
else return false;
}
#ifdef HW_USE_WIFI
bool netman_request(netman_action_t nma) {
if (xQueueSend(netman_action_queue, &nma, 10) == pdTRUE) { // add request item to networkmanager queue, waiting 10 os ticks max
return true;
}
else return false;
}
#endif /* HW_USE_WIFI */
bool usb_data_get(uint8_t *usb_rx_data) {
if (xQueueReceive(usb0_rx_queue, usb_rx_data, 0) == pdTRUE) { // try to get any data in queue immediately so as not to block
return true;
}
else return false;
}
bool usb_data_put(uint8_t *usb_tx_data) {
if (xQueueSend(usb0_tx_queue, usb_tx_data, 10) == pdTRUE) { // add data item to usb tx queue, waiting 10 os ticks max
return true;
}
else return false;
}
================================================
FILE: services/service_queues.h
================================================
/******************************************************************************
* @file service_queues.h
*
* @brief Initialization and helper functions for interaction with the queues
* used by services (FreeRTOS tasks) for inter-task communications and
* data handling.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#ifndef SERVICE_QUEUES_H
#define SERVICE_QUEUES_H
#include
#include "hardware_config.h"
#include "shell.h"
#include "FreeRTOS.h"
#include "semphr.h"
#include "queue.h"
#include "lfs.h"
#ifdef HW_USE_WIFI
#include "hw_wifi.h"
#endif
/**********************************************************
* CLI printing queue -
* allows tasks other than CLI to print to the CLI UART/USB
***********************************************************/
extern QueueHandle_t print_queue;
// note: if any characters are entered after the prompt, the CLI will not pull
// from the print queue... so the queue depth represents how many output strings
// can be buffered in the queue until current user input is completed
#define PRINT_QUEUE_DEPTH 32
#define PRINT_QUEUE_ITEM_SIZE BUF_OUT_SIZE
/*************************************************
* Task manager queue -
* used to pass commands for managing task control
**************************************************/
extern QueueHandle_t taskman_queue;
typedef enum tm_action_t {DELETE, SUSPEND, RESUME} tm_action_t; // action to take on task
typedef struct taskman_item_t {TaskHandle_t task; tm_action_t action;} taskman_item_t; // queue item - struct for taskID & action
#define TASKMAN_QUEUE_DEPTH 1
#define TASKMAN_QUEUE_ITEM_SIZE sizeof(taskman_item_t)
/*****************************************************************
* Storage manager queue -
* pass commands & data for interacting with onboard flash storage
******************************************************************/
extern QueueHandle_t storman_queue;
// storagemanager actions for interacting with littlefs
typedef enum {LSDIR, // list directory contents
MKDIR, // create a new directory
RMDIR, // delete a directory and its contents
MKFILE, // create a new empty file
RMFILE, // delete a file
DUMPFILE, // dump entire contents of file
READFILE, // read a portion of a file
WRITEFILE, // overwrite a file
APPENDFILE, // append data to end of file
FILESTAT, // get file statistics
CHKFILE, // check if a file exists without error
FSSTAT, // get filesystem statistics
FORMAT, // format the filesystem
UNMOUNT // unmount the filesystem and stop the service
} storman_action_t;
// the storagemanager queue item structure
typedef struct storman_item_t {storman_action_t action;
char sm_item_name[PATHNAME_MAX_LEN]; // file or directory name
lfs_soff_t sm_item_offset; // offset in file to read/write
long sm_item_size; // size of data to read/write
char sm_item_data[FILE_SIZE_MAX]; // file input/output data
struct lfs_info sm_item_info; // littlefs info structure
} storman_item_t;
// global structure to hold storagemanager status data
extern struct storman_item_t smi_glob;
// global storagemanager status binary semaphore - for data ready synchronization
extern SemaphoreHandle_t smi_glob_sem;
#define STORMAN_QUEUE_DEPTH 1
#define STORMAN_QUEUE_ITEM_SIZE sizeof(smi_glob)
#ifdef HW_USE_WIFI
/************************************************************
* Network manager queue -
* pass commands & data for interacting with network hardware
*************************************************************/
extern QueueHandle_t netman_action_queue;
// networkmanager actions for interacting with network hardware
typedef enum {NETJOIN, // join a network
NETLEAVE // leave a network
} netman_action_t;
// the networkmanager instance info structure
typedef struct netman_info_t {hw_wifi_status_t status; // network connection status
hw_wifi_ip_addr_t ip; // current IP address (IPv4)
} netman_info_t;
// global structure to hold networkmanager status info
extern struct netman_info_t nmi_glob;
#define NETMAN_ACTION_QUEUE_DEPTH 1
#define NETMAN_ACTION_QUEUE_ITEM_SIZE sizeof(netman_action_t)
#endif /* HW_USE_WIFI */
/**********************************************************
* USB device queue -
* holds buffered data bytes to or from the TinyUSB service
***********************************************************/
extern QueueHandle_t usb0_rx_queue;
extern QueueHandle_t usb0_tx_queue;
#define USB0_RX_QUEUE_DEPTH 8
#define USB0_TX_QUEUE_DEPTH 8
#define USB0_RX_QUEUE_ITEM_SIZE CFG_TUD_CDC_RX_BUFSIZE
#define USB0_TX_QUEUE_ITEM_SIZE CFG_TUD_CDC_TX_BUFSIZE
/************************
* Queue helper functions
*************************/
/**
* @brief Initialize all queues.
*
* This routine uses the FreeRTOS xQueueCreate API to create each queue used
* in the system. All queues are created even if the tasks that use them have
* not yet been started.
*
* @param none
*
* @return 0 upon success, 1 upon failure
*/
bool init_queues(void);
// queue helper functions
/**
* @brief Print a raw string out to the CLI.
*
* This function puts a string pointer into the CLI printing queue exactly as
* passed.
*
* @param string pointer to the string to put in the queue for printing
*
* @return nothing
*/
bool cli_print_raw(char *string);
/**
* @brief Print a timestamped string out to the CLI.
*
* This function prepends a timestamp onto the given string and then drops the
* new timestamped string pointer into the CLI printing queue.
*
* @param string pointer to the string to put in the queue for printing
*
* @return nothing
*/
bool cli_print_timestamped(char *string);
/**
* @brief Send a request to taskmanager.
*
* This helper function puts a taskmanager request item structure into the
* taskmanager service's queue for performing control actions on available
* services.
*
* @param tmi pointer to the taskmanager request item to put into the queue for
* controlling services
*
* @return true if item successfully queued, otherwise false (queue full)
*/
bool taskman_request(struct taskman_item_t *tmi);
/**
* @brief Send a request to storagemanager.
*
* This helper function puts a storagemanager request item structure into the
* storagemanager service's queue for interaction with a filesystem.
*
* @param smi pointer to the storagemanger request item to put into the queue for
* filesystem access
*
* @return true if item successfully queued, otherwise false (queue full)
*/
bool storman_request(struct storman_item_t *smi);
#ifdef HW_USE_WIFI
/**
* @brief Send a request to networkmanager.
*
* This helper function puts a networkemanager action request item into the
* networkmanager service's queue for interaction with a the network hardware.
*
* @param nma networkmanger request item to put into the queue for network
hardware interaction
*
* @return true if item successfully queued, otherwise false (queue full)
*/
bool netman_request(netman_action_t nma);
#endif /* HW_USE_WIFI */
/**
* @brief Get any data bytes in the USB RX buffer queue.
*
* This function will copy data (if available) out of the USB device RX queue.
* This data is in the form of a byte array up to the size of the USB RX buffer.
*
* @param usb_rx_data pointer to the buffer to copy the data from the rx queue into
*
* @return true if item retrieved, otherwise false (queue empty)
*/
bool usb_data_get(uint8_t *usb_rx_data);
/**
* @brief Put data bytes into the USB TX buffer queue.
*
* This function will put data to send into the USB TX queue. This data is a
* null-terminated byte array up to the size of the USB TX buffer.
*
* @param usb_rx_data pointer to the null-terminated data buffer to copy into the tx queue
*
* @return true if item successfully queued, otherwise false (queue full)
*/
bool usb_data_put(uint8_t *usb_tx_data);
#endif /* SERVICES_QUEUES_H */
================================================
FILE: services/services.c
================================================
/******************************************************************************
* @file services.c
*
* @brief Defines the service descriptors for each system service declared in
* services.h. These service descriptors are used to associate a service
* name string with a service function pointer, as well as indicate if
* the service should be started at boot. The individual service function
* implementations and FreeRTOS APIs for registering the associated tasks
* are contained in the source files for the respective services. Queues
* used to pass data between services are implemented in service_queues.h.
*
* @author @nbes4 (github)
*
* @date 06-18-2024
*
* @copyright Copyright (c) 2024 @nbes4 (github)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include "services.h"
// see services.h for more information on creating services
// note: use xstr() to convert the SERVICE_NAME_ #define from services.h to a usable string
// (e.g. xstr(SERVICE_NAME_HEARTBEAT))
const service_desc_t service_descriptors[] = {
{
.name = xstr(SERVICE_NAME_USB),
.service_func = usb_service,
.startup = true
},
{
.name = xstr(SERVICE_NAME_CLI),
.service_func = cli_service,
.startup = true
},
{
.name = xstr(SERVICE_NAME_STORMAN),
.service_func = storman_service,
.startup = true
},
#ifdef HW_USE_WIFI
{
.name = xstr(SERVICE_NAME_NETMAN),
.service_func = netman_service,
.startup = true
},
#endif /* HW_USE_WIFI */
{
.name = xstr(SERVICE_NAME_WATCHDOG),
.service_func = watchdog_service,
.startup = true
},
{
.name = xstr(SERVICE_NAME_HEARTBEAT),
.service_func = heartbeat_service,
.startup = false
}
};
const size_t service_descriptors_length = sizeof(service_descriptors)/sizeof(service_desc_t);
================================================
FILE: services/services.h
================================================
/******************************************************************************
* @file services.h
*
* @brief Defines all of the services available on the system. The individual
* service function implementations and FreeRTOS APIs for registering the
* associated tasks are contained in the source files for the respective
* services. Queues used to pass data between services are implemented
* in service_queues.h.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#ifndef SERVICES_H
#define SERVICES_H
#include
#include "hardware_config.h"
#include "shell.h"
#include "FreeRTOS.h"
#include "lfs.h"
/*******************************************************************************
* Services - Dynamic tasks to run in FreeRTOS.
* Services can be launched at boot or started/suspended/stopped at
* any time via 'taskmanager', the base service.
*
* If a new service is added, a SERVICE_NAME must be defined for it,
* and the service implementation and FreeRTOS task launcher must be
* created in a separate source file (see "heartbeat_service.c" for
* an example). The service's "descriptor" then needs to be added
* to the service_descriptors[] array in services.c, which associates
* the service's main function pointer with its name string, and
* defines whether the service should run at boot.
*
* The service schedule within FreeRTOS is determined by 3 parameters:
* Priority, Repeat, and Delay. Upon any given scheduler tick, the OS
* will run the task (service) with the highest priority. After a task
* runs, it will check if it should immediately run again based on the
* REPEAT parameter; if it has already repeated the specified number
* of times it will block itself for the specified number of ticks
* based on the DELAY parameter. This essentially means a task's run
* percentage (within a priority level) is given by REPEAT/DELAY.
*
* Pro tip: uncomment add_definitions(-DSCHED_TEST_DELAY) in the
* top-level CMakeLists.txt to burn extra cycles in each service, and
* then use the 'bin/top' CLI command to show FreeRTOS task runtime
* percentages to help tune the scheduler! Don't forget to comment
* this back out after testing!
*
* Note that by default, 1 OS tick is 1 ms.
* This can be changed in FreeRTOSConfig.h, see 'configTICK_RATE_HZ'
*******************************************************************************/
// stringify helper - use xstr() to convert #define to a usable string
#define str(s) # s
#define xstr(s) str(s)
// service names for spawning and interacting with rtos tasks - no quotes around them.
// note - max name length is 15 characters, defined by configMAX_TASK_NAME_LEN in FreeRTOS.h
#define SERVICE_NAME_TASKMAN taskmanager
#define SERVICE_NAME_CLI cli
#define SERVICE_NAME_USB usb
#define SERVICE_NAME_STORMAN storagemanager
#define SERVICE_NAME_NETMAN networkmanager
#define SERVICE_NAME_WATCHDOG watchdog
#define SERVICE_NAME_HEARTBEAT heartbeat
// freertos task priorities for the services.
// as long as configUSE_TIME_SLICING is set, equal priority tasks will share time.
#define PRIORITY_TASKMAN 1
#define PRIORITY_CLI 1
#define PRIORITY_USB 2
#define PRIORITY_STORMAN 3
#define PRIORITY_NETMAN 3
#define PRIORITY_WATCHDOG 1
#define PRIORITY_HEARTBEAT 1
// number of sequential time slices to run each service before beginning the
// delay interval set below. If a service should run most of the time, set REPEAT
// to a higher number and DELAY to a lower number.
#define REPEAT_TASKMAN 1
#define REPEAT_CLI 1
#define REPEAT_USB 1
#define REPEAT_STORMAN 1
#define REPEAT_NETMAN 1
#define REPEAT_WATCHDOG 1
#define REPEAT_HEARTBEAT 1
// OS ticks to block after each execution of a service (sets max execution interval).
// higher priority services should include some delay time to allow lower priority
// tasks to execute. Since the delay happens at the end of the service loop, the
// service should finish its current work before blocking itself with the delay.
// Note that if a service has delay of 0 and priority is > 0, the IDLE task will
// always be blocked and FreeRTOS will not be able to perform task cleanup (i.e. freeing RAM).
#define DELAY_TASKMAN 20
#define DELAY_CLI 1 // CLI delay could be increased at the expense of character I/O responsiveness
#define DELAY_USB 5
#define DELAY_STORMAN 100
#define DELAY_NETMAN 10 // This will impact network latency
#define DELAY_WATCHDOG 100
#define DELAY_HEARTBEAT 5000 // Example heartbeat service "beats" every 5 seconds when started
// FreeRTOS stack sizes for the services - "stack" in this sense is dedicated heap memory for a task.
// local variables within a service/task use this stack space.
// If pvPortMalloc is called within a task, it will allocate directly from shared FreeRTOS heap.
// Use 'bin/ps' command to show a service's min stack (memory usage high water mark)
// to determine if too much/too little has been allocated.
#define STACK_TASKMAN 512
#define STACK_CLI 1024
#define STACK_USB 1024
#define STACK_STORMAN 1024
#define STACK_NETMAN 1024
#define STACK_WATCHDOG configMINIMAL_STACK_SIZE // 256 by default
#define STACK_HEARTBEAT configMINIMAL_STACK_SIZE
/************************
* Service Functions
*************************/
// below are functions for launching the services.
// pointers to these are added to a service's .service_func descriptor item in
// services.c
/**
* @brief Start the taskmanager service.
*
* The taskmanager service is responsible for dynamically starting, suspending,
* stopping, and resuming services (FreeRTOS tasks). It does this by receiving a
* service name and action to perform from the taskmanager queue.
*
* @param none
*
* @return 32-bit integer corresponding to FreeRTOS return status defined in projdefs.h
*/
BaseType_t taskman_service(void);
/**
* @brief Start the CLI service.
*
* The CLI (Command Line Interface) service is an instance of microshell that
* provides the ability to interact with the system, run routines, and see text
* output using a serial terminal connected to a UART (or USB) on the MCU. It has
* additional wrappers and a printing queue which allows other services to print
* strings out from the CLI while remaining thread-safe.
*
* @param none
*
* @return 32-bit integer corresponding to FreeRTOS return status defined in projdefs.h
*/
BaseType_t cli_service(void);
/**
* @brief Start the USB service.
*
* The USB service manages the data pipe to/from the USB controller, operating in
* device mode, via the TinyUSB library. It is intended to run continuously at a
* low priority, checking for available TX/RX data in a non-blocking fashion.
* Data links between other tasks and USB endpoints are facilitated via data queues.
*
* @param none
*
* @return 32-bit integer corresponding to FreeRTOS return status defined in projdefs.h
*/
BaseType_t usb_service(void);
/**
* @brief Start the storagemanager service.
*
* The storagemanager service is responsible for maintaining the filesystem(s) in
* onboard flash that can be used to store persistent settings, logs, etc. It does
* this by implementing littlefs instances. All data transport to/from flash is
* done via the storagemanager queue.
*
* @param none
*
* @return 32-bit integer corresponding to FreeRTOS return status defined in projdefs.h
*/
BaseType_t storman_service(void);
/**
* @brief Start the networkmanager service.
*
* The networkmanager service is responsible for managing the network connection
* (currently only WiFi). It brings up/down WiFi hardware, manages credentials,
* and connects/disconnets to/from the wireless network. It also provides current
* network status upon request. The networkmanager also handles all network data
* transport via the networkmanager data queue.
*
* @param none
*
* @return 32-bit integer corresponding to FreeRTOS return status defined in projdefs.h
*/
BaseType_t netman_service(void);
/**
* @brief Start the watchdog service.
*
* The watchdog service enables the system watchdog timer, and then resets the
* timer periodically, preventing the timer from expiring and resetting the MCU.
* If for some reason we are stuck in the weeds somewhere and the watchdog
* cannot be serviced, a system reset will hopefully restore sanity.
*
* @param none
*
* @return 32-bit integer corresponding to FreeRTOS return status defined in projdefs.h
*/
BaseType_t watchdog_service(void);
/**
* @brief Start the heartbeat service.
*
* The heartbeat service is an example service which demonstrates the ability to
* dynamically start a task, and suspend/resume/kill it with the taskmanager.
* It also demonstrates the usage of the CLI printing queue by placing a string
* to print in the queue every 5 seconds (the heartbeat message) - 12 bpm - effectively
* simulating the heartbeat of a blue whale.
*
* @param none
*
* @return 32-bit integer corresponding to FreeRTOS return status defined in projdefs.h
*/
BaseType_t heartbeat_service(void);
/************************
* Service Descriptors
*************************/
// service function pointer typedef
typedef BaseType_t (*service_func_t)(void);
// service descriptor structure to hold the service name, service function pointer and startup flag
typedef struct service_desc_t {
// string version of the service name, used when comparing against user input
const char * const name;
//Defines wether or not this service should be automatically launched by taskmanager at boot
const bool startup;
//Function pointer to the service that creates the respective FreeRTOS task - declared in services.h
service_func_t service_func;
} service_desc_t;
// holds all the services that can be launched with taskmanager.
// these can be in any order, the corresponding FreeRTOS tasks will be launched in this order.
// note: taskmanager itself is not in this array (it is a base service).
// edit services.c to add your own services!
extern const service_desc_t service_descriptors[];
// number of service descriptors in the array is used to iterate through services
// for startup and interaction
extern const size_t service_descriptors_length;
#endif /* SERVICES_H */
================================================
FILE: services/storman_service.c
================================================
/******************************************************************************
* @file storman_service.c
*
* @brief storagemanager service implementation and FreeRTOS task creation.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include
#include
#include "hardware_config.h"
#include "rtos_utils.h"
#include "shell.h"
#include "services.h"
#include "service_queues.h"
#include "hardware/flash.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
static void prvStorageManagerTask(void *pvParameters);
TaskHandle_t xStorManTask;
extern void shell_mnt_mount(void); // declared in this file so /mnt can be mounted on-the-fly
extern void shell_mnt_unmount(void); // declared in this file so /mnt can be unmounted on-the-fly
struct storman_item_t smi_glob; // write any resulting lfs data into global struct so it can be used by other tasks
SemaphoreHandle_t smi_glob_sem; // binary semaphore used to provide a data ready signal to other tasks
int err = 0; // used throughout the task to indicate that an error has occured
// main service function, creates FreeRTOS task from prvStorageManagerTask
BaseType_t storman_service(void)
{
BaseType_t xReturn;
// create the FreeRTOS task
xReturn = xTaskCreate(
prvStorageManagerTask,
xstr(SERVICE_NAME_STORMAN),
STACK_STORMAN,
NULL,
PRIORITY_STORMAN,
&xStorManTask
);
// print timestamp value
cli_uart_puts(timestamp());
if (xReturn == pdPASS) {
cli_uart_puts("Storage manager service running\r\n");
}
else {
cli_uart_puts("Error starting the storage manager service\r\n");
}
return xReturn;
}
// FreeRTOS task created by storman_service
static void prvStorageManagerTask(void *pvParameters)
{
// littlefs filesystem variables
lfs_t lfs_flash0;
lfs_file_t flash0_file;
lfs_dir_t flash0_dir;
// allocate memory for littlefs buffers
void *lfs_read_buffer = pvPortMalloc(FLASH0_PAGE_SIZE);
void *lfs_prog_buffer = pvPortMalloc(FLASH0_PAGE_SIZE);
void *lfs_lookahead_buffer = pvPortMalloc(FLASH0_LOOKAHEAD_SIZE);
// littlefs flash0 filesystem configuration
struct lfs_config fs_config_flash0 = {
// block device operation HAL functions
.read = onboard_flash_read,
.prog = onboard_flash_write,
.erase = onboard_flash_erase,
.sync = onboard_flash_sync,
// block device configuration
.read_size = 1,
.prog_size = FLASH0_PAGE_SIZE,
.block_size = FLASH0_BLOCK_SIZE,
.block_count = FLASH0_FS_SIZE / FLASH0_BLOCK_SIZE,
.block_cycles = FLASH0_BLOCK_CYCLES,
.cache_size = FLASH0_CACHE_SIZE,
.lookahead_size = FLASH0_LOOKAHEAD_SIZE,
// pre-allocated buffers
.read_buffer = lfs_read_buffer,
.prog_buffer = lfs_prog_buffer,
.lookahead_buffer = lfs_lookahead_buffer,
// other configurations
.name_max = PATHNAME_MAX_LEN, // max length of path+filenames
.file_max = FILE_SIZE_MAX, // max size of a file in bytes
};
// print some NVM initialization text
cli_uart_puts(timestamp());
cli_uart_puts("Initializing NVM...");
// mount the flash0 filesystem
if(lfs_mount(&lfs_flash0, &fs_config_flash0) == 0) {
shell_mnt_mount(); // create '/mnt' node in the shell
cli_uart_puts("flash0 mounted in /mnt\r\n");
} else {
// if non-zero, format and try again
cli_uart_puts("no filesystem found\r\n");
cli_uart_puts(timestamp());
cli_uart_puts("Formatting storage...\r\n"); // should only happen on first mount
if(lfs_format(&lfs_flash0, &fs_config_flash0) == 0) {
cli_uart_puts(timestamp());
cli_uart_puts("formatting complete - ");
if(lfs_mount(&lfs_flash0, &fs_config_flash0) == 0) { // retry mount
cli_uart_puts("flash0 mounted in /mnt\r\n");
} else {
cli_uart_puts("problem mounting flash0!\r\n");
}
} else {
cli_uart_puts(timestamp());
cli_uart_puts("problem formatting flash0!\r\n");
}
}
// create the binary semaphore used to signal other tasks that data is ready
smi_glob_sem = xSemaphoreCreateBinary();
while(true) {
err = 0;
// Check the storagemanager queue to see if an item is available
if (xQueueReceive(storman_queue, (void *)&smi_glob, 0) == pdTRUE)
{
// clear any existing semaphore in case a previous one was not taken
xSemaphoreTake(smi_glob_sem, 0);
// determine what action to perform in the filesystem.
// note that there may be further littlefs capabilities which are
// not implemented here. see "littlefs/lfs.h" for all APIs
switch(smi_glob.action)
{
case LSDIR: // list directory contents
err = lfs_dir_open(&lfs_flash0, &flash0_dir, smi_glob.sm_item_name);
if (err == 0) {
char *lsdir_output = (char*)pvPortMalloc(BUF_OUT_SIZE); // use FreeRTOS malloc and free, it is a large buffer
strcpy(lsdir_output, USH_SHELL_FONT_STYLE_BOLD
USH_SHELL_FONT_COLOR_BLUE
"File List\r\n"
"---------\r\n"
USH_SHELL_FONT_STYLE_RESET);
while(lfs_dir_read(&lfs_flash0, &flash0_dir, &smi_glob.sm_item_info) > 0) {
strcpy(lsdir_output + strlen(lsdir_output), smi_glob.sm_item_info.name);
if (smi_glob.sm_item_info.type == LFS_TYPE_DIR) { // check if this item is a directory
strcpy(lsdir_output + strlen(lsdir_output), "/"); // append a forward slash to the name if dir
}
strcpy(lsdir_output + strlen(lsdir_output), "\r\n");
};
strcpy(smi_glob.sm_item_data, lsdir_output); // use the global data to store a copy of the combined list output
smi_glob.sm_item_data[strlen(smi_glob.sm_item_data)] = 0; // put a null character at the end
xSemaphoreGive(smi_glob_sem); // provide the binary semaphore to indicate data is available
vPortFree(lsdir_output);
err = lfs_dir_close(&lfs_flash0, &flash0_dir);
}
break;
case MKDIR: // create a new directory
err = lfs_mkdir(&lfs_flash0, smi_glob.sm_item_name);
break;
case RMDIR: // delete a directory (only if empty)
// note: currently the same as RMFILE but kept separate for future enhancement (delete non-empty dirs, etc)
err = lfs_remove(&lfs_flash0, smi_glob.sm_item_name);
break;
case MKFILE: // create a new empty file (if file already exists, will generate error)
err = lfs_file_open(&lfs_flash0, &flash0_file, smi_glob.sm_item_name, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL);
if (err < 0) break;
err = lfs_file_write(&lfs_flash0, &flash0_file, NULL, (lfs_size_t)1); // may not be needed?
if (err < 0) break;
err = lfs_file_close(&lfs_flash0, &flash0_file);
break;
case RMFILE: // delete a file
err = lfs_remove(&lfs_flash0, smi_glob.sm_item_name);
break;
case DUMPFILE: // dump entire contents of file
err = lfs_file_open(&lfs_flash0, &flash0_file, smi_glob.sm_item_name, LFS_O_RDONLY);
if (err < 0) break;
err = lfs_file_read(&lfs_flash0, &flash0_file, smi_glob.sm_item_data, sizeof(smi_glob.sm_item_data));
if (err < 0) break;
smi_glob.sm_item_data[lfs_file_size(&lfs_flash0, &flash0_file)] = 0; // put a null character at the end of the file contents data
xSemaphoreGive(smi_glob_sem); // provide the binary semaphore to indicate data is available
err = lfs_file_close(&lfs_flash0, &flash0_file);
break;
case READFILE: // read a portion of a file
err = lfs_file_open(&lfs_flash0, &flash0_file, smi_glob.sm_item_name, LFS_O_RDONLY);
if (err < 0) break;
err = lfs_file_seek(&lfs_flash0, &flash0_file, smi_glob.sm_item_offset, LFS_SEEK_SET);
if (err < 0) break;
err = lfs_file_read(&lfs_flash0, &flash0_file, smi_glob.sm_item_data, smi_glob.sm_item_size);
if (err < 0) break;
smi_glob.sm_item_data[smi_glob.sm_item_size] = 0; // put a null character at the end of the read data
xSemaphoreGive(smi_glob_sem); // provide the binary semaphore to indicate data is available
err = lfs_file_close(&lfs_flash0, &flash0_file);
break;
case WRITEFILE: // write to a new file, or overwrite an existing file
err = lfs_file_open(&lfs_flash0, &flash0_file, smi_glob.sm_item_name, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC);
if (err < 0) break;
err = lfs_file_write(&lfs_flash0, &flash0_file, smi_glob.sm_item_data, (lfs_size_t)strlen(smi_glob.sm_item_data));
if (err < 0) break;
err = lfs_file_close(&lfs_flash0, &flash0_file);
break;
case APPENDFILE: // append data to end of existing file
err = lfs_file_open(&lfs_flash0, &flash0_file, smi_glob.sm_item_name, LFS_O_WRONLY | LFS_O_APPEND);
if (err < 0) break;
err = lfs_file_write(&lfs_flash0, &flash0_file, smi_glob.sm_item_data, (lfs_size_t)strlen(smi_glob.sm_item_data));
if (err < 0) break;
err = lfs_file_close(&lfs_flash0, &flash0_file);
break;
case FILESTAT: // get file statistics (size)
err = lfs_stat(&lfs_flash0, smi_glob.sm_item_name, &smi_glob.sm_item_info);
if (err < 0) break;
strcpy(smi_glob.sm_item_data, smi_glob.sm_item_info.name);
sprintf(smi_glob.sm_item_data + strlen(smi_glob.sm_item_data), ": %lu bytes", smi_glob.sm_item_info.size);
xSemaphoreGive(smi_glob_sem); // provide the binary semaphore to indicate data is available
break;
case CHKFILE: // check if a file exists without error
if (lfs_stat(&lfs_flash0, smi_glob.sm_item_name, &smi_glob.sm_item_info) == 0) {
xSemaphoreGive(smi_glob_sem); // provide the binary semaphore to indicate file exists
}
break;
case FSSTAT: // get filesystem statistics
smi_glob.sm_item_size = lfs_fs_size(&lfs_flash0);
if (smi_glob.sm_item_size < 0) {
err = smi_glob.sm_item_size;
break;
}
// format output for printing elsewhere
sprintf(smi_glob.sm_item_data, "Filesystem usage: %lu/%lu blocks (%lu/%lu bytes)",
smi_glob.sm_item_size,
FLASH0_FS_SIZE/FLASH0_BLOCK_SIZE,
smi_glob.sm_item_size*FLASH0_BLOCK_SIZE,
FLASH0_FS_SIZE);
xSemaphoreGive(smi_glob_sem); // provide the binary semaphore to indicate data is available
break;
case FORMAT: // format the filesystem (erase all contents)
if(lfs_format(&lfs_flash0, &fs_config_flash0) == 0 && lfs_mount(&lfs_flash0, &fs_config_flash0) == 0) {
strcpy(smi_glob.sm_item_data, "formatting complete");
}
else {
strcpy(smi_glob.sm_item_data, "problem formatting");
}
xSemaphoreGive(smi_glob_sem); // provide the binary semaphore to indicate data is available
break;
case UNMOUNT: // unmount the filesystem and stop the service
err = lfs_unmount(&lfs_flash0);
// free up buffers
vPortFree(lfs_read_buffer);
vPortFree(lfs_prog_buffer);
vPortFree(lfs_lookahead_buffer);
// remove the "/mnt" node from the CLI
shell_mnt_unmount();
break;
default:
break;
}
}
// check if there were any lfs errors and print to CLI
// error definitions come from enum lfs_error in lfs.h
if (err < 0) {
char err_msg[48] = "filesystem error: ";
switch (err)
{
case LFS_ERR_IO:
strcpy(err_msg + strlen(err_msg), "error during device operation");
break;
case LFS_ERR_CORRUPT:
strcpy(err_msg + strlen(err_msg), "corrupted");
break;
case LFS_ERR_NOENT:
strcpy(err_msg + strlen(err_msg), "entry does not exist");
break;
case LFS_ERR_EXIST:
strcpy(err_msg + strlen(err_msg), "entry already exists");
break;
case LFS_ERR_NOTDIR:
strcpy(err_msg + strlen(err_msg), "entry is not a dir");
break;
case LFS_ERR_ISDIR:
strcpy(err_msg + strlen(err_msg), "entry is a dir");
break;
case LFS_ERR_NOTEMPTY:
strcpy(err_msg + strlen(err_msg), "dir is not empty");
break;
case LFS_ERR_BADF:
strcpy(err_msg + strlen(err_msg), "bad file number");
break;
case LFS_ERR_FBIG:
strcpy(err_msg + strlen(err_msg), "file too large");
break;
case LFS_ERR_INVAL:
strcpy(err_msg + strlen(err_msg), "invalid parameter");
break;
case LFS_ERR_NOSPC:
strcpy(err_msg + strlen(err_msg), "no space left on device");
break;
case LFS_ERR_NOMEM:
strcpy(err_msg + strlen(err_msg), "no more memory available");
break;
case LFS_ERR_NOATTR:
strcpy(err_msg + strlen(err_msg), "no data/attr available");
break;
case LFS_ERR_NAMETOOLONG:
strcpy(err_msg + strlen(err_msg), "file name too long");
default:
strcpy(err_msg + strlen(err_msg), "unknown");
break;
}
cli_print_raw(err_msg);
}
if(smi_glob.action == UNMOUNT) {
// filesystem is already unmounted, delete this task
vTaskDelete(NULL);
}
// update this task's schedule
task_sched_update(REPEAT_STORMAN, DELAY_STORMAN);
}
}
================================================
FILE: services/taskman_service.c
================================================
/******************************************************************************
* @file taskman_service.c
*
* @brief taskmanager service implementation and FreeRTOS task creation.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include
#include "hardware_config.h"
#include "rtos_utils.h"
#include "shell.h"
#include "services.h"
#include "service_queues.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
static void prvTaskManagerTask(void *pvParameters);
TaskHandle_t xTaskManTask;
// main service function, creates FreeRTOS task from prvTaskManagerTask
BaseType_t taskman_service(void)
{
BaseType_t xReturn;
// create the FreeRTOS task
xReturn = xTaskCreate(
prvTaskManagerTask,
xstr(SERVICE_NAME_TASKMAN),
STACK_TASKMAN,
NULL,
PRIORITY_TASKMAN,
&xTaskManTask
);
// print timestamp value
cli_uart_puts(timestamp());
if (xReturn == pdPASS) {
// initialize all service queues
if (init_queues() == 0) {
cli_uart_puts("Task manager registered\r\n");
}
else {
cli_uart_puts("Error creating task queues\r\n");
}
}
else {
// if we got here, taskman service failed, no other services will start
cli_uart_puts("Error starting the taskmanager service\r\n");
}
return xReturn;
}
// FreeRTOS task created by taskman_service
static void prvTaskManagerTask(void *pvParameters)
{
struct taskman_item_t tmi;
// FreeRTOS scheduler is running by the time we get here. Print a message
cli_uart_puts(timestamp());
cli_uart_puts("FreeRTOS is running!\r\n");
// launch startup services
cli_uart_puts(timestamp());
cli_uart_puts("Starting all bootup services...\r\n");
int i;
for (i = 0; i < service_descriptors_length; i++) {
if(service_descriptors[i].startup) {
service_descriptors[i].service_func();
}
}
// At this point the system is fully running. Print a message
cli_uart_puts(timestamp());
cli_uart_puts("All startup services launched.\r\n");
while(true) {
// check for any task actions in the queue
if (xQueueReceive(taskman_queue, (void *)&tmi, 0) == pdTRUE) {
// perform the action. note that "START" is not implemented in task manager
// because an unregistered task does not have a TaskHandle yet (used
// in the taskman_item struct). This could be a future enhancement
switch (tmi.action)
{
case DELETE:
vTaskDelete(tmi.task);
break;
case SUSPEND:
vTaskSuspend(tmi.task);
break;
case RESUME:
vTaskResume(tmi.task);
break;
default:
break;
}
}
// update this task's schedule
task_sched_update(REPEAT_TASKMAN, DELAY_TASKMAN);
}
}
================================================
FILE: services/usb_service.c
================================================
/******************************************************************************
* @file usb_service.c
*
* @brief USB service implementation and FreeRTOS task creation.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include "hardware_config.h"
#include "rtos_utils.h"
#include "services.h"
#include "service_queues.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "tusb.h"
#include "string.h"
static void prvUsbTask(void *pvParameters); // usb task
TaskHandle_t xUsbTask;
// main service function, creates FreeRTOS task from prvUsbTask
BaseType_t usb_service(void)
{
BaseType_t xReturn;
// spawn the usb task
xReturn = xTaskCreate(
prvUsbTask,
xstr(SERVICE_NAME_USB),
STACK_USB,
NULL,
PRIORITY_USB,
&xUsbTask
);
// print timestamp value
cli_uart_puts(timestamp());
if (xReturn == pdPASS) {
cli_uart_puts("USB service started\r\n");
}
else {
cli_uart_puts("Error starting the USB service\r\n");
}
return xReturn;
}
// FreeRTOS task created by storman_service
static void prvUsbTask(void *pvParameters)
{
// USB device endpoint 0
struct usb_iface_t usb_iface_0 = {
.iface_id = 0,
.is_conn = false,
.rx_buffer = {},
.rx_pos = 0,
.tx_buffer = {},
.tx_pos = 0
};
while(true) {
// TinyUSB service function
tud_task();
// perform USB reads/writes and move data buffers to/from queue,
// only if not using CLI over USB. If using USB for CLI, run tud_task only
if (!CLI_USE_USB) {
// if connected, read/write any data available in buffers
if (tud_cdc_n_connected(usb_iface_0.iface_id)) {
usb_iface_0.is_conn = true;
usb_read_bytes(&usb_iface_0);
usb_write_bytes(&usb_iface_0);
}
else usb_iface_0.is_conn = false;
// check if there are RX bytes in the buffer and copy into the receive queue
if (usb_iface_0.rx_pos > 0) {
// add null termination to buffer if needed
if (usb_iface_0.rx_buffer[usb_iface_0.rx_pos - 1] != '\0') { // if it is a string there should already be NULL in pos-1
usb_iface_0.rx_buffer[usb_iface_0.rx_pos] = '\0'; // if not, add one
}
if (xQueueSend(usb0_rx_queue, &usb_iface_0.rx_buffer, 10) == pdTRUE) {
usb_iface_0.rx_pos = 0;
}
}
// check if there are any TX items in the queue and copy to the TX data buffer
if (usb_iface_0.tx_pos == 0) {
if (xQueueReceive(usb0_tx_queue, usb_iface_0.tx_buffer, 0) == pdTRUE) {
usb_iface_0.tx_pos = strlen(usb_iface_0.tx_buffer) + 1; // add 1 assuming null terminated byte array
}
}
}
// update this task's schedule
task_sched_update(REPEAT_USB, DELAY_USB);
}
}
================================================
FILE: services/watchdog_service.c
================================================
/******************************************************************************
* @file watchdog_service.c
*
* @brief watchdog service implementation and FreeRTOS task creation.
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#include "hardware_config.h"
#include "services.h"
#include "rtos_utils.h"
#include "FreeRTOS.h"
#include "task.h"
static void prvWatchdogTask(void *pvParameters);
TaskHandle_t xWatchdogTask;
// main service function, creates FreeRTOS task from prvWatchdogTask
BaseType_t watchdog_service(void)
{
BaseType_t xReturn;
// create the FreeRTOS task
xReturn = xTaskCreate(
prvWatchdogTask,
xstr(SERVICE_NAME_WATCHDOG),
STACK_WATCHDOG,
NULL,
PRIORITY_WATCHDOG,
&xWatchdogTask
);
// print timestamp value
cli_uart_puts(timestamp());
if (xReturn == pdPASS) {
cli_uart_puts("Watchdog service started\r\n");
}
else {
cli_uart_puts("Error starting the watchdog service\r\n");
}
return xReturn;
}
// FreeRTOS task created by watchdog_service
static void prvWatchdogTask(void *pvParameters)
{
// enable the watchdog timer
watchdog_en(WATCHDOG_DELAY_MS);
while(true) {
// reset watchdog timer
watchdog_kick();
// update this task's schedule
task_sched_update(REPEAT_WATCHDOG, DELAY_WATCHDOG);
}
}
================================================
FILE: version.h
================================================
/******************************************************************************
* @file version.h
*
* @brief contains the version number of the base BreadboardOS project
*
* @author Cavin McKinley (MCKNLY LLC)
*
* @date 02-14-2024
*
* @copyright Copyright (c) 2024 Cavin McKinley (MCKNLY LLC)
* Released under the MIT License
*
* SPDX-License-Identifier: MIT
******************************************************************************/
#ifndef VERSION_H
#define VERSION_H
// stringify helper - use xstr() to convert #define to a usable string
#define str(s) # s
#define xstr(s) str(s)
// maintain BreadboardOS version so it can be tracked along with custom project
#define BBOS_NAME "breadboard-os" // do not change
#define BBOS_VERSION_MAJOR 0 // changed only for major release update
#define BBOS_VERSION_MINOR 3 // changed only for minor release update
// global "modified version" variable will hold '+' if on a branch other than main
// this is checked and defined in the cli_service startup routine
extern char BBOS_VERSION_MOD;
// custom project name and version is defined in top level CMakeLists.txt
// look for PROJ_NAME and PROJ_VER
#endif /* VERSION_H */
Hackaday
Tom's Hardware
Adafruit
CNX Software
Electromaker
