new release
This commit is contained in:
@@ -1,14 +0,0 @@
|
||||
set(srcs
|
||||
"src/api.c"
|
||||
"src/ota.c"
|
||||
"src/json.c"
|
||||
"src/timeout_utils.c"
|
||||
"lib/cAT/src/cat.c")
|
||||
|
||||
idf_component_register(SRCS "${srcs}"
|
||||
INCLUDE_DIRS "include" "lib/cAT/src"
|
||||
PRIV_INCLUDE_DIRS "src"
|
||||
PRIV_REQUIRES nvs_flash app_update json driver esp_http_client esp_netif esp_wifi esp_timer esp_hw_support
|
||||
REQUIRES network config evse peripherals protocols ocpp auth)
|
||||
|
||||
set_source_files_properties(lib/cAT/src/cat.c PROPERTIES COMPILE_FLAGS -Wno-maybe-uninitialized)
|
||||
@@ -1,6 +0,0 @@
|
||||
#ifndef API_H_
|
||||
#define API_H_
|
||||
|
||||
void api_init(void);
|
||||
|
||||
#endif /* API_H_ */
|
||||
@@ -1,43 +0,0 @@
|
||||
#ifndef JSON_UTILS_H
|
||||
#define JSON_UTILS_H
|
||||
|
||||
#include "esp_err.h"
|
||||
#include "cJSON.h"
|
||||
|
||||
cJSON* json_get_evse_config(void);
|
||||
|
||||
esp_err_t json_set_evse_config(cJSON* root);
|
||||
|
||||
cJSON* json_get_wifi_config(void);
|
||||
|
||||
esp_err_t json_set_wifi_config(cJSON* root, bool timeout);
|
||||
|
||||
//JSON* json_get_wifi_scan(void);
|
||||
|
||||
cJSON* json_get_mqtt_config(void);
|
||||
|
||||
esp_err_t json_set_mqtt_config(cJSON* root);
|
||||
|
||||
//cJSON* json_get_serial_config(void);
|
||||
|
||||
//esp_err_t json_set_serial_config(cJSON* root);
|
||||
|
||||
cJSON* json_get_modbus_config(void);
|
||||
|
||||
esp_err_t json_set_modbus_config(cJSON* root);
|
||||
|
||||
//cJSON* json_get_script_config(void);
|
||||
|
||||
//esp_err_t json_set_script_config(cJSON* root);
|
||||
|
||||
cJSON* json_get_time_config(void);
|
||||
|
||||
esp_err_t json_set_time_config(cJSON* root);
|
||||
|
||||
cJSON* json_get_state(void);
|
||||
|
||||
cJSON* json_get_info(void);
|
||||
|
||||
cJSON* json_get_board_config(void);
|
||||
|
||||
#endif /* JSON_UTILS_H */
|
||||
@@ -1,15 +0,0 @@
|
||||
#ifndef OTA_H_
|
||||
#define OTA_H_
|
||||
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
#define OTA_VERSION_URL "https://dzurikmiroslav.github.io/esp32-evse/firmware/version.txt"
|
||||
|
||||
#define OTA_FIRMWARE_URL "https://dzurikmiroslav.github.io/esp32-evse/firmware/"
|
||||
|
||||
esp_err_t ota_get_available_version(char* version);
|
||||
|
||||
bool ota_is_newer_version(const char* actual, const char* available);
|
||||
|
||||
#endif /* OTA_H_ */
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef TIMEOUT_UTILS_H
|
||||
#define TIMEOUT_UTILS_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
/**
|
||||
* @brief Restart in 5 seconds
|
||||
*
|
||||
*/
|
||||
void timeout_restart(void);
|
||||
|
||||
/**
|
||||
* @brief Set WiFi config in 1 second
|
||||
*
|
||||
* @param enabled
|
||||
* @param ssid
|
||||
* @param password
|
||||
* @return esp_err_t
|
||||
*/
|
||||
esp_err_t timeout_wifi_set_config(bool enabled, const char* ssid, const char* password);
|
||||
|
||||
#endif /* TIMEOUT_UTILS_H */
|
||||
@@ -1,493 +0,0 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
#
|
||||
# clang-format configuration file. Intended for clang-format >= 4.
|
||||
#
|
||||
# For more information, see:
|
||||
#
|
||||
# Documentation/process/clang-format.rst
|
||||
# https://clang.llvm.org/docs/ClangFormat.html
|
||||
# https://clang.llvm.org/docs/ClangFormatStyleOptions.html
|
||||
#
|
||||
---
|
||||
AccessModifierOffset: -4
|
||||
AlignAfterOpenBracket: Align
|
||||
AlignConsecutiveAssignments: false
|
||||
AlignConsecutiveDeclarations: false
|
||||
#AlignEscapedNewlines: Left # Unknown to clang-format-4.0
|
||||
AlignOperands: true
|
||||
AlignTrailingComments: false
|
||||
AllowAllParametersOfDeclarationOnNextLine: false
|
||||
AllowShortBlocksOnASingleLine: false
|
||||
AllowShortCaseLabelsOnASingleLine: false
|
||||
AllowShortFunctionsOnASingleLine: None
|
||||
AllowShortIfStatementsOnASingleLine: false
|
||||
AllowShortLoopsOnASingleLine: false
|
||||
AlwaysBreakAfterDefinitionReturnType: None
|
||||
AlwaysBreakAfterReturnType: None
|
||||
AlwaysBreakBeforeMultilineStrings: false
|
||||
AlwaysBreakTemplateDeclarations: false
|
||||
BinPackArguments: true
|
||||
BinPackParameters: true
|
||||
BraceWrapping:
|
||||
AfterClass: false
|
||||
AfterControlStatement: false
|
||||
AfterEnum: false
|
||||
AfterFunction: true
|
||||
AfterNamespace: true
|
||||
AfterObjCDeclaration: false
|
||||
AfterStruct: false
|
||||
AfterUnion: false
|
||||
#AfterExternBlock: false # Unknown to clang-format-5.0
|
||||
BeforeCatch: false
|
||||
BeforeElse: false
|
||||
IndentBraces: false
|
||||
#SplitEmptyFunction: true # Unknown to clang-format-4.0
|
||||
#SplitEmptyRecord: true # Unknown to clang-format-4.0
|
||||
#SplitEmptyNamespace: true # Unknown to clang-format-4.0
|
||||
BreakBeforeBinaryOperators: None
|
||||
BreakBeforeBraces: Custom
|
||||
#BreakBeforeInheritanceComma: false # Unknown to clang-format-4.0
|
||||
BreakBeforeTernaryOperators: false
|
||||
BreakConstructorInitializersBeforeComma: false
|
||||
#BreakConstructorInitializers: BeforeComma # Unknown to clang-format-4.0
|
||||
BreakAfterJavaFieldAnnotations: false
|
||||
BreakStringLiterals: false
|
||||
ColumnLimit: 160
|
||||
CommentPragmas: '^ IWYU pragma:'
|
||||
#CompactNamespaces: false # Unknown to clang-format-4.0
|
||||
ConstructorInitializerAllOnOneLineOrOnePerLine: false
|
||||
ConstructorInitializerIndentWidth: 8
|
||||
ContinuationIndentWidth: 8
|
||||
Cpp11BracedListStyle: false
|
||||
DerivePointerAlignment: false
|
||||
DisableFormat: false
|
||||
ExperimentalAutoDetectBinPacking: false
|
||||
#FixNamespaceComments: false # Unknown to clang-format-4.0
|
||||
|
||||
# Taken from:
|
||||
# git grep -h '^#define [^[:space:]]*for_each[^[:space:]]*(' include/ \
|
||||
# | sed "s,^#define \([^[:space:]]*for_each[^[:space:]]*\)(.*$, - '\1'," \
|
||||
# | sort | uniq
|
||||
ForEachMacros:
|
||||
- 'apei_estatus_for_each_section'
|
||||
- 'ata_for_each_dev'
|
||||
- 'ata_for_each_link'
|
||||
- '__ata_qc_for_each'
|
||||
- 'ata_qc_for_each'
|
||||
- 'ata_qc_for_each_raw'
|
||||
- 'ata_qc_for_each_with_internal'
|
||||
- 'ax25_for_each'
|
||||
- 'ax25_uid_for_each'
|
||||
- '__bio_for_each_bvec'
|
||||
- 'bio_for_each_bvec'
|
||||
- 'bio_for_each_integrity_vec'
|
||||
- '__bio_for_each_segment'
|
||||
- 'bio_for_each_segment'
|
||||
- 'bio_for_each_segment_all'
|
||||
- 'bio_list_for_each'
|
||||
- 'bip_for_each_vec'
|
||||
- 'blkg_for_each_descendant_post'
|
||||
- 'blkg_for_each_descendant_pre'
|
||||
- 'blk_queue_for_each_rl'
|
||||
- 'bond_for_each_slave'
|
||||
- 'bond_for_each_slave_rcu'
|
||||
- 'bpf_for_each_spilled_reg'
|
||||
- 'btree_for_each_safe128'
|
||||
- 'btree_for_each_safe32'
|
||||
- 'btree_for_each_safe64'
|
||||
- 'btree_for_each_safel'
|
||||
- 'card_for_each_dev'
|
||||
- 'cgroup_taskset_for_each'
|
||||
- 'cgroup_taskset_for_each_leader'
|
||||
- 'cpufreq_for_each_entry'
|
||||
- 'cpufreq_for_each_entry_idx'
|
||||
- 'cpufreq_for_each_valid_entry'
|
||||
- 'cpufreq_for_each_valid_entry_idx'
|
||||
- 'css_for_each_child'
|
||||
- 'css_for_each_descendant_post'
|
||||
- 'css_for_each_descendant_pre'
|
||||
- 'device_for_each_child_node'
|
||||
- 'drm_atomic_crtc_for_each_plane'
|
||||
- 'drm_atomic_crtc_state_for_each_plane'
|
||||
- 'drm_atomic_crtc_state_for_each_plane_state'
|
||||
- 'drm_atomic_for_each_plane_damage'
|
||||
- 'drm_connector_for_each_possible_encoder'
|
||||
- 'drm_for_each_connector_iter'
|
||||
- 'drm_for_each_crtc'
|
||||
- 'drm_for_each_encoder'
|
||||
- 'drm_for_each_encoder_mask'
|
||||
- 'drm_for_each_fb'
|
||||
- 'drm_for_each_legacy_plane'
|
||||
- 'drm_for_each_plane'
|
||||
- 'drm_for_each_plane_mask'
|
||||
- 'drm_for_each_privobj'
|
||||
- 'drm_mm_for_each_hole'
|
||||
- 'drm_mm_for_each_node'
|
||||
- 'drm_mm_for_each_node_in_range'
|
||||
- 'drm_mm_for_each_node_safe'
|
||||
- 'flow_action_for_each'
|
||||
- 'for_each_active_drhd_unit'
|
||||
- 'for_each_active_iommu'
|
||||
- 'for_each_available_child_of_node'
|
||||
- 'for_each_bio'
|
||||
- 'for_each_board_func_rsrc'
|
||||
- 'for_each_bvec'
|
||||
- 'for_each_card_components'
|
||||
- 'for_each_card_links'
|
||||
- 'for_each_card_links_safe'
|
||||
- 'for_each_card_prelinks'
|
||||
- 'for_each_card_rtds'
|
||||
- 'for_each_card_rtds_safe'
|
||||
- 'for_each_cgroup_storage_type'
|
||||
- 'for_each_child_of_node'
|
||||
- 'for_each_clear_bit'
|
||||
- 'for_each_clear_bit_from'
|
||||
- 'for_each_cmsghdr'
|
||||
- 'for_each_compatible_node'
|
||||
- 'for_each_component_dais'
|
||||
- 'for_each_component_dais_safe'
|
||||
- 'for_each_comp_order'
|
||||
- 'for_each_console'
|
||||
- 'for_each_cpu'
|
||||
- 'for_each_cpu_and'
|
||||
- 'for_each_cpu_not'
|
||||
- 'for_each_cpu_wrap'
|
||||
- 'for_each_dev_addr'
|
||||
- 'for_each_dma_cap_mask'
|
||||
- 'for_each_dpcm_be'
|
||||
- 'for_each_dpcm_be_rollback'
|
||||
- 'for_each_dpcm_be_safe'
|
||||
- 'for_each_dpcm_fe'
|
||||
- 'for_each_drhd_unit'
|
||||
- 'for_each_dss_dev'
|
||||
- 'for_each_efi_memory_desc'
|
||||
- 'for_each_efi_memory_desc_in_map'
|
||||
- 'for_each_element'
|
||||
- 'for_each_element_extid'
|
||||
- 'for_each_element_id'
|
||||
- 'for_each_endpoint_of_node'
|
||||
- 'for_each_evictable_lru'
|
||||
- 'for_each_fib6_node_rt_rcu'
|
||||
- 'for_each_fib6_walker_rt'
|
||||
- 'for_each_free_mem_range'
|
||||
- 'for_each_free_mem_range_reverse'
|
||||
- 'for_each_func_rsrc'
|
||||
- 'for_each_hstate'
|
||||
- 'for_each_if'
|
||||
- 'for_each_iommu'
|
||||
- 'for_each_ip_tunnel_rcu'
|
||||
- 'for_each_irq_nr'
|
||||
- 'for_each_link_codecs'
|
||||
- 'for_each_lru'
|
||||
- 'for_each_matching_node'
|
||||
- 'for_each_matching_node_and_match'
|
||||
- 'for_each_memblock'
|
||||
- 'for_each_memblock_type'
|
||||
- 'for_each_memcg_cache_index'
|
||||
- 'for_each_mem_pfn_range'
|
||||
- 'for_each_mem_range'
|
||||
- 'for_each_mem_range_rev'
|
||||
- 'for_each_migratetype_order'
|
||||
- 'for_each_msi_entry'
|
||||
- 'for_each_msi_entry_safe'
|
||||
- 'for_each_net'
|
||||
- 'for_each_netdev'
|
||||
- 'for_each_netdev_continue'
|
||||
- 'for_each_netdev_continue_rcu'
|
||||
- 'for_each_netdev_feature'
|
||||
- 'for_each_netdev_in_bond_rcu'
|
||||
- 'for_each_netdev_rcu'
|
||||
- 'for_each_netdev_reverse'
|
||||
- 'for_each_netdev_safe'
|
||||
- 'for_each_net_rcu'
|
||||
- 'for_each_new_connector_in_state'
|
||||
- 'for_each_new_crtc_in_state'
|
||||
- 'for_each_new_mst_mgr_in_state'
|
||||
- 'for_each_new_plane_in_state'
|
||||
- 'for_each_new_private_obj_in_state'
|
||||
- 'for_each_node'
|
||||
- 'for_each_node_by_name'
|
||||
- 'for_each_node_by_type'
|
||||
- 'for_each_node_mask'
|
||||
- 'for_each_node_state'
|
||||
- 'for_each_node_with_cpus'
|
||||
- 'for_each_node_with_property'
|
||||
- 'for_each_of_allnodes'
|
||||
- 'for_each_of_allnodes_from'
|
||||
- 'for_each_of_cpu_node'
|
||||
- 'for_each_of_pci_range'
|
||||
- 'for_each_old_connector_in_state'
|
||||
- 'for_each_old_crtc_in_state'
|
||||
- 'for_each_old_mst_mgr_in_state'
|
||||
- 'for_each_oldnew_connector_in_state'
|
||||
- 'for_each_oldnew_crtc_in_state'
|
||||
- 'for_each_oldnew_mst_mgr_in_state'
|
||||
- 'for_each_oldnew_plane_in_state'
|
||||
- 'for_each_oldnew_plane_in_state_reverse'
|
||||
- 'for_each_oldnew_private_obj_in_state'
|
||||
- 'for_each_old_plane_in_state'
|
||||
- 'for_each_old_private_obj_in_state'
|
||||
- 'for_each_online_cpu'
|
||||
- 'for_each_online_node'
|
||||
- 'for_each_online_pgdat'
|
||||
- 'for_each_pci_bridge'
|
||||
- 'for_each_pci_dev'
|
||||
- 'for_each_pci_msi_entry'
|
||||
- 'for_each_populated_zone'
|
||||
- 'for_each_possible_cpu'
|
||||
- 'for_each_present_cpu'
|
||||
- 'for_each_prime_number'
|
||||
- 'for_each_prime_number_from'
|
||||
- 'for_each_process'
|
||||
- 'for_each_process_thread'
|
||||
- 'for_each_property_of_node'
|
||||
- 'for_each_registered_fb'
|
||||
- 'for_each_reserved_mem_region'
|
||||
- 'for_each_rtd_codec_dai'
|
||||
- 'for_each_rtd_codec_dai_rollback'
|
||||
- 'for_each_rtdcom'
|
||||
- 'for_each_rtdcom_safe'
|
||||
- 'for_each_set_bit'
|
||||
- 'for_each_set_bit_from'
|
||||
- 'for_each_sg'
|
||||
- 'for_each_sg_dma_page'
|
||||
- 'for_each_sg_page'
|
||||
- 'for_each_sibling_event'
|
||||
- 'for_each_subelement'
|
||||
- 'for_each_subelement_extid'
|
||||
- 'for_each_subelement_id'
|
||||
- '__for_each_thread'
|
||||
- 'for_each_thread'
|
||||
- 'for_each_zone'
|
||||
- 'for_each_zone_zonelist'
|
||||
- 'for_each_zone_zonelist_nodemask'
|
||||
- 'fwnode_for_each_available_child_node'
|
||||
- 'fwnode_for_each_child_node'
|
||||
- 'fwnode_graph_for_each_endpoint'
|
||||
- 'gadget_for_each_ep'
|
||||
- 'genradix_for_each'
|
||||
- 'genradix_for_each_from'
|
||||
- 'hash_for_each'
|
||||
- 'hash_for_each_possible'
|
||||
- 'hash_for_each_possible_rcu'
|
||||
- 'hash_for_each_possible_rcu_notrace'
|
||||
- 'hash_for_each_possible_safe'
|
||||
- 'hash_for_each_rcu'
|
||||
- 'hash_for_each_safe'
|
||||
- 'hctx_for_each_ctx'
|
||||
- 'hlist_bl_for_each_entry'
|
||||
- 'hlist_bl_for_each_entry_rcu'
|
||||
- 'hlist_bl_for_each_entry_safe'
|
||||
- 'hlist_for_each'
|
||||
- 'hlist_for_each_entry'
|
||||
- 'hlist_for_each_entry_continue'
|
||||
- 'hlist_for_each_entry_continue_rcu'
|
||||
- 'hlist_for_each_entry_continue_rcu_bh'
|
||||
- 'hlist_for_each_entry_from'
|
||||
- 'hlist_for_each_entry_from_rcu'
|
||||
- 'hlist_for_each_entry_rcu'
|
||||
- 'hlist_for_each_entry_rcu_bh'
|
||||
- 'hlist_for_each_entry_rcu_notrace'
|
||||
- 'hlist_for_each_entry_safe'
|
||||
- '__hlist_for_each_rcu'
|
||||
- 'hlist_for_each_safe'
|
||||
- 'hlist_nulls_for_each_entry'
|
||||
- 'hlist_nulls_for_each_entry_from'
|
||||
- 'hlist_nulls_for_each_entry_rcu'
|
||||
- 'hlist_nulls_for_each_entry_safe'
|
||||
- 'i3c_bus_for_each_i2cdev'
|
||||
- 'i3c_bus_for_each_i3cdev'
|
||||
- 'ide_host_for_each_port'
|
||||
- 'ide_port_for_each_dev'
|
||||
- 'ide_port_for_each_present_dev'
|
||||
- 'idr_for_each_entry'
|
||||
- 'idr_for_each_entry_continue'
|
||||
- 'idr_for_each_entry_ul'
|
||||
- 'inet_bind_bucket_for_each'
|
||||
- 'inet_lhash2_for_each_icsk_rcu'
|
||||
- 'key_for_each'
|
||||
- 'key_for_each_safe'
|
||||
- 'klp_for_each_func'
|
||||
- 'klp_for_each_func_safe'
|
||||
- 'klp_for_each_func_static'
|
||||
- 'klp_for_each_object'
|
||||
- 'klp_for_each_object_safe'
|
||||
- 'klp_for_each_object_static'
|
||||
- 'kvm_for_each_memslot'
|
||||
- 'kvm_for_each_vcpu'
|
||||
- 'list_for_each'
|
||||
- 'list_for_each_codec'
|
||||
- 'list_for_each_codec_safe'
|
||||
- 'list_for_each_entry'
|
||||
- 'list_for_each_entry_continue'
|
||||
- 'list_for_each_entry_continue_rcu'
|
||||
- 'list_for_each_entry_continue_reverse'
|
||||
- 'list_for_each_entry_from'
|
||||
- 'list_for_each_entry_from_rcu'
|
||||
- 'list_for_each_entry_from_reverse'
|
||||
- 'list_for_each_entry_lockless'
|
||||
- 'list_for_each_entry_rcu'
|
||||
- 'list_for_each_entry_reverse'
|
||||
- 'list_for_each_entry_safe'
|
||||
- 'list_for_each_entry_safe_continue'
|
||||
- 'list_for_each_entry_safe_from'
|
||||
- 'list_for_each_entry_safe_reverse'
|
||||
- 'list_for_each_prev'
|
||||
- 'list_for_each_prev_safe'
|
||||
- 'list_for_each_safe'
|
||||
- 'llist_for_each'
|
||||
- 'llist_for_each_entry'
|
||||
- 'llist_for_each_entry_safe'
|
||||
- 'llist_for_each_safe'
|
||||
- 'media_device_for_each_entity'
|
||||
- 'media_device_for_each_intf'
|
||||
- 'media_device_for_each_link'
|
||||
- 'media_device_for_each_pad'
|
||||
- 'mp_bvec_for_each_page'
|
||||
- 'mp_bvec_for_each_segment'
|
||||
- 'nanddev_io_for_each_page'
|
||||
- 'netdev_for_each_lower_dev'
|
||||
- 'netdev_for_each_lower_private'
|
||||
- 'netdev_for_each_lower_private_rcu'
|
||||
- 'netdev_for_each_mc_addr'
|
||||
- 'netdev_for_each_uc_addr'
|
||||
- 'netdev_for_each_upper_dev_rcu'
|
||||
- 'netdev_hw_addr_list_for_each'
|
||||
- 'nft_rule_for_each_expr'
|
||||
- 'nla_for_each_attr'
|
||||
- 'nla_for_each_nested'
|
||||
- 'nlmsg_for_each_attr'
|
||||
- 'nlmsg_for_each_msg'
|
||||
- 'nr_neigh_for_each'
|
||||
- 'nr_neigh_for_each_safe'
|
||||
- 'nr_node_for_each'
|
||||
- 'nr_node_for_each_safe'
|
||||
- 'of_for_each_phandle'
|
||||
- 'of_property_for_each_string'
|
||||
- 'of_property_for_each_u32'
|
||||
- 'pci_bus_for_each_resource'
|
||||
- 'ping_portaddr_for_each_entry'
|
||||
- 'plist_for_each'
|
||||
- 'plist_for_each_continue'
|
||||
- 'plist_for_each_entry'
|
||||
- 'plist_for_each_entry_continue'
|
||||
- 'plist_for_each_entry_safe'
|
||||
- 'plist_for_each_safe'
|
||||
- 'pnp_for_each_card'
|
||||
- 'pnp_for_each_dev'
|
||||
- 'protocol_for_each_card'
|
||||
- 'protocol_for_each_dev'
|
||||
- 'queue_for_each_hw_ctx'
|
||||
- 'radix_tree_for_each_slot'
|
||||
- 'radix_tree_for_each_tagged'
|
||||
- 'rbtree_postorder_for_each_entry_safe'
|
||||
- 'rdma_for_each_port'
|
||||
- 'resource_list_for_each_entry'
|
||||
- 'resource_list_for_each_entry_safe'
|
||||
- 'rhl_for_each_entry_rcu'
|
||||
- 'rhl_for_each_rcu'
|
||||
- 'rht_for_each'
|
||||
- 'rht_for_each_from'
|
||||
- 'rht_for_each_entry'
|
||||
- 'rht_for_each_entry_from'
|
||||
- 'rht_for_each_entry_rcu'
|
||||
- 'rht_for_each_entry_rcu_from'
|
||||
- 'rht_for_each_entry_safe'
|
||||
- 'rht_for_each_rcu'
|
||||
- 'rht_for_each_rcu_from'
|
||||
- '__rq_for_each_bio'
|
||||
- 'rq_for_each_bvec'
|
||||
- 'rq_for_each_segment'
|
||||
- 'scsi_for_each_prot_sg'
|
||||
- 'scsi_for_each_sg'
|
||||
- 'sctp_for_each_hentry'
|
||||
- 'sctp_skb_for_each'
|
||||
- 'shdma_for_each_chan'
|
||||
- '__shost_for_each_device'
|
||||
- 'shost_for_each_device'
|
||||
- 'sk_for_each'
|
||||
- 'sk_for_each_bound'
|
||||
- 'sk_for_each_entry_offset_rcu'
|
||||
- 'sk_for_each_from'
|
||||
- 'sk_for_each_rcu'
|
||||
- 'sk_for_each_safe'
|
||||
- 'sk_nulls_for_each'
|
||||
- 'sk_nulls_for_each_from'
|
||||
- 'sk_nulls_for_each_rcu'
|
||||
- 'snd_array_for_each'
|
||||
- 'snd_pcm_group_for_each_entry'
|
||||
- 'snd_soc_dapm_widget_for_each_path'
|
||||
- 'snd_soc_dapm_widget_for_each_path_safe'
|
||||
- 'snd_soc_dapm_widget_for_each_sink_path'
|
||||
- 'snd_soc_dapm_widget_for_each_source_path'
|
||||
- 'tb_property_for_each'
|
||||
- 'tcf_exts_for_each_action'
|
||||
- 'udp_portaddr_for_each_entry'
|
||||
- 'udp_portaddr_for_each_entry_rcu'
|
||||
- 'usb_hub_for_each_child'
|
||||
- 'v4l2_device_for_each_subdev'
|
||||
- 'v4l2_m2m_for_each_dst_buf'
|
||||
- 'v4l2_m2m_for_each_dst_buf_safe'
|
||||
- 'v4l2_m2m_for_each_src_buf'
|
||||
- 'v4l2_m2m_for_each_src_buf_safe'
|
||||
- 'virtio_device_for_each_vq'
|
||||
- 'xa_for_each'
|
||||
- 'xa_for_each_marked'
|
||||
- 'xa_for_each_start'
|
||||
- 'xas_for_each'
|
||||
- 'xas_for_each_conflict'
|
||||
- 'xas_for_each_marked'
|
||||
- 'zorro_for_each_dev'
|
||||
|
||||
#IncludeBlocks: Preserve # Unknown to clang-format-5.0
|
||||
IncludeCategories:
|
||||
- Regex: '.*'
|
||||
Priority: 1
|
||||
IncludeIsMainRegex: '(Test)?$'
|
||||
IndentCaseLabels: false
|
||||
#IndentPPDirectives: None # Unknown to clang-format-5.0
|
||||
IndentWidth: 8
|
||||
IndentWrappedFunctionNames: false
|
||||
JavaScriptQuotes: Leave
|
||||
JavaScriptWrapImports: true
|
||||
KeepEmptyLinesAtTheStartOfBlocks: false
|
||||
MacroBlockBegin: ''
|
||||
MacroBlockEnd: ''
|
||||
MaxEmptyLinesToKeep: 1
|
||||
NamespaceIndentation: Inner
|
||||
#ObjCBinPackProtocolList: Auto # Unknown to clang-format-5.0
|
||||
ObjCBlockIndentWidth: 8
|
||||
ObjCSpaceAfterProperty: true
|
||||
ObjCSpaceBeforeProtocolList: true
|
||||
|
||||
# Taken from git's rules
|
||||
#PenaltyBreakAssignment: 10 # Unknown to clang-format-4.0
|
||||
PenaltyBreakBeforeFirstCallParameter: 30
|
||||
PenaltyBreakComment: 10
|
||||
PenaltyBreakFirstLessLess: 0
|
||||
PenaltyBreakString: 10
|
||||
PenaltyExcessCharacter: 100
|
||||
PenaltyReturnTypeOnItsOwnLine: 60
|
||||
|
||||
PointerAlignment: Right
|
||||
ReflowComments: false
|
||||
SortIncludes: false
|
||||
#SortUsingDeclarations: false # Unknown to clang-format-4.0
|
||||
SpaceAfterCStyleCast: false
|
||||
SpaceAfterTemplateKeyword: true
|
||||
SpaceBeforeAssignmentOperators: true
|
||||
#SpaceBeforeCtorInitializerColon: true # Unknown to clang-format-5.0
|
||||
#SpaceBeforeInheritanceColon: true # Unknown to clang-format-5.0
|
||||
SpaceBeforeParens: ControlStatements
|
||||
#SpaceBeforeRangeBasedForLoopColon: true # Unknown to clang-format-5.0
|
||||
SpaceInEmptyParentheses: false
|
||||
SpacesBeforeTrailingComments: 1
|
||||
SpacesInAngles: false
|
||||
SpacesInContainerLiterals: false
|
||||
SpacesInCStyleCastParentheses: false
|
||||
SpacesInParentheses: false
|
||||
SpacesInSquareBrackets: false
|
||||
Standard: Cpp03
|
||||
TabWidth: 8
|
||||
UseTab: Never
|
||||
...
|
||||
17
components/api/lib/cAT/.gitignore
vendored
17
components/api/lib/cAT/.gitignore
vendored
@@ -1,17 +0,0 @@
|
||||
.vscode
|
||||
lib
|
||||
bin
|
||||
dist
|
||||
build
|
||||
CMakeLists.txt.user
|
||||
CMakeCache.txt
|
||||
CMakeFiles
|
||||
CMakeScripts
|
||||
Testing
|
||||
Makefile
|
||||
cmake_install.cmake
|
||||
install_manifest.txt
|
||||
compile_commands.json
|
||||
CTestTestfile.cmake
|
||||
_deps
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
language: c
|
||||
|
||||
compiler:
|
||||
- gcc
|
||||
|
||||
before_script:
|
||||
- mkdir build
|
||||
- cd build
|
||||
- cmake ..
|
||||
|
||||
script: make && make test
|
||||
@@ -1,148 +0,0 @@
|
||||
cmake_minimum_required( VERSION 3.0 )
|
||||
|
||||
project( libcat LANGUAGES C )
|
||||
|
||||
set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib )
|
||||
set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib )
|
||||
set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )
|
||||
|
||||
enable_testing( )
|
||||
|
||||
include_directories( ${PROJECT_SOURCE_DIR}/src )
|
||||
|
||||
file( GLOB SRC_FILES src/*.c )
|
||||
add_library( cat SHARED ${SRC_FILES} )
|
||||
set_target_properties( cat PROPERTIES VERSION 0.11.1 SOVERSION 1 )
|
||||
target_compile_options( cat PRIVATE -Werror -Wall -Wextra -pedantic )
|
||||
|
||||
install( TARGETS cat DESTINATION lib )
|
||||
install( FILES src/cat.h DESTINATION include/cat )
|
||||
|
||||
add_executable( demo example/demo.c )
|
||||
target_link_libraries( demo cat )
|
||||
|
||||
add_executable( basic example/basic.c )
|
||||
target_link_libraries( basic cat )
|
||||
|
||||
add_executable( unsolicited example/unsolicited.c )
|
||||
target_link_libraries( unsolicited cat )
|
||||
|
||||
add_executable( test_parse tests/test_parse.c )
|
||||
target_link_libraries( test_parse cat )
|
||||
add_test( test_parse ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_parse )
|
||||
|
||||
add_executable( test_run tests/test_run.c )
|
||||
target_link_libraries( test_run cat )
|
||||
add_test( test_run ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_run )
|
||||
|
||||
add_executable( test_read tests/test_read.c )
|
||||
target_link_libraries( test_read cat )
|
||||
add_test( test_read ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_read )
|
||||
|
||||
add_executable( test_write tests/test_write.c )
|
||||
target_link_libraries( test_write cat )
|
||||
add_test( test_write ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_write )
|
||||
|
||||
add_executable( test_write_parse tests/test_write_parse.c )
|
||||
target_link_libraries( test_write_parse cat )
|
||||
add_test( test_write_parse ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_write_parse )
|
||||
|
||||
add_executable( test_write_int_range tests/test_write_int_range.c )
|
||||
target_link_libraries( test_write_int_range cat )
|
||||
add_test( test_write_int_range ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_write_int_range )
|
||||
|
||||
add_executable( test_write_uint_range tests/test_write_uint_range.c )
|
||||
target_link_libraries( test_write_uint_range cat )
|
||||
add_test( test_write_uint_range ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_write_uint_range )
|
||||
|
||||
add_executable( test_write_hex_range tests/test_write_hex_range.c )
|
||||
target_link_libraries( test_write_hex_range cat )
|
||||
add_test( test_write_hex_range ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_write_hex_range )
|
||||
|
||||
add_executable( test_write_hex_buffer tests/test_write_hex_buffer.c )
|
||||
target_link_libraries( test_write_hex_buffer cat )
|
||||
add_test( test_write_hex_buffer ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_write_hex_buffer )
|
||||
|
||||
add_executable( test_write_string_buffer tests/test_write_string_buffer.c )
|
||||
target_link_libraries( test_write_string_buffer cat )
|
||||
add_test( test_write_string_buffer ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_write_string_buffer )
|
||||
|
||||
add_executable( test_read_args tests/test_read_args.c )
|
||||
target_link_libraries( test_read_args cat )
|
||||
add_test( test_read_args ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_read_args )
|
||||
|
||||
add_executable( test_test tests/test_test.c )
|
||||
target_link_libraries( test_test cat )
|
||||
add_test( test_test ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_test )
|
||||
|
||||
add_executable( test_test_args tests/test_test_args.c )
|
||||
target_link_libraries( test_test_args cat )
|
||||
add_test( test_test_args ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_test_args )
|
||||
|
||||
add_executable( test_mutex tests/test_mutex.c )
|
||||
target_link_libraries( test_mutex cat )
|
||||
add_test( test_mutex ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_mutex )
|
||||
|
||||
add_executable( test_unsolicited_read tests/test_unsolicited_read.c )
|
||||
target_link_libraries( test_unsolicited_read cat )
|
||||
add_test( test_unsolicited_read ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_unsolicited_read )
|
||||
|
||||
add_executable( test_unsolicited_read_stress tests/test_unsolicited_read_stress.c )
|
||||
target_link_libraries( test_unsolicited_read_stress cat )
|
||||
add_test( test_unsolicited_read_stress ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_unsolicited_read_stress )
|
||||
|
||||
add_executable( test_unsolicited_read_buffer tests/test_unsolicited_read_buffer.c ${SRC_FILES})
|
||||
set_target_properties( test_unsolicited_read_buffer PROPERTIES COMPILE_DEFINITIONS "CAT_UNSOLICITED_CMD_BUFFER_SIZE=2" )
|
||||
add_test( test_unsolicited_read_buffer ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_unsolicited_read_buffer )
|
||||
|
||||
add_executable( test_hold_state tests/test_hold_state.c )
|
||||
target_link_libraries( test_hold_state cat )
|
||||
add_test( test_hold_state ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_hold_state )
|
||||
|
||||
add_executable( test_return_read tests/test_return_read.c )
|
||||
target_link_libraries( test_return_read cat )
|
||||
add_test( test_return_read ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_return_read )
|
||||
|
||||
add_executable( test_return_write tests/test_return_write.c )
|
||||
target_link_libraries( test_return_write cat )
|
||||
add_test( test_return_write ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_return_write )
|
||||
|
||||
add_executable( test_unsolicited_test tests/test_unsolicited_test.c )
|
||||
target_link_libraries( test_unsolicited_test cat )
|
||||
add_test( test_unsolicited_test ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_unsolicited_test )
|
||||
|
||||
add_executable( test_return_test tests/test_return_test.c )
|
||||
target_link_libraries( test_return_test cat )
|
||||
add_test( test_return_test ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_return_test )
|
||||
|
||||
add_executable( test_return_run tests/test_return_run.c )
|
||||
target_link_libraries( test_return_run cat )
|
||||
add_test( test_return_run ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_return_run )
|
||||
|
||||
add_executable( test_test_only tests/test_test_only.c )
|
||||
target_link_libraries( test_test_only cat )
|
||||
add_test( test_test_only ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_test_only )
|
||||
|
||||
add_executable( test_search_cmd tests/test_search_cmd.c )
|
||||
target_link_libraries( test_search_cmd cat )
|
||||
add_test( test_search_cmd ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_search_cmd )
|
||||
|
||||
add_executable( test_order tests/test_order.c )
|
||||
target_link_libraries( test_order cat )
|
||||
add_test( test_order ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_order )
|
||||
|
||||
add_executable( test_cmd_list tests/test_cmd_list.c )
|
||||
target_link_libraries( test_cmd_list cat )
|
||||
add_test( test_cmd_list ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_cmd_list )
|
||||
|
||||
add_executable( test_var_access tests/test_var_access.c )
|
||||
target_link_libraries( test_var_access cat )
|
||||
add_test( test_var_access ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_var_access )
|
||||
|
||||
add_executable( test_shortcuts tests/test_shortcuts.c )
|
||||
target_link_libraries( test_shortcuts cat )
|
||||
add_test( test_shortcuts ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_shortcuts )
|
||||
|
||||
add_custom_target( check COMMAND ${CMAKE_CTEST_COMMAND} --verbose )
|
||||
add_custom_target( cleanall COMMAND rm -rf Makefile CMakeCache.txt CMakeFiles/ bin/ lib/ cmake_install.cmake CTestTestfile.cmake Testing/ )
|
||||
add_custom_target( uninstall COMMAND xargs rm < install_manifest.txt )
|
||||
@@ -1,21 +0,0 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
@@ -1,211 +0,0 @@
|
||||
[](https://travis-ci.org/marcinbor85/cat)
|
||||
# libcat (cAT)
|
||||
Plain C library for parsing AT commands for use in host devices.
|
||||
|
||||
## Features
|
||||
* blazing fast, non-blocking, robust implementation
|
||||
* 100% static implementation (without any dynamic memory allocation)
|
||||
* very small footprint (both RAM and ROM)
|
||||
* support for READ, WRITE, TEST and RUN type commands
|
||||
* commands shortcuts (auto select best command candidate)
|
||||
* single request - multiple responses
|
||||
* unsolicited read/test command support
|
||||
* hold state for delayed responses for time-consuming tasks
|
||||
* high-level memory variables mapping arguments parsing
|
||||
* variables accessors (read and write, read only, write only)
|
||||
* automatic arguments types validating
|
||||
* automatic format test responses for commands with variables
|
||||
* CRLF and LF compatible
|
||||
* case-insensitive
|
||||
* dedicated for embedded systems
|
||||
* object-oriented architecture
|
||||
* separated interface for low-level layer
|
||||
* fully asynchronous input/output operations
|
||||
* multiplatform and portable
|
||||
* asynchronous api with event callbacks
|
||||
* print registered commands list feature
|
||||
* only two source files
|
||||
* wide unit tests
|
||||
|
||||
## Build
|
||||
|
||||
Build and install:
|
||||
|
||||
```sh
|
||||
cmake .
|
||||
make
|
||||
make test
|
||||
sudo make install
|
||||
```
|
||||
|
||||
## Example basic demo posibilities
|
||||
|
||||
```console
|
||||
AT+PRINT=? # TEST command
|
||||
+PRINT=<X:UINT8[RW]>,<Y:UINT8[RW]>,<MESSAGE:STRING[RW]> # Automatic response
|
||||
Printing something special at (X,Y). # Automatic response
|
||||
OK # Automatic acknowledge
|
||||
|
||||
AT+PRINT? # READ command
|
||||
+PRINT=0,0,"" # Automatic response
|
||||
OK # Automatic acknowledge
|
||||
|
||||
AT+PRINT=xyz,-2 # WRITE command
|
||||
ERROR # Automatic acknowledge
|
||||
|
||||
AT+PRINT=1,2,"test" # WRITE command
|
||||
OK # Automatic acknowledge
|
||||
|
||||
AT+PRINT # RUN command
|
||||
some printing at (1,2) with text "test" # Manual response
|
||||
OK # Automatic acknowledge
|
||||
```
|
||||
|
||||
## Example unsolicited demo posibilities
|
||||
|
||||
```console
|
||||
AT+START=? # TEST command
|
||||
+START=<MODE:UINT32[WO]> # Automatic response
|
||||
Start scanning after write (0 - wifi, 1 - bluetooth). # Automatic response
|
||||
OK # Automatic acknowledge
|
||||
|
||||
AT+START=0 # WRITE command
|
||||
+SCAN=-10,"wifi1" # Unsolicited read response
|
||||
+SCAN=-50,"wifi2" # Unsolicited read response
|
||||
+SCAN=-20,"wifi3" # Unsolicited read response
|
||||
OK # Unsolicited acknowledge
|
||||
|
||||
AT+START=1 # WRITE command
|
||||
+SCAN=-20,"bluetooth1" # Unsolicited read response
|
||||
OK # Unsolicited acknowledge
|
||||
|
||||
AT+SCAN=? # TEST command
|
||||
+SCAN=<RSSI:INT32[RO]>,<SSID:STRING[RO]> # Automatic response
|
||||
Scan result record. # Automatic response
|
||||
OK # Automatic acknowledge
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
Define High-Level variables:
|
||||
|
||||
```c
|
||||
|
||||
static uint8_t x;
|
||||
static uint8_t y;
|
||||
static char msg[32];
|
||||
|
||||
static struct cat_variable go_vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC, /* unsigned int variable */
|
||||
.data = &x,
|
||||
.data_size = sizeof(x),
|
||||
.write = x_write,
|
||||
.name = "X",
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE,
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC, /* unsigned int variable */
|
||||
.data = &y,
|
||||
.data_size = sizeof(y),
|
||||
.write = y_write,
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE,
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING, /* string variable */
|
||||
.data = msg,
|
||||
.data_size = sizeof(msg),
|
||||
.write = msg_write,
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE,
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
Define AT commands descriptor:
|
||||
|
||||
```c
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "TEST",
|
||||
.read = test_read, /* read handler for ATTEST? command */
|
||||
.write = test_write, /* write handler for ATTEST={val} command */
|
||||
.run = test_run /* run handler for ATTEST command */
|
||||
},
|
||||
{
|
||||
.name = "+NUM",
|
||||
.write = num_write, /* write handler for AT+NUM={val} command */
|
||||
.read = num_read /* read handler for AT+NUM? command */
|
||||
},
|
||||
{
|
||||
.name = "+GO",
|
||||
.write = go_write, /* write handler for AT+GO={x},{y},{msg} command */
|
||||
.var = go_vars, /* attach variables to command */
|
||||
.var_num = sizeof(go_vars) / sizeof(go_vars[0]),
|
||||
.need_all_vars = true
|
||||
},
|
||||
{
|
||||
.name = "RESTART",
|
||||
.run = restart_run /* run handler for ATRESTART command */
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
Define AT command parser descriptor:
|
||||
|
||||
```c
|
||||
|
||||
static char working_buf[128]; /* working buffer, must be declared manually */
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = working_buf,
|
||||
.buf_size = sizeof(working_buf),
|
||||
};
|
||||
```
|
||||
|
||||
Define IO low-level layer interface:
|
||||
|
||||
```c
|
||||
static int write_char(char ch)
|
||||
{
|
||||
putc(ch, stdout);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
*ch = getch();
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
```
|
||||
|
||||
Initialize AT command parser and run:
|
||||
|
||||
```c
|
||||
struct cat_object at; /* at command parser object */
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL); /* initialize at command parser object */
|
||||
|
||||
while (1) {
|
||||
cat_service(&at) /* periodically call at command parser service */
|
||||
|
||||
... /* other stuff, running in main loop */
|
||||
}
|
||||
|
||||
```
|
||||
@@ -1,70 +0,0 @@
|
||||
TODO:
|
||||
- differentation of variables for read and write commands
|
||||
- help command (printing all commands posibilities with descriptions)
|
||||
- documentation updated (buffer sized, return enum types, write variable nums, buf size hints)
|
||||
- helper setters and getters for variables
|
||||
|
||||
0.11.0
|
||||
* optional context in commands and data_getter in variables
|
||||
* optional extended read and write variable handler with parent command
|
||||
|
||||
0.10.1
|
||||
* single working buffer insteads of two separated for atcmd and unsolicited events
|
||||
|
||||
0.10.0
|
||||
* separate atcmd and unsolicited event state machines
|
||||
|
||||
0.9.0
|
||||
* variables accessors
|
||||
|
||||
0.8.1
|
||||
* fix commands shourtcuts
|
||||
|
||||
0.8.0
|
||||
* print commands list feature
|
||||
|
||||
0.7.1
|
||||
* more flexible command group initialization (pointers)
|
||||
|
||||
0.7.0
|
||||
* function for checking unsolicited buffer
|
||||
* some refactoring regarding unsolicited buffer
|
||||
* helper function cat_search_variable_by_name added
|
||||
* commands group with searching feature added
|
||||
* disable feature for commands and groups added
|
||||
|
||||
0.6.0
|
||||
* async non blocking io->write
|
||||
* async unsolicited read/test event (injected at idle and hold state)
|
||||
* hold commands parse processing feature (for delayed unsolicited read responses)
|
||||
* behavior differentation by callbacks return values
|
||||
* only-test flag in commands descriptor (for fast disable read/write/run)
|
||||
* helper function for searching command by name
|
||||
* multiple responses triggered by single request pattern support
|
||||
* generic mutex descriptor interface
|
||||
* return value states enum types
|
||||
|
||||
0.5.3
|
||||
* function for checking internal busy state added
|
||||
|
||||
0.5.2
|
||||
* small fix in auto description response
|
||||
|
||||
0.5.1
|
||||
* description field in command added (used in auto help message)
|
||||
|
||||
0.5.0
|
||||
* test command parser with auto help messages
|
||||
* output string end-line encoding same as input string
|
||||
* very basic demo example application added
|
||||
|
||||
0.4.0
|
||||
* high level parsing for command arguments
|
||||
* int, uint, hex, hexbuf, string argument types
|
||||
* validating arguments values range
|
||||
|
||||
0.3.0
|
||||
* independent buffers (parsing buffer and state buffer)
|
||||
|
||||
0.2.0
|
||||
* passing command struct instead of command name in command handlers
|
||||
@@ -1,161 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
/* variables assigned to print command */
|
||||
static uint8_t x;
|
||||
static uint8_t y;
|
||||
static char message[16];
|
||||
|
||||
/* helper variable used to exit demo code */
|
||||
static bool quit_flag;
|
||||
|
||||
/* run command handler with application dependent login print code */
|
||||
static int print_run(const struct cat_command *cmd)
|
||||
{
|
||||
printf("some printing at (%d,%d) with text \"%s\"\n", x, y, message);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* run command handler attached to HELP command for printing commands list */
|
||||
static int print_cmd_list(const struct cat_command *cmd)
|
||||
{
|
||||
return CAT_RETURN_STATE_PRINT_CMD_LIST_OK;
|
||||
}
|
||||
|
||||
/* run command handler with custom exit mechanism */
|
||||
static int quit_run(const struct cat_command *cmd)
|
||||
{
|
||||
quit_flag = true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* declaring print variables array */
|
||||
static struct cat_variable print_vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &x,
|
||||
.data_size = sizeof(x),
|
||||
.name = "X",
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE,
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &y,
|
||||
.data_size = sizeof(y),
|
||||
.name = "Y",
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE,
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = message,
|
||||
.data_size = sizeof(message),
|
||||
.name = "MESSAGE",
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE,
|
||||
}
|
||||
};
|
||||
|
||||
/* declaring commands array */
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+PRINT",
|
||||
.description = "Printing something special at (X,Y).",
|
||||
.run = print_run,
|
||||
.var = print_vars,
|
||||
.var_num = sizeof(print_vars) / sizeof(print_vars[0]),
|
||||
.need_all_vars = true
|
||||
},
|
||||
{
|
||||
.name = "#HELP",
|
||||
.run = print_cmd_list,
|
||||
},
|
||||
{
|
||||
.name = "#QUIT",
|
||||
.run = quit_run
|
||||
},
|
||||
};
|
||||
|
||||
/* working buffer */
|
||||
static char buf[128];
|
||||
|
||||
/* declaring parser descriptor */
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
/* custom target dependent input output handlers */
|
||||
static int write_char(char ch)
|
||||
{
|
||||
putc(ch, stdout);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
*ch = getc(stdin);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* declaring input output interface descriptor for parser */
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
/* initializing */
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
/* main loop with exit code conditions */
|
||||
while ((cat_service(&at) != 0) && (quit_flag == 0)) {};
|
||||
|
||||
/* goodbye message */
|
||||
printf("Bye!\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,260 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static int32_t speed;
|
||||
static uint16_t adr;
|
||||
static uint8_t x;
|
||||
static uint8_t y;
|
||||
static uint8_t bytes_buf[4];
|
||||
static char msg[16];
|
||||
static bool quit_flag;
|
||||
|
||||
static int x_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
printf("x variable updated internally to: %u\n", x);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int y_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
printf("y variable updated internally to: %u\n", y);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int msg_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
printf("msg variable updated %lu bytes internally to: <%s>\n", write_size, msg);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int speed_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
printf("speed variable updated internally to: %d\n", speed);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int adr_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
printf("adr variable updated internally to: 0x%04X\n", adr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bytesbuf_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
printf("bytes_buf variable updated %lu bytes internally to: ", write_size);
|
||||
for (i = 0; i < sizeof(bytes_buf); i++)
|
||||
printf("%02X", bytes_buf[i]);
|
||||
printf("\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int go_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
printf("<%s>: x=%d y=%d msg=%s @ speed=%d\n",
|
||||
cmd->name,
|
||||
*(uint8_t*)(cmd->var[0].data),
|
||||
*(uint8_t*)(cmd->var[1].data),
|
||||
msg,
|
||||
speed
|
||||
);
|
||||
|
||||
printf("<bytes>: ");
|
||||
for (i = 0; i < sizeof(bytes_buf); i++)
|
||||
printf("%02X", bytes_buf[i]);
|
||||
printf("\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int set_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
printf("<%s>: SET SPEED TO = %d\n",
|
||||
cmd->name,
|
||||
speed
|
||||
);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int set_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_run(const struct cat_command *cmd)
|
||||
{
|
||||
printf("TEST: <%s>", cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int quit_run(const struct cat_command *cmd)
|
||||
{
|
||||
printf("QUIT: <%s>", cmd->name);
|
||||
quit_flag = true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int print_cmd_list(const struct cat_command *cmd)
|
||||
{
|
||||
return CAT_RETURN_STATE_PRINT_CMD_LIST_OK;
|
||||
}
|
||||
|
||||
static struct cat_variable go_vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &x,
|
||||
.data_size = sizeof(x),
|
||||
.write = x_write,
|
||||
.name = "x"
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &y,
|
||||
.data_size = sizeof(y),
|
||||
.write = y_write,
|
||||
.name = "y"
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = msg,
|
||||
.data_size = sizeof(msg),
|
||||
.write = msg_write,
|
||||
.name = "msg"
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable set_vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &speed,
|
||||
.data_size = sizeof(speed),
|
||||
.write = speed_write,
|
||||
.name = "speed"
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &adr,
|
||||
.data_size = sizeof(adr),
|
||||
.write = adr_write,
|
||||
.name = "address"
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_HEX,
|
||||
.data = &bytes_buf,
|
||||
.data_size = sizeof(bytes_buf),
|
||||
.write = bytesbuf_write,
|
||||
.name = "buffer"
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+GO",
|
||||
.write = go_write,
|
||||
.var = go_vars,
|
||||
.var_num = sizeof(go_vars) / sizeof(go_vars[0]),
|
||||
.need_all_vars = true
|
||||
},
|
||||
{
|
||||
.name = "+SET",
|
||||
.write = set_write,
|
||||
.read = set_read,
|
||||
.var = set_vars,
|
||||
.var_num = sizeof(set_vars) / sizeof(set_vars[0]),
|
||||
},
|
||||
{
|
||||
.name = "#TEST",
|
||||
.run = test_run
|
||||
},
|
||||
{
|
||||
.name = "#HELP",
|
||||
.run = print_cmd_list,
|
||||
},
|
||||
{
|
||||
.name = "#QUIT",
|
||||
.run = quit_run
|
||||
},
|
||||
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
putc(ch, stdout);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
*ch = getc(stdin);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
while ((cat_service(&at) != 0) && (quit_flag == 0)) {};
|
||||
|
||||
printf("Bye!\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,251 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
/* variables assigned to scan command */
|
||||
static int rssi;
|
||||
static char ssid[16];
|
||||
|
||||
/* helper variable used to exit demo code */
|
||||
static bool quit_flag;
|
||||
|
||||
/* variables assigned to start command */
|
||||
static int mode;
|
||||
|
||||
/* main at command parser object */
|
||||
struct cat_object at;
|
||||
|
||||
struct scan_results {
|
||||
int rssi;
|
||||
char ssid[16];
|
||||
};
|
||||
|
||||
/* static const scan results */
|
||||
static const struct scan_results results[2][3] = {
|
||||
{
|
||||
{
|
||||
.rssi = -10,
|
||||
.ssid = "wifi1",
|
||||
},
|
||||
{
|
||||
.rssi = -50,
|
||||
.ssid = "wifi2",
|
||||
},
|
||||
{
|
||||
.rssi = -20,
|
||||
.ssid = "wifi3",
|
||||
}
|
||||
},
|
||||
{
|
||||
{
|
||||
.rssi = -20,
|
||||
.ssid = "bluetooth1",
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/* helper variable */
|
||||
static int scan_index;
|
||||
|
||||
/* run command handler with custom exit mechanism */
|
||||
static int quit_run(const struct cat_command *cmd)
|
||||
{
|
||||
quit_flag = true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* helper function */
|
||||
static void load_scan_results(int index)
|
||||
{
|
||||
rssi = results[mode][index].rssi;
|
||||
strcpy(ssid, results[mode][index].ssid);
|
||||
}
|
||||
|
||||
/* declaring scan variables array */
|
||||
static struct cat_variable scan_vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &rssi,
|
||||
.data_size = sizeof(rssi),
|
||||
.name = "RSSI"
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = ssid,
|
||||
.data_size = sizeof(ssid),
|
||||
.name = "SSID"
|
||||
}
|
||||
};
|
||||
|
||||
/* forward declaration */
|
||||
static cat_return_state scan_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size);
|
||||
|
||||
/* unsolicited command */
|
||||
static struct cat_command scan_cmd = {
|
||||
.name = "+SCAN",
|
||||
.read = scan_read,
|
||||
.var = scan_vars,
|
||||
.var_num = sizeof(scan_vars) / sizeof(scan_vars[0])
|
||||
};
|
||||
|
||||
/* unsolicited read callback handler */
|
||||
static cat_return_state scan_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
int max = (mode == 0) ? 3 : 1;
|
||||
|
||||
scan_index++;
|
||||
if (scan_index > max)
|
||||
return CAT_RETURN_STATE_HOLD_EXIT_OK;
|
||||
|
||||
load_scan_results(scan_index);
|
||||
cat_trigger_unsolicited_read(&at, &scan_cmd);
|
||||
|
||||
return CAT_RETURN_STATE_DATA_NEXT;
|
||||
}
|
||||
|
||||
/* mode variable validator */
|
||||
static int mode_write(const struct cat_variable *var, const size_t write_size)
|
||||
{
|
||||
if (*(int*)var->data >= 2)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* start write callback handler */
|
||||
static cat_return_state start_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
scan_index = 0;
|
||||
|
||||
load_scan_results(scan_index);
|
||||
cat_trigger_unsolicited_read(&at, &scan_cmd);
|
||||
|
||||
return CAT_RETURN_STATE_HOLD;
|
||||
}
|
||||
|
||||
/* run command handler attached to HELP command for printing commands list */
|
||||
static int print_cmd_list(const struct cat_command *cmd)
|
||||
{
|
||||
return CAT_RETURN_STATE_PRINT_CMD_LIST_OK;
|
||||
}
|
||||
|
||||
/* declaring start command variables array */
|
||||
static struct cat_variable start_vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &mode,
|
||||
.data_size = sizeof(mode),
|
||||
.name = "MODE",
|
||||
.write = mode_write,
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY,
|
||||
}
|
||||
};
|
||||
|
||||
/* declaring commands array */
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+START",
|
||||
.description = "Start scanning after write (0 - wifi, 1 - bluetooth).",
|
||||
.write = start_write,
|
||||
.var = start_vars,
|
||||
.var_num = sizeof(start_vars) / sizeof(start_vars[0]),
|
||||
.need_all_vars = true
|
||||
},
|
||||
{
|
||||
.name = "+SCAN",
|
||||
.description = "Scan result record.",
|
||||
.only_test = true,
|
||||
.var = scan_vars,
|
||||
.var_num = sizeof(scan_vars) / sizeof(scan_vars[0])
|
||||
},
|
||||
{
|
||||
.name = "#HELP",
|
||||
.run = print_cmd_list,
|
||||
},
|
||||
{
|
||||
.name = "#QUIT",
|
||||
.run = quit_run
|
||||
},
|
||||
};
|
||||
|
||||
/* working buffer */
|
||||
static char buf[128];
|
||||
|
||||
/* declaring parser descriptor */
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
/* custom target dependent input output handlers */
|
||||
static int write_char(char ch)
|
||||
{
|
||||
putc(ch, stdout);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
*ch = getc(stdin);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* declaring input output interface descriptor for parser */
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
/* initializing */
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
/* main loop with exit code conditions */
|
||||
while ((cat_service(&at) != 0) && (quit_flag == 0)) {};
|
||||
|
||||
/* goodbye message */
|
||||
printf("Bye!\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,557 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#ifndef CAT_H
|
||||
#define CAT_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
/* only forward declarations (looks for definition below) */
|
||||
struct cat_command;
|
||||
struct cat_variable;
|
||||
|
||||
#ifndef CAT_UNSOLICITED_CMD_BUFFER_SIZE
|
||||
/* unsolicited command buffer default size (can by override externally during compilation) */
|
||||
#define CAT_UNSOLICITED_CMD_BUFFER_SIZE ((size_t)(1))
|
||||
#endif
|
||||
|
||||
/* enum type with variable type definitions */
|
||||
typedef enum {
|
||||
CAT_VAR_INT_DEC = 0, /* decimal encoded signed integer variable */
|
||||
CAT_VAR_UINT_DEC, /* decimal encoded unsigned integer variable */
|
||||
CAT_VAR_NUM_HEX, /* hexadecimal encoded unsigned integer variable */
|
||||
CAT_VAR_BUF_HEX, /* asciihex encoded bytes array */
|
||||
CAT_VAR_BUF_STRING /* string variable */
|
||||
} cat_var_type;
|
||||
|
||||
/* enum type wirh variable accessors definitions */
|
||||
typedef enum {
|
||||
CAT_VAR_ACCESS_READ_WRITE = 0, /* there will be possible to read and write variable */
|
||||
CAT_VAR_ACCESS_READ_ONLY, /* there will be possible to read only variable */
|
||||
CAT_VAR_ACCESS_WRITE_ONLY, /* there will be possible to write only variable */
|
||||
} cat_var_access;
|
||||
|
||||
/* enum type with function status */
|
||||
typedef enum {
|
||||
CAT_STATUS_ERROR_BUFFER_EMPTY = -7,
|
||||
CAT_STATUS_ERROR_NOT_HOLD = -6,
|
||||
CAT_STATUS_ERROR_BUFFER_FULL = -5,
|
||||
CAT_STATUS_ERROR_UNKNOWN_STATE = -4,
|
||||
CAT_STATUS_ERROR_MUTEX_LOCK = -3,
|
||||
CAT_STATUS_ERROR_MUTEX_UNLOCK = -2,
|
||||
CAT_STATUS_ERROR = -1,
|
||||
CAT_STATUS_OK = 0,
|
||||
CAT_STATUS_BUSY = 1,
|
||||
CAT_STATUS_HOLD = 2
|
||||
} cat_status;
|
||||
|
||||
/**
|
||||
* Write variable function handler
|
||||
*
|
||||
* This callback function is called after variable update immediatly.
|
||||
* User application can validate writed value and check for amount of data size was written.
|
||||
* This handler is optional, so when is not defined, operations will be fully automatically.
|
||||
*
|
||||
* @param var - pointer to struct descriptor of parsed variable
|
||||
* @param write_size - size of data was written (useful especially with hexbuf var type)
|
||||
* @return 0 - ok, else error and stop parsing
|
||||
* */
|
||||
typedef int (*cat_var_write_handler)(const struct cat_variable *var, const size_t write_size);
|
||||
|
||||
/**
|
||||
* Read variable function handler
|
||||
*
|
||||
* This callback function is called just before variable value read.
|
||||
* User application can copy data from private fields to variable connected with parsed command.
|
||||
* This handler is optional, so when is not defined, operations will be fully automatically.
|
||||
*
|
||||
* @param var - pointer to struct descriptor of parsed variable
|
||||
* @return 0 - ok, else error and stop parsing
|
||||
* */
|
||||
typedef int (*cat_var_read_handler)(const struct cat_variable *var);
|
||||
|
||||
/**
|
||||
* Write variable extended function handler
|
||||
*
|
||||
* This callback function is called after variable update immediatly.
|
||||
* User application can validate writed value and check for amount of data size was written.
|
||||
* This handler is optional, so when is not defined, operations will be fully automatically.
|
||||
*
|
||||
* @param var - pointer to struct descriptor of parsed variable
|
||||
* @param cmd - pointer to variable parent command structure
|
||||
* @param write_size - size of data was written (useful especially with hexbuf var type)
|
||||
* @return 0 - ok, else error and stop parsing
|
||||
* */
|
||||
typedef int (*cat_var_write_ex_handler)(const struct cat_variable *var, const struct cat_command *cmd, const size_t write_size);
|
||||
|
||||
/**
|
||||
* Read variable function handler
|
||||
*
|
||||
* This callback function is called just before variable value read.
|
||||
* User application can copy data from private fields to variable connected with parsed command.
|
||||
* This handler is optional, so when is not defined, operations will be fully automatically.
|
||||
*
|
||||
* @param var - pointer to struct descriptor of parsed variable
|
||||
* @param cmd - pointer to variable parent command structure
|
||||
* @return 0 - ok, else error and stop parsing
|
||||
* */
|
||||
typedef int (*cat_var_read_ex_handler)(const struct cat_variable *var, const struct cat_command *cmd);
|
||||
|
||||
/**
|
||||
* Data getter for variable.
|
||||
* The purpose of this function is to replace statically allocated data and data_size fields
|
||||
* with function pointer with context. Then the data and data_size from this getter would be
|
||||
* changed and returned runtime.
|
||||
*
|
||||
* @param var - pointer to struct descriptor of parsed variable
|
||||
* @param context - command context
|
||||
* @param size - pointer to variable where should be placed data size
|
||||
* @return pointer to data array from context
|
||||
*/
|
||||
typedef void* (*cat_var_data_getter)(const struct cat_variable *var, void *context, size_t *data_size);
|
||||
|
||||
struct cat_variable {
|
||||
const char *name; /* variable name (optional - using only for auto format test command response) */
|
||||
cat_var_type type; /* variable type (needed for parsing and validating) */
|
||||
void *data; /* generic pointer to statically allocated memory for variable data read/write/validate operations */
|
||||
size_t data_size; /* variable data size, pointed by data pointer */
|
||||
cat_var_access access; /* variable accessor */
|
||||
|
||||
cat_var_write_handler write; /* write variable handler */
|
||||
cat_var_read_handler read; /* read variable handler */
|
||||
cat_var_write_ex_handler write_ex; /* optional write variable extended handler */
|
||||
cat_var_read_ex_handler read_ex; /* optional read variable extended handler */
|
||||
|
||||
cat_var_data_getter data_getter; /* optional data getter for dynamic linking data and data_size */
|
||||
};
|
||||
|
||||
/* enum type with command callbacks return values meaning */
|
||||
typedef enum {
|
||||
CAT_RETURN_STATE_ERROR = -1, /* immediatly error acknowledge */
|
||||
CAT_RETURN_STATE_DATA_OK, /* send current data buffer followed by ok acknowledge */
|
||||
CAT_RETURN_STATE_DATA_NEXT, /* send current data buffer and go to next callback iteration */
|
||||
CAT_RETURN_STATE_NEXT, /* go to next callback iteration without sending anything */
|
||||
CAT_RETURN_STATE_OK, /* immediatly ok acknowledge */
|
||||
CAT_RETURN_STATE_HOLD, /* enable hold parser state */
|
||||
CAT_RETURN_STATE_HOLD_EXIT_OK, /* exit from hold state with OK response */
|
||||
CAT_RETURN_STATE_HOLD_EXIT_ERROR, /* exit from hold state with ERROR response */
|
||||
CAT_RETURN_STATE_PRINT_CMD_LIST_OK, /* print commands list followed by ok acknowledge (only in TEST and RUN) */
|
||||
} cat_return_state;
|
||||
|
||||
/**
|
||||
* Write command function handler (AT+CMD=)
|
||||
*
|
||||
* This callback function is called after parsing all connected variables.
|
||||
* User application can validate all variales at once at this moment, or copy them to the other application layer buffer.
|
||||
* User can check number of variables or make custom process of parsing non standard arguments format.
|
||||
* This handler is optional, so when is not defined, operations on variables will be fully automatically.
|
||||
* If neither write handler nor variables not defined, then write command type is not available.
|
||||
*
|
||||
* @param cmd - pointer to struct descriptor of processed command
|
||||
* @param data - pointer to arguments buffer for custom parsing
|
||||
* @param data_size - length of arguments buffer
|
||||
* @param args_num - number of passed arguments connected to variables
|
||||
* @return according to cat_return_state enum definitions
|
||||
* */
|
||||
typedef cat_return_state (*cat_cmd_write_handler)(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num);
|
||||
|
||||
/**
|
||||
* Read command function handler (AT+CMD?)
|
||||
*
|
||||
* This callback function is called after format all connected variables.
|
||||
* User application can change automatic response, or add some custom data to response.
|
||||
* This handler is optional, so when is not defined, operations on variables will be fully automatically.
|
||||
* If neither read handler nor variables not defined, then read command type is not available.
|
||||
*
|
||||
* @param cmd - pointer to struct descriptor of processed command
|
||||
* @param data - pointer to arguments buffer for custom parsing
|
||||
* @param data_size - pointer to length of arguments buffer (can be modifed if needed)
|
||||
* @param max_data_size - maximum length of buffer pointed by data pointer
|
||||
* @return according to cat_return_state enum definitions
|
||||
* */
|
||||
typedef cat_return_state (*cat_cmd_read_handler)(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size);
|
||||
|
||||
/**
|
||||
* Run command function handler (AT+CMD)
|
||||
*
|
||||
* No operations on variables are done.
|
||||
* This handler is optional.
|
||||
* If run handler not defined, then run command type is not available.
|
||||
*
|
||||
* @param cmd - pointer to struct descriptor of processed command
|
||||
* @return according to cat_return_state enum definitions
|
||||
* */
|
||||
typedef cat_return_state (*cat_cmd_run_handler)(const struct cat_command *cmd);
|
||||
|
||||
/**
|
||||
* Test command function handler (AT+CMD=?)
|
||||
*
|
||||
* This callback function is called after format all connected variables.
|
||||
* User application can change automatic response, or add some custom data to response.
|
||||
* This handler is optional, so when is not defined, operations on variables will be fully automatically.
|
||||
* If neither test handler nor variables not defined, then test command type is not available.
|
||||
* Exception of this rule is write command without variables.
|
||||
* In this case, the "question mark" will be passed as a custom argument to the write handler.
|
||||
*
|
||||
* @param cmd - pointer to struct descriptor of processed command
|
||||
* @param data - pointer to arguments buffer for custom parsing
|
||||
* @param data_size - pointer to length of arguments buffer (can be modifed if needed)
|
||||
* @param max_data_size - maximum length of buffer pointed by data pointer
|
||||
* @return according to cat_return_state enum definitions
|
||||
* */
|
||||
typedef cat_return_state (*cat_cmd_test_handler)(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size);
|
||||
|
||||
/* enum type with main at parser fsm state */
|
||||
typedef enum {
|
||||
CAT_STATE_ERROR = -1,
|
||||
CAT_STATE_IDLE,
|
||||
CAT_STATE_PARSE_PREFIX,
|
||||
CAT_STATE_PARSE_COMMAND_CHAR,
|
||||
CAT_STATE_UPDATE_COMMAND_STATE,
|
||||
CAT_STATE_WAIT_READ_ACKNOWLEDGE,
|
||||
CAT_STATE_SEARCH_COMMAND,
|
||||
CAT_STATE_COMMAND_FOUND,
|
||||
CAT_STATE_COMMAND_NOT_FOUND,
|
||||
CAT_STATE_PARSE_COMMAND_ARGS,
|
||||
CAT_STATE_PARSE_WRITE_ARGS,
|
||||
CAT_STATE_FORMAT_READ_ARGS,
|
||||
CAT_STATE_WAIT_TEST_ACKNOWLEDGE,
|
||||
CAT_STATE_FORMAT_TEST_ARGS,
|
||||
CAT_STATE_WRITE_LOOP,
|
||||
CAT_STATE_READ_LOOP,
|
||||
CAT_STATE_TEST_LOOP,
|
||||
CAT_STATE_RUN_LOOP,
|
||||
CAT_STATE_HOLD,
|
||||
CAT_STATE_FLUSH_IO_WRITE_WAIT,
|
||||
CAT_STATE_FLUSH_IO_WRITE,
|
||||
CAT_STATE_AFTER_FLUSH_RESET,
|
||||
CAT_STATE_AFTER_FLUSH_OK,
|
||||
CAT_STATE_AFTER_FLUSH_FORMAT_READ_ARGS,
|
||||
CAT_STATE_AFTER_FLUSH_FORMAT_TEST_ARGS,
|
||||
CAT_STATE_PRINT_CMD,
|
||||
} cat_state;
|
||||
|
||||
/* enum type with type of command request */
|
||||
typedef enum {
|
||||
CAT_CMD_TYPE_NONE = -1,
|
||||
CAT_CMD_TYPE_RUN,
|
||||
CAT_CMD_TYPE_READ,
|
||||
CAT_CMD_TYPE_WRITE,
|
||||
CAT_CMD_TYPE_TEST,
|
||||
CAT_CMD_TYPE__TOTAL_NUM
|
||||
} cat_cmd_type;
|
||||
|
||||
/* structure with io interface functions */
|
||||
struct cat_io_interface {
|
||||
int (*write)(char ch); /* write char to output stream. return 1 if byte wrote successfully. */
|
||||
int (*read)(char *ch); /* read char from input stream. return 1 if byte read successfully. */
|
||||
};
|
||||
|
||||
/* structure with mutex interface functions */
|
||||
struct cat_mutex_interface {
|
||||
int (*lock)(void); /* lock mutex handler. return 0 if successfully locked, otherwise - cannot lock */
|
||||
int (*unlock)(void); /* unlock mutex handler. return 0 if successfully unlocked, otherwise - cannot unlock */
|
||||
};
|
||||
|
||||
/* structure with at command descriptor */
|
||||
struct cat_command {
|
||||
const char *name; /* at command name (case-insensitivity) */
|
||||
const char *description; /* at command description (optionally - can be null) */
|
||||
|
||||
cat_cmd_write_handler write; /* write command handler */
|
||||
cat_cmd_read_handler read; /* read command handler */
|
||||
cat_cmd_run_handler run; /* run command handler */
|
||||
cat_cmd_test_handler test; /* test command handler */
|
||||
|
||||
struct cat_variable const *var; /* pointer to array of variables assiocated with this command */
|
||||
size_t var_num; /* number of variables in array */
|
||||
|
||||
bool need_all_vars; /* flag to need all vars parsing */
|
||||
bool only_test; /* flag to disable read/write/run commands (only test auto description) */
|
||||
bool disable; /* flag to completely disable command */
|
||||
|
||||
void* context; /* pointer to optional context structure */
|
||||
};
|
||||
|
||||
struct cat_command_group {
|
||||
const char *name; /* command group name (optional, for identification purpose) */
|
||||
|
||||
struct cat_command const *cmd; /* pointer to array of commands descriptor */
|
||||
size_t cmd_num; /* number of commands in array */
|
||||
|
||||
bool disable; /* flag to completely disable all commands in group */
|
||||
};
|
||||
|
||||
/* structure with at command parser descriptor */
|
||||
struct cat_descriptor {
|
||||
struct cat_command_group* const *cmd_group; /* pointer to array of commands group descriptor */
|
||||
size_t cmd_group_num; /* number of commands group in array */
|
||||
|
||||
uint8_t *buf; /* pointer to working buffer (used to parse command argument) */
|
||||
size_t buf_size; /* working buffer length */
|
||||
|
||||
/* optional unsolicited buffer, if not configured (NULL) */
|
||||
/* then the buf will be divided into two smaller buffers */
|
||||
uint8_t *unsolicited_buf; /* pointer to unsolicited working buffer (used to parse command argument) */
|
||||
size_t unsolicited_buf_size; /* unsolicited working buffer length */
|
||||
};
|
||||
|
||||
/* strcuture with unsolicited command buffered infos */
|
||||
struct cat_unsolicited_cmd {
|
||||
struct cat_command const *cmd; /* pointer to commands used to unsolicited event */
|
||||
cat_cmd_type type; /* type of unsolicited event */
|
||||
};
|
||||
|
||||
/* enum type with unsolicited events fsm state */
|
||||
typedef enum {
|
||||
CAT_UNSOLICITED_STATE_IDLE,
|
||||
CAT_UNSOLICITED_STATE_FORMAT_READ_ARGS,
|
||||
CAT_UNSOLICITED_STATE_FORMAT_TEST_ARGS,
|
||||
CAT_UNSOLICITED_STATE_READ_LOOP,
|
||||
CAT_UNSOLICITED_STATE_TEST_LOOP,
|
||||
CAT_UNSOLICITED_STATE_FLUSH_IO_WRITE_WAIT,
|
||||
CAT_UNSOLICITED_STATE_FLUSH_IO_WRITE,
|
||||
CAT_UNSOLICITED_STATE_AFTER_FLUSH_RESET,
|
||||
CAT_UNSOLICITED_STATE_AFTER_FLUSH_OK,
|
||||
CAT_UNSOLICITED_STATE_AFTER_FLUSH_FORMAT_READ_ARGS,
|
||||
CAT_UNSOLICITED_STATE_AFTER_FLUSH_FORMAT_TEST_ARGS,
|
||||
} cat_unsolicited_state;
|
||||
|
||||
/* enum type with fsm type */
|
||||
typedef enum {
|
||||
CAT_FSM_TYPE_ATCMD,
|
||||
CAT_FSM_TYPE_UNSOLICITED,
|
||||
CAT_FSM_TYPE__TOTAL_NUM,
|
||||
} cat_fsm_type;
|
||||
|
||||
struct cat_unsolicited_fsm {
|
||||
cat_unsolicited_state state; /* current unsolicited fsm state */
|
||||
|
||||
size_t index; /* index used to iterate over commands and variables */
|
||||
size_t position; /* position of actually parsed char in arguments string */
|
||||
|
||||
struct cat_command const *cmd; /* pointer to current command descriptor */
|
||||
struct cat_variable const *var; /* pointer to current variable descriptor */
|
||||
cat_cmd_type cmd_type; /* type of command request */
|
||||
|
||||
char const *write_buf; /* working buffer pointer used for asynch writing to io */
|
||||
int write_state; /* before, data, after flush io write state */
|
||||
cat_unsolicited_state write_state_after; /* parser state to set after flush io write */
|
||||
|
||||
struct cat_unsolicited_cmd unsolicited_cmd_buffer[CAT_UNSOLICITED_CMD_BUFFER_SIZE]; /* buffer with unsolicited commands used to unsolicited event */
|
||||
size_t unsolicited_cmd_buffer_tail; /* tail index of unsolicited cmd buffer */
|
||||
size_t unsolicited_cmd_buffer_head; /* head index of unsolicited cmd buffer */
|
||||
size_t unsolicited_cmd_buffer_items_count; /* number of unsolicited cmd in buffer */
|
||||
};
|
||||
|
||||
/* structure with main at command parser object */
|
||||
struct cat_object {
|
||||
struct cat_descriptor const *desc; /* pointer to at command parser descriptor */
|
||||
struct cat_io_interface const *io; /* pointer to at command parser io interface */
|
||||
struct cat_mutex_interface const *mutex; /* pointer to at command parser mutex interface */
|
||||
|
||||
size_t index; /* index used to iterate over commands and variables */
|
||||
size_t partial_cntr; /* partial match commands counter */
|
||||
size_t length; /* length of input command name and command arguments */
|
||||
size_t position; /* position of actually parsed char in arguments string */
|
||||
size_t write_size; /* size of parsed buffer hex or buffer string */
|
||||
size_t commands_num; /* computed total number of registered commands */
|
||||
|
||||
struct cat_command const *cmd; /* pointer to current command descriptor */
|
||||
struct cat_variable const *var; /* pointer to current variable descriptor */
|
||||
cat_cmd_type cmd_type; /* type of command request */
|
||||
|
||||
char current_char; /* current received char from input stream */
|
||||
cat_state state; /* current fsm state */
|
||||
bool cr_flag; /* flag for detect <cr> char in input string */
|
||||
bool hold_state_flag; /* status of hold state (independent from fsm states) */
|
||||
int hold_exit_status; /* hold exit parameter with status */
|
||||
char const *write_buf; /* working buffer pointer used for asynch writing to io */
|
||||
int write_state; /* before, data, after flush io write state */
|
||||
cat_state write_state_after; /* parser state to set after flush io write */
|
||||
|
||||
struct cat_unsolicited_fsm unsolicited_fsm;
|
||||
};
|
||||
|
||||
/**
|
||||
* Function used to initialize at command parser.
|
||||
* Initialize starting values of object fields.
|
||||
*
|
||||
* @param self pointer to at command parser object to initialize
|
||||
* @param desc pointer to at command parser descriptor
|
||||
* @param io pointer to at command parser io low-level layer interface
|
||||
* @param mutex pointer to at command partes mutex interface
|
||||
*/
|
||||
void cat_init(struct cat_object *self, const struct cat_descriptor *desc, const struct cat_io_interface *io, const struct cat_mutex_interface *mutex);
|
||||
|
||||
/**
|
||||
* Function must be called periodically to asynchronoulsy run at command parser.
|
||||
* Commands handlers will be call from this function context.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @return according to cat_return_state enum definitions
|
||||
*/
|
||||
cat_status cat_service(struct cat_object *self);
|
||||
|
||||
/**
|
||||
* Function return flag which indicating internal busy state.
|
||||
* It is used to determine whether external application modules can use shared input / output interfaces functions.
|
||||
* It is usefull especially in rtos environments.
|
||||
* If internal parser state is busy by doing some processing then function return 1.
|
||||
* If the function returns 0, then the external application modules can safely use the input / output interfaces functions shared with the library.
|
||||
* If the function returns 1, then input / output interface function are used by internal parser functions.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @return according to cat_return_state enum definitions
|
||||
*/
|
||||
cat_status cat_is_busy(struct cat_object *self);
|
||||
|
||||
/**
|
||||
* Function return flag which indicating parsing hold state.
|
||||
* If the function returns 0, then the at parsing process is normal.
|
||||
* If the function returns 1, then the at parsing process is holded.
|
||||
* To exit from hold state, user have to call cat_hold_exit or return HOLD_EXIT return value in callback.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @return according to cat_return_state enum definitions
|
||||
*/
|
||||
cat_status cat_is_hold(struct cat_object *self);
|
||||
|
||||
/**
|
||||
* Function return flag which indicating state of internal buffer of unsolicited events.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @return CAT_STATUS_OK - buffer is not full, unsolicited event can be buffered
|
||||
* CAT_STATUS_ERROR_BUFFER_FULL - buffer is full, unsolicited event cannot be buffered
|
||||
* CAT_STATUS_ERROR_MUTEX_LOCK - cannot lock mutex error
|
||||
* CAT_STATUS_ERROR_MUTEX_UNLOCK - cannot unlock mutex error
|
||||
*/
|
||||
cat_status cat_is_unsolicited_buffer_full(struct cat_object *self);
|
||||
|
||||
/**
|
||||
* Function sends unsolicited event message.
|
||||
* Command message is buffered inside parser in 1-level deep buffer and processed in cat_service context.
|
||||
* Only command pointer is buffered, so command struct should be static or global until be fully processed.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param cmd pointer to command structure regarding which unsolicited event applies to
|
||||
* @param type type of operation (only CAT_CMD_TYPE_READ and CAT_CMD_TYPE_TEST are allowed)
|
||||
* @return according to cat_return_state enum definitions
|
||||
*/
|
||||
cat_status cat_trigger_unsolicited_event(struct cat_object *self, struct cat_command const *cmd, cat_cmd_type type);
|
||||
|
||||
/**
|
||||
* Function sends unsolicited read event message.
|
||||
* Command message is buffered inside parser in 1-level deep buffer and processed in cat_service context.
|
||||
* Only command pointer is buffered, so command struct should be static or global until be fully processed.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param cmd pointer to command structure regarding which unsolicited read applies to
|
||||
* @return according to cat_return_state enum definitions
|
||||
*/
|
||||
cat_status cat_trigger_unsolicited_read(struct cat_object *self, struct cat_command const *cmd);
|
||||
|
||||
/**
|
||||
* Function sends unsolicited test event message.
|
||||
* Command message is buffered inside parser in 1-level deep buffer and processed in cat_service context.
|
||||
* Only command pointer is buffered, so command struct should be static or global until be fully processed.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param cmd pointer to command structure regarding which unsolicited test applies to
|
||||
* @return according to cat_return_state enum definitions
|
||||
*/
|
||||
cat_status cat_trigger_unsolicited_test(struct cat_object *self, struct cat_command const *cmd);
|
||||
|
||||
/**
|
||||
* Function used to exit from hold state with OK/ERROR response and back to idle state.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param status response status 0 - OK, else ERROR
|
||||
* @return according to cat_return_state enum definitions
|
||||
*/
|
||||
cat_status cat_hold_exit(struct cat_object *self, cat_status status);
|
||||
|
||||
/**
|
||||
* Function used to searching registered command by its name.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param name command name to search
|
||||
* @return pointer to command object, NULL if command not found
|
||||
*/
|
||||
struct cat_command const* cat_search_command_by_name(struct cat_object *self, const char *name);
|
||||
|
||||
/**
|
||||
* Function used to searching registered command group by its name.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param name command group name to search
|
||||
* @return pointer to command group object, NULL if command group not found
|
||||
*/
|
||||
struct cat_command_group const* cat_search_command_group_by_name(struct cat_object *self, const char *name);
|
||||
|
||||
/**
|
||||
* Function used to searching attached variable to command its name.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param cmd pointer to command in which variable will be searched
|
||||
* @param name variable name to search
|
||||
* @return pointer to command group object, NULL if command group not found
|
||||
*/
|
||||
struct cat_variable const* cat_search_variable_by_name(struct cat_object *self, struct cat_command const *cmd, const char *name);
|
||||
|
||||
/**
|
||||
* Function used to check what command is currently processed.
|
||||
* Function is not protected by mutex mechanism, due to processed cmd may change after function return.
|
||||
* This only matters in multithreaded environments, it does not matter for one thread.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param fsm type of internal state machine to check current command
|
||||
* @return pointer to command which is currently processed, NULL if no command is processed
|
||||
*/
|
||||
struct cat_command const* cat_get_processed_command(struct cat_object *self, cat_fsm_type fsm);
|
||||
|
||||
/**
|
||||
* Function return unsolicited event command status.
|
||||
* Function is not protected by mutex mechanism, due to processed cmd may change after function return.
|
||||
* This only matters in multithreaded environments, it does not matter for one thread.
|
||||
*
|
||||
* @param self pointer to at command parser object
|
||||
* @param cmd pointer to command in which variable will be searched
|
||||
* @param type type of unsolicited event
|
||||
* @return CAT_STATUS_OK - command is not buffered nor processed
|
||||
* CAT_STATUS_BUSY - command is waiting in buffer or is processed
|
||||
*/
|
||||
cat_status cat_is_unsolicited_event_buffered(struct cat_object *self, struct cat_command const *cmd, cat_cmd_type type);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* CAT_H */
|
||||
@@ -1,340 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char ack_results[512];
|
||||
|
||||
static int8_t var1;
|
||||
static int8_t var2;
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_run(const struct cat_command *cmd)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var1_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var2_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int print_cmd_list(const struct cat_command *cmd)
|
||||
{
|
||||
return CAT_RETURN_STATE_PRINT_CMD_LIST_OK;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars_ro[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write,
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars_wo[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write,
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars2[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars2_ro[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write,
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars2_wo[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write,
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+V1",
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+V1RO",
|
||||
.var = vars_ro,
|
||||
.var_num = sizeof(vars_ro) / sizeof(vars_ro[0])
|
||||
},
|
||||
{
|
||||
.name = "+V1RW",
|
||||
.var = vars_wo,
|
||||
.var_num = sizeof(vars_wo) / sizeof(vars_wo[0])
|
||||
},
|
||||
{
|
||||
.name = "+V11",
|
||||
.var = vars2,
|
||||
.var_num = sizeof(vars2) / sizeof(vars2[0])
|
||||
},
|
||||
{
|
||||
.name = "+V11RO",
|
||||
.var = vars2_ro,
|
||||
.var_num = sizeof(vars2_ro) / sizeof(vars2_ro[0])
|
||||
},
|
||||
{
|
||||
.name = "+V11WO",
|
||||
.var = vars2_wo,
|
||||
.var_num = sizeof(vars2_wo) / sizeof(vars2_wo[0])
|
||||
},
|
||||
{
|
||||
.name = "+V2",
|
||||
.write = cmd_write,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+V3",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+V4",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
.test = cmd_test,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+V5",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
.test = cmd_test,
|
||||
.run = cmd_run,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+S1",
|
||||
},
|
||||
{
|
||||
.name = "+S2",
|
||||
.write = cmd_write,
|
||||
},
|
||||
{
|
||||
.name = "+S3",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
},
|
||||
{
|
||||
.name = "+S4",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
.test = cmd_test,
|
||||
},
|
||||
{
|
||||
.name = "+S5",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
.test = cmd_test,
|
||||
.run = cmd_run,
|
||||
},
|
||||
{
|
||||
.name = "+D1",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
.test = cmd_test,
|
||||
.run = cmd_run,
|
||||
.disable = true,
|
||||
},
|
||||
{
|
||||
.name = "+T1",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
.test = cmd_test,
|
||||
.run = cmd_run,
|
||||
.only_test = true,
|
||||
},
|
||||
{
|
||||
.name = "+T2",
|
||||
.only_test = true,
|
||||
},
|
||||
{
|
||||
.name = "#HELP",
|
||||
.run = print_cmd_list,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[512];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static void print_raw_text(char *p)
|
||||
{
|
||||
while (*p != '\0') {
|
||||
if (*p == '\n') {
|
||||
printf("\\n");
|
||||
} else {
|
||||
putchar(*p);
|
||||
}
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input("\nAT#HELP\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nAT+V1?\nAT+V1=\nAT+V1=?\n\nAT+V1RO?\nAT+V1RO=?\n\nAT+V1RW=\nAT+V1RW=?\n\nAT+V11?\nAT+V11=\nAT+V11=?\n\nAT+V11RO?\nAT+V11RO=\nAT+V11RO=?\n\nAT+V11WO?\nAT+V11WO=\nAT+V11WO=?\n\nAT+V2?\nAT+V2=\nAT+V2=?\n\nAT+V3?\nAT+V3=\nAT+V3=?\n\nAT+V4?\nAT+V4=\nAT+V4=?\n\nAT+V5\nAT+V5?\nAT+V5=\nAT+V5=?\n\nAT+S2=\n\nAT+S3?\nAT+S3=\n\nAT+S4?\nAT+S4=\nAT+S4=?\n\nAT+S5\nAT+S5?\nAT+S5=\nAT+S5=?\n\nAT+T1=?\n\nAT#HELP\n\nOK\n") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,229 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char cmd_results[256];
|
||||
static char var_read_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x, var_u1, var_u2;
|
||||
static struct cat_object at;
|
||||
|
||||
static struct cat_command u_cmds[];
|
||||
|
||||
static cat_return_state cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
strcat(cmd_results, " write:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
if (var_x < 2) {
|
||||
s = cat_trigger_unsolicited_read(&at, &u_cmds[var_x]);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
|
||||
return CAT_RETURN_STATE_HOLD;
|
||||
}
|
||||
|
||||
return CAT_RETURN_STATE_ERROR;
|
||||
}
|
||||
|
||||
static cat_return_state cmd1_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
strcat(cmd_results, " read1:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
if (var_u1 > 0) {
|
||||
var_u1--;
|
||||
s = cat_trigger_unsolicited_read(&at, cmd);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
return CAT_RETURN_STATE_DATA_OK;
|
||||
}
|
||||
|
||||
return CAT_RETURN_STATE_HOLD_EXIT_OK;
|
||||
}
|
||||
|
||||
static cat_return_state cmd2_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
strcat(cmd_results, " read2:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
if (var_u2 > 0) {
|
||||
var_u2--;
|
||||
s = cat_trigger_unsolicited_read(&at, cmd);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
return CAT_RETURN_STATE_DATA_OK;
|
||||
}
|
||||
|
||||
cat_hold_exit(&at, CAT_STATUS_OK);
|
||||
return CAT_RETURN_STATE_DATA_OK;
|
||||
}
|
||||
|
||||
static int var_read(const struct cat_variable *var)
|
||||
{
|
||||
strcat(var_read_results, " var_read:");
|
||||
strcat(var_read_results, var->name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable u_vars[] = {
|
||||
{
|
||||
.name = "U1",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u1,
|
||||
.data_size = sizeof(var_u1),
|
||||
.read = var_read
|
||||
},
|
||||
{
|
||||
.name = "U2",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u2,
|
||||
.data_size = sizeof(var_u2),
|
||||
.read = var_read
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x),
|
||||
.read = var_read
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.write = cmd_write,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command u_cmds[] = {
|
||||
{
|
||||
.name = "+U1CMD",
|
||||
.read = cmd1_read,
|
||||
.var = &u_vars[0],
|
||||
.var_num = 1,
|
||||
},
|
||||
{
|
||||
.name = "+U2CMD",
|
||||
.read = cmd2_read,
|
||||
.var = &u_vars[1],
|
||||
.var_num = 1,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var_u1 = 2;
|
||||
var_u2 = 3;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(cmd_results, 0, sizeof(cmd_results));
|
||||
memset(var_read_results, 0, sizeof(var_read_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD=0\n\nAT+CMD=1\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+U1CMD=2\n\n+U1CMD=1\n\nOK\n\n+U2CMD=3\n\n+U2CMD=2\n\n+U2CMD=1\n\n+U2CMD=0\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD read1:+U1CMD read1:+U1CMD read1:+U1CMD write:+CMD read2:+U2CMD read2:+U2CMD read2:+U2CMD read2:+U2CMD") == 0);
|
||||
assert(strcmp(var_read_results, " var_read:U1 var_read:U1 var_read:U1 var_read:U2 var_read:U2 var_read:U2 var_read:U2") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,185 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char run_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int a_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " A:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " AP:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " +TEST:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "A",
|
||||
.run = a_run
|
||||
},
|
||||
{
|
||||
.name = "AP",
|
||||
.run = ap_run
|
||||
},
|
||||
{
|
||||
.name = "+TEST",
|
||||
.run = test_run
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static int mutex_ret_lock;
|
||||
static int mutex_ret_unlock;
|
||||
|
||||
static int mutex_lock(void)
|
||||
{
|
||||
return mutex_ret_lock;
|
||||
}
|
||||
|
||||
static int mutex_unlock(void)
|
||||
{
|
||||
return mutex_ret_unlock;
|
||||
}
|
||||
|
||||
static struct cat_mutex_interface mutex = {
|
||||
.lock = mutex_lock,
|
||||
.unlock = mutex_unlock
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
mutex_ret_lock = 0;
|
||||
mutex_ret_unlock = 0;
|
||||
|
||||
memset(run_results, 0, sizeof(run_results));
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT\nAT+test\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, &mutex);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(run_results, " +TEST:+TEST") == 0);
|
||||
|
||||
mutex_ret_lock = 1;
|
||||
mutex_ret_unlock = 0;
|
||||
assert(cat_service(&at) == CAT_STATUS_ERROR_MUTEX_LOCK);
|
||||
|
||||
mutex_ret_lock = 0;
|
||||
mutex_ret_unlock = 1;
|
||||
assert(cat_service(&at) == CAT_STATUS_ERROR_MUTEX_UNLOCK);
|
||||
|
||||
mutex_ret_lock = 1;
|
||||
mutex_ret_unlock = 0;
|
||||
assert(cat_is_busy(&at) == CAT_STATUS_ERROR_MUTEX_LOCK);
|
||||
|
||||
mutex_ret_lock = 0;
|
||||
mutex_ret_unlock = 1;
|
||||
assert(cat_is_busy(&at) == CAT_STATUS_ERROR_MUTEX_UNLOCK);
|
||||
|
||||
mutex_ret_lock = 0;
|
||||
mutex_ret_unlock = 0;
|
||||
assert(cat_service(&at) == CAT_STATUS_OK);
|
||||
assert(cat_is_busy(&at) == CAT_STATUS_OK);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,223 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char run_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int e_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " E:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int e0_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " E0:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int e1_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " E1:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_command cmds1[] = {
|
||||
{
|
||||
.name = "E",
|
||||
.run = e_run,
|
||||
},
|
||||
{
|
||||
.name = "E0",
|
||||
.run = e0_run,
|
||||
},
|
||||
{
|
||||
.name = "E1",
|
||||
.run = e1_run,
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds2[] = {
|
||||
{
|
||||
.name = "E0",
|
||||
.run = e0_run,
|
||||
},
|
||||
{
|
||||
.name = "E1",
|
||||
.run = e1_run,
|
||||
},
|
||||
{
|
||||
.name = "E",
|
||||
.run = e_run,
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds3[] = {
|
||||
{
|
||||
.name = "E0",
|
||||
.run = e0_run,
|
||||
},
|
||||
{
|
||||
.name = "E",
|
||||
.run = e_run,
|
||||
},
|
||||
{
|
||||
.name = "E1",
|
||||
.run = e1_run,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_1_group = {
|
||||
.cmd = cmds1,
|
||||
.cmd_num = sizeof(cmds1) / sizeof(cmds1[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_1_desc[] = {
|
||||
&cmd_1_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc_1 = {
|
||||
.cmd_group = cmd_1_desc,
|
||||
.cmd_group_num = sizeof(cmd_1_desc) / sizeof(cmd_1_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static struct cat_command_group cmd_2_group = {
|
||||
.cmd = cmds2,
|
||||
.cmd_num = sizeof(cmds2) / sizeof(cmds2[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_2_desc[] = {
|
||||
&cmd_2_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc_2 = {
|
||||
.cmd_group = cmd_2_desc,
|
||||
.cmd_group_num = sizeof(cmd_2_desc) / sizeof(cmd_2_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static struct cat_command_group cmd_3_group = {
|
||||
.cmd = cmds3,
|
||||
.cmd_num = sizeof(cmds3) / sizeof(cmds3[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_3_desc[] = {
|
||||
&cmd_3_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc_3 = {
|
||||
.cmd_group = cmd_3_desc,
|
||||
.cmd_group_num = sizeof(cmd_3_desc) / sizeof(cmd_3_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(run_results, 0, sizeof(run_results));
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nATE\n\nATE0\n\nATE1\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc_1, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(run_results, " E:E E0:E0 E1:E1") == 0);
|
||||
|
||||
cat_init(&at, &desc_2, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(run_results, " E:E E0:E0 E1:E1") == 0);
|
||||
|
||||
cat_init(&at, &desc_3, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(run_results, " E:E E0:E0 E1:E1") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,195 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char run_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int a_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " A:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " AP:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " +TEST:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "A",
|
||||
.run = a_run,
|
||||
.disable = false,
|
||||
},
|
||||
{
|
||||
.name = "AP",
|
||||
.run = ap_run,
|
||||
.disable = false,
|
||||
},
|
||||
{
|
||||
.name = "+TEST",
|
||||
.run = test_run,
|
||||
.disable = false,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(run_results, 0, sizeof(run_results));
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nsa\rAT\n\r\nAT\nAT+\n\nATA\r\natap\naaaattttap\na\n\r+test\r\n+testATA\nATAPATAP\n\rAT\rATA\nAT+test\r\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\r\nERROR\r\n\nOK\n\nOK\n\r\nOK\r\n\nOK\n\nERROR\n\nERROR\n\r\nERROR\r\n\nERROR\n\nERROR\n\r\nERROR\r\n\r\nOK\r\n") == 0);
|
||||
assert(strcmp(run_results, " +TEST:+TEST A:A AP:AP +TEST:+TEST") == 0);
|
||||
|
||||
prepare_input("\nAT\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(cat_is_busy(&at) == 0);
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(run_results, "") == 0);
|
||||
|
||||
prepare_input("\nAT+te");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(cat_is_busy(&at) != 0);
|
||||
assert(strcmp(ack_results, "") == 0);
|
||||
assert(strcmp(run_results, "") == 0);
|
||||
|
||||
prepare_input("st\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(cat_is_busy(&at) == 0);
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(run_results, " +TEST:+TEST") == 0);
|
||||
|
||||
struct cat_command *cmd;
|
||||
|
||||
cmd = (struct cat_command*)cat_search_command_by_name(&at, "A");
|
||||
cmd->disable = true;
|
||||
cmd = (struct cat_command*)cat_search_command_by_name(&at, "+TEST");
|
||||
cmd->disable = true;
|
||||
|
||||
prepare_input("\nATA\n\nATAP\n\nAT+TEST\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(run_results, " AP:AP AP:AP") == 0);
|
||||
|
||||
struct cat_command_group *cmd_group;
|
||||
cmd_group = (struct cat_command_group*)cat_search_command_group_by_name(&at, "standard");
|
||||
assert(cmd_group == NULL);
|
||||
|
||||
cmd_desc[0]->name = "standard";
|
||||
cmd_group = (struct cat_command_group*)cat_search_command_group_by_name(&at, "standard");
|
||||
assert(cmd_group == cmd_desc[0]);
|
||||
cmd_group->disable = true;
|
||||
|
||||
prepare_input("\nATA\n\nATAP\n\nAT+TEST\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nERROR\n\nERROR\n") == 0);
|
||||
assert(strcmp(run_results, "") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,165 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char run_results[256];
|
||||
static char read_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int a_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " A_");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int a_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(read_results, " A:");
|
||||
strcat(read_results, cmd->name);
|
||||
|
||||
snprintf(data, max_data_size, "%s=A-val", cmd->name);
|
||||
*data_size = strlen(data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(read_results, " AP:");
|
||||
strcat(read_results, cmd->name);
|
||||
|
||||
*data_size = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(read_results, " +TEST:");
|
||||
strcat(read_results, cmd->name);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "A",
|
||||
.read = a_read,
|
||||
.run = a_run
|
||||
},
|
||||
{
|
||||
.name = "AP",
|
||||
.read = ap_read
|
||||
},
|
||||
{
|
||||
.name = "+TEST",
|
||||
.read = test_read
|
||||
},
|
||||
{
|
||||
.name = "+EMPTY"
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(run_results, 0, sizeof(run_results));
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(read_results, 0, sizeof(read_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT\r\nAT+\nAT+?\nATA?\r\nATAP\nATAP?\nATAPA?\nAT+TEST?\nAT+te?\nAT+e?\nAT+empTY?\r\nATA\r\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\r\nOK\r\n\nERROR\n\nERROR\n\r\nA=A-val\r\n\r\nOK\r\n\nERROR\n\nAP=\n\nOK\n\nERROR\n\nERROR\n\nERROR\n\nERROR\n\r\nERROR\r\n\r\nOK\r\n") == 0);
|
||||
assert(strcmp(run_results, " A_A") == 0);
|
||||
assert(strcmp(read_results, " A:A AP:AP +TEST:+TEST +TEST:+TEST") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,225 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char ack_results[256];
|
||||
|
||||
static int8_t var_int;
|
||||
static uint8_t var_uint;
|
||||
static uint8_t var_hex8;
|
||||
static uint16_t var_hex16;
|
||||
static uint32_t var_hex32;
|
||||
static uint8_t var_buf[4];
|
||||
static char var_string[16];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
static int common_cntr;
|
||||
static uint8_t ctx;
|
||||
|
||||
static int cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd2_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
sprintf(data, "%s=test", cmd->name);
|
||||
*data_size = strlen(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int common_var_read_handler(const struct cat_variable *var)
|
||||
{
|
||||
common_cntr++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void* var_int_data_getter(const struct cat_variable *var, void *context, size_t *data_size)
|
||||
{
|
||||
*data_size = sizeof(var_int);
|
||||
assert(context == &ctx);
|
||||
return &var_int;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.read = common_var_read_handler,
|
||||
.data_getter = var_int_data_getter,
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint,
|
||||
.data_size = sizeof(var_uint),
|
||||
.read = common_var_read_handler
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex8,
|
||||
.data_size = sizeof(var_hex8),
|
||||
.read = common_var_read_handler
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex16,
|
||||
.data_size = sizeof(var_hex16),
|
||||
.read = common_var_read_handler
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex32,
|
||||
.data_size = sizeof(var_hex32),
|
||||
.read = common_var_read_handler
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_HEX,
|
||||
.data = &var_buf,
|
||||
.data_size = sizeof(var_buf),
|
||||
.read = common_var_read_handler
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = &var_string,
|
||||
.data_size = sizeof(var_string),
|
||||
.read = common_var_read_handler
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+SET",
|
||||
.read = cmd_read,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
.context = &ctx,
|
||||
},
|
||||
{
|
||||
.name = "+TEST",
|
||||
.read = cmd2_read,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
.context = &ctx,
|
||||
},
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var_int = -1;
|
||||
var_uint = 255;
|
||||
var_hex8 = 0xAA;
|
||||
var_hex16 = 0x0123;
|
||||
var_hex32 = 0xFF001234;
|
||||
|
||||
var_buf[0] = 0x12;
|
||||
var_buf[1] = 0x34;
|
||||
var_buf[2] = 0x56;
|
||||
var_buf[3] = 0x78;
|
||||
|
||||
common_cntr = 0;
|
||||
|
||||
sprintf(var_string, "\\\"test\n");
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+SET?\r\n";
|
||||
static const char test_case_2[] = "\nAT+TEST?\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\r\n+SET=-1,255,0xAA,0x0123,0xFF001234,12345678,\"\\\\\\\"test\\n\"\r\n\r\nOK\r\n") == 0);
|
||||
assert(common_cntr == 7);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+TEST=test\n\nOK\n") == 0);
|
||||
assert(common_cntr == 7);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,206 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char cmd_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x;
|
||||
static struct cat_object at;
|
||||
|
||||
static cat_return_state ret;
|
||||
static bool ret_error;
|
||||
|
||||
static cat_return_state cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(cmd_results, " read:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
if (cat_is_hold(&at) == CAT_STATUS_HOLD) {
|
||||
var_x++;
|
||||
if (var_x > 4) {
|
||||
ret = (ret_error == false) ? CAT_RETURN_STATE_HOLD_EXIT_OK : CAT_RETURN_STATE_HOLD_EXIT_ERROR;
|
||||
} else {
|
||||
if (var_x == 4) {
|
||||
strcpy(data, "test");
|
||||
*data_size = strlen(data);
|
||||
}
|
||||
ret = CAT_RETURN_STATE_DATA_NEXT;
|
||||
}
|
||||
} else {
|
||||
if ((ret == CAT_RETURN_STATE_DATA_NEXT) || (ret == CAT_RETURN_STATE_NEXT)) {
|
||||
var_x++;
|
||||
if (var_x > 2)
|
||||
ret = CAT_RETURN_STATE_DATA_OK;
|
||||
} else if (ret == CAT_RETURN_STATE_HOLD) {
|
||||
cat_trigger_unsolicited_read(&at, cmd);
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x)
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.read = cmd_read,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
var_x = 1;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(cmd_results, 0, sizeof(cmd_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD?\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
ret = CAT_RETURN_STATE_ERROR;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " read:+CMD") == 0);
|
||||
|
||||
ret = CAT_RETURN_STATE_DATA_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=1\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " read:+CMD") == 0);
|
||||
|
||||
ret = CAT_RETURN_STATE_DATA_NEXT;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=1\n\n+CMD=2\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " read:+CMD read:+CMD") == 0);
|
||||
|
||||
ret = CAT_RETURN_STATE_NEXT;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=2\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " read:+CMD read:+CMD") == 0);
|
||||
|
||||
ret = CAT_RETURN_STATE_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " read:+CMD") == 0);
|
||||
|
||||
ret_error = false;
|
||||
ret = CAT_RETURN_STATE_HOLD;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=1\n\n+CMD=2\n\ntest\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " read:+CMD read:+CMD read:+CMD read:+CMD read:+CMD") == 0);
|
||||
|
||||
ret_error = true;
|
||||
ret = CAT_RETURN_STATE_HOLD;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=1\n\n+CMD=2\n\ntest\n\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " read:+CMD read:+CMD read:+CMD read:+CMD read:+CMD") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,236 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char cmd_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x;
|
||||
static struct cat_object at;
|
||||
|
||||
static cat_return_state ret;
|
||||
static bool ret_error;
|
||||
|
||||
static cat_return_state cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(cmd_results, " read:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
var_x++;
|
||||
if (var_x > 5) {
|
||||
ret = (ret_error == false) ? CAT_RETURN_STATE_HOLD_EXIT_OK : CAT_RETURN_STATE_HOLD_EXIT_ERROR;
|
||||
} else {
|
||||
if (var_x == 5) {
|
||||
strcpy(data, "test");
|
||||
*data_size = strlen(data);
|
||||
}
|
||||
ret = CAT_RETURN_STATE_DATA_NEXT;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static cat_return_state cmd_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(cmd_results, " run:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
if ((ret == CAT_RETURN_STATE_DATA_NEXT) || (ret == CAT_RETURN_STATE_NEXT)) {
|
||||
var_x++;
|
||||
if (var_x > 3)
|
||||
ret = CAT_RETURN_STATE_DATA_OK;
|
||||
} else if (ret == CAT_RETURN_STATE_HOLD) {
|
||||
cat_trigger_unsolicited_read(&at, cmd);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x)
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.run = cmd_run,
|
||||
.read = cmd_read,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
var_x = 2;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(cmd_results, 0, sizeof(cmd_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
ret = CAT_RETURN_STATE_ERROR;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
ret = CAT_RETURN_STATE_DATA_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
ret = CAT_RETURN_STATE_DATA_NEXT;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD run:+CMD") == 0);
|
||||
assert(var_x == 4);
|
||||
|
||||
ret = CAT_RETURN_STATE_NEXT;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD run:+CMD") == 0);
|
||||
assert(var_x == 4);
|
||||
|
||||
ret = CAT_RETURN_STATE_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
ret_error = false;
|
||||
ret = CAT_RETURN_STATE_HOLD;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=2\n\n+CMD=3\n\ntest\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD read:+CMD read:+CMD read:+CMD read:+CMD") == 0);
|
||||
assert(var_x == 6);
|
||||
|
||||
ret_error = true;
|
||||
ret = CAT_RETURN_STATE_HOLD;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=2\n\n+CMD=3\n\ntest\n\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD read:+CMD read:+CMD read:+CMD read:+CMD") == 0);
|
||||
assert(var_x == 6);
|
||||
|
||||
ret = CAT_RETURN_STATE_HOLD_EXIT_ERROR;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
ret = CAT_RETURN_STATE_HOLD_EXIT_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " run:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,206 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char cmd_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x;
|
||||
static struct cat_object at;
|
||||
|
||||
static cat_return_state ret;
|
||||
static bool ret_error;
|
||||
|
||||
static cat_return_state cmd_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(cmd_results, " test:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
if (cat_is_hold(&at) == CAT_STATUS_HOLD) {
|
||||
var_x++;
|
||||
if (var_x > 4) {
|
||||
ret = (ret_error == false) ? CAT_RETURN_STATE_HOLD_EXIT_OK : CAT_RETURN_STATE_HOLD_EXIT_ERROR;
|
||||
} else {
|
||||
if (var_x == 4) {
|
||||
strcpy(data, "test");
|
||||
*data_size = strlen(data);
|
||||
}
|
||||
ret = CAT_RETURN_STATE_DATA_NEXT;
|
||||
}
|
||||
} else {
|
||||
if ((ret == CAT_RETURN_STATE_DATA_NEXT) || (ret == CAT_RETURN_STATE_NEXT)) {
|
||||
var_x++;
|
||||
if (var_x > 2)
|
||||
ret = CAT_RETURN_STATE_DATA_OK;
|
||||
} else if (ret == CAT_RETURN_STATE_HOLD) {
|
||||
cat_trigger_unsolicited_test(&at, cmd);
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x)
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.test = cmd_test,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
var_x = 1;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(cmd_results, 0, sizeof(cmd_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD=?\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
ret = CAT_RETURN_STATE_ERROR;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:+CMD") == 0);
|
||||
|
||||
ret = CAT_RETURN_STATE_DATA_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=<X:INT32[RW]>\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:+CMD") == 0);
|
||||
|
||||
ret = CAT_RETURN_STATE_DATA_NEXT;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=<X:INT32[RW]>\n\n+CMD=<X:INT32[RW]>\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:+CMD test:+CMD") == 0);
|
||||
|
||||
ret = CAT_RETURN_STATE_NEXT;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=<X:INT32[RW]>\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:+CMD test:+CMD") == 0);
|
||||
|
||||
ret = CAT_RETURN_STATE_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:+CMD") == 0);
|
||||
|
||||
ret_error = false;
|
||||
ret = CAT_RETURN_STATE_HOLD;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=<X:INT32[RW]>\n\n+CMD=<X:INT32[RW]>\n\ntest\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:+CMD test:+CMD test:+CMD test:+CMD test:+CMD") == 0);
|
||||
|
||||
ret_error = true;
|
||||
ret = CAT_RETURN_STATE_HOLD;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=<X:INT32[RW]>\n\n+CMD=<X:INT32[RW]>\n\ntest\n\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:+CMD test:+CMD test:+CMD test:+CMD test:+CMD") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,236 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char cmd_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x;
|
||||
static struct cat_object at;
|
||||
|
||||
static cat_return_state ret;
|
||||
static bool ret_error;
|
||||
|
||||
static cat_return_state cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(cmd_results, " read:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
var_x++;
|
||||
if (var_x > 5) {
|
||||
ret = (ret_error == false) ? CAT_RETURN_STATE_HOLD_EXIT_OK : CAT_RETURN_STATE_HOLD_EXIT_ERROR;
|
||||
} else {
|
||||
if (var_x == 5) {
|
||||
strcpy(data, "test");
|
||||
*data_size = strlen(data);
|
||||
}
|
||||
ret = CAT_RETURN_STATE_DATA_NEXT;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static cat_return_state cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(cmd_results, " write:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
if ((ret == CAT_RETURN_STATE_DATA_NEXT) || (ret == CAT_RETURN_STATE_NEXT)) {
|
||||
var_x++;
|
||||
if (var_x > 3)
|
||||
ret = CAT_RETURN_STATE_DATA_OK;
|
||||
} else if (ret == CAT_RETURN_STATE_HOLD) {
|
||||
cat_trigger_unsolicited_read(&at, cmd);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x)
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.write = cmd_write,
|
||||
.read = cmd_read,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
var_x = 1;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(cmd_results, 0, sizeof(cmd_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD=2\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
ret = CAT_RETURN_STATE_ERROR;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
ret = CAT_RETURN_STATE_DATA_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
ret = CAT_RETURN_STATE_DATA_NEXT;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD write:+CMD") == 0);
|
||||
assert(var_x == 4);
|
||||
|
||||
ret = CAT_RETURN_STATE_NEXT;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD write:+CMD") == 0);
|
||||
assert(var_x == 4);
|
||||
|
||||
ret = CAT_RETURN_STATE_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
ret_error = false;
|
||||
ret = CAT_RETURN_STATE_HOLD;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=2\n\n+CMD=3\n\ntest\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD read:+CMD read:+CMD read:+CMD read:+CMD") == 0);
|
||||
assert(var_x == 6);
|
||||
|
||||
ret_error = true;
|
||||
ret = CAT_RETURN_STATE_HOLD;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+CMD=2\n\n+CMD=3\n\ntest\n\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD read:+CMD read:+CMD read:+CMD read:+CMD") == 0);
|
||||
assert(var_x == 6);
|
||||
|
||||
ret = CAT_RETURN_STATE_HOLD_EXIT_ERROR;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
ret = CAT_RETURN_STATE_HOLD_EXIT_OK;
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " write:+CMD") == 0);
|
||||
assert(var_x == 2);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,157 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char run_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int a_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " A:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " AP:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " +TEST:");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int force_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " FORCE:");
|
||||
strcat(run_results, cmd->name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "A",
|
||||
.run = a_run
|
||||
},
|
||||
{
|
||||
.name = "AP",
|
||||
.run = ap_run
|
||||
},
|
||||
{
|
||||
.name = "+TEST",
|
||||
.run = test_run
|
||||
},
|
||||
{
|
||||
.name = "+EMPTY"
|
||||
},
|
||||
{
|
||||
.name = "FORCE",
|
||||
.run = force_run,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(run_results, 0, sizeof(run_results));
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT\nAT+\nATA\r\nATAP\nATAPA\nAT+TEST\nAT+te\nAT+e\nAT+empTY\naTf\nAtFoRcE\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nERROR\n\r\nOK\r\n\nOK\n\nERROR\n\nOK\n\nOK\n\nERROR\n\nERROR\n\nERROR\n\nERROR\n") == 0);
|
||||
assert(strcmp(run_results, " A:A AP:AP +TEST:+TEST +TEST:+TEST FORCE:FORCE FORCE:FORCE") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,224 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static int ap_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable vars_ap1[] = {
|
||||
{
|
||||
.name = "var_ap1_1"
|
||||
},
|
||||
{
|
||||
.name = "var_ap1_2"
|
||||
},
|
||||
{
|
||||
.name = "var_ap1_3"
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars_apx2[] = {
|
||||
{
|
||||
.name = "var_apx2_1"
|
||||
},
|
||||
{
|
||||
.name = "var_apx2_2"
|
||||
},
|
||||
{
|
||||
.name = "var_apx2_3"
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "AP1",
|
||||
.write = ap_write,
|
||||
.only_test = true,
|
||||
.var = vars_ap1,
|
||||
.var_num = sizeof(vars_ap1) / sizeof(vars_ap1[0])
|
||||
},
|
||||
{
|
||||
.name = "AP2",
|
||||
.read = ap_read,
|
||||
.only_test = false
|
||||
},
|
||||
};
|
||||
|
||||
static struct cat_command cmds2[] = {
|
||||
{
|
||||
.name = "APX1",
|
||||
.write = ap_write,
|
||||
.only_test = true
|
||||
},
|
||||
{
|
||||
.name = "APX2",
|
||||
.read = ap_read,
|
||||
.only_test = false,
|
||||
.var = vars_apx2,
|
||||
.var_num = sizeof(vars_apx2) / sizeof(vars_apx2[0])
|
||||
},
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group1 = {
|
||||
.name = "std",
|
||||
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group cmd_group2 = {
|
||||
.name = "ext",
|
||||
|
||||
.cmd = cmds2,
|
||||
.cmd_num = sizeof(cmds2) / sizeof(cmds2[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group1,
|
||||
&cmd_group2
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
struct cat_command const *cmd;
|
||||
struct cat_command_group const *cmd_group;
|
||||
struct cat_variable const *var;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
cmd = cat_search_command_by_name(&at, "A");
|
||||
assert(cmd == NULL);
|
||||
|
||||
cmd = cat_search_command_by_name(&at, "AP");
|
||||
assert(cmd == NULL);
|
||||
|
||||
cmd = cat_search_command_by_name(&at, "AP1");
|
||||
assert(cmd == &cmds[0]);
|
||||
|
||||
cmd = cat_search_command_by_name(&at, "AP2");
|
||||
assert(cmd == &cmds[1]);
|
||||
|
||||
cmd = cat_search_command_by_name(&at, "AP3");
|
||||
assert(cmd == NULL);
|
||||
|
||||
cmd = cat_search_command_by_name(&at, "APX1");
|
||||
assert(cmd == &cmds2[0]);
|
||||
|
||||
cmd = cat_search_command_by_name(&at, "APX2");
|
||||
assert(cmd == &cmds2[1]);
|
||||
|
||||
cmd = cat_search_command_by_name(&at, "APX3");
|
||||
assert(cmd == NULL);
|
||||
|
||||
cmd_group = cat_search_command_group_by_name(&at, "std");
|
||||
assert(cmd_group == cmd_desc[0]);
|
||||
|
||||
cmd_group = cat_search_command_group_by_name(&at, "ext");
|
||||
assert(cmd_group == cmd_desc[1]);
|
||||
|
||||
cmd_group = cat_search_command_group_by_name(&at, "not");
|
||||
assert(cmd_group == NULL);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds[0], "v");
|
||||
assert(var == NULL);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds[0], "var_ap");
|
||||
assert(var == NULL);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds[0], "var_apx2");
|
||||
assert(var == NULL);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds[0], "var_ap1_1");
|
||||
assert(var == &vars_ap1[0]);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds[0], "var_ap1_2");
|
||||
assert(var == &vars_ap1[1]);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds[0], "var_ap1_3");
|
||||
assert(var == &vars_ap1[2]);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds[0], "var_ap1_4");
|
||||
assert(var == NULL);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds[1], "var_ap1_1");
|
||||
assert(var == NULL);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds2[1], "var_apx2_1");
|
||||
assert(var == &vars_apx2[0]);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds2[1], "var_apx2_2");
|
||||
assert(var == &vars_apx2[1]);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds2[1], "var_apx2_3");
|
||||
assert(var == &vars_apx2[2]);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds2[1], "var_apx2_4");
|
||||
assert(var == NULL);
|
||||
|
||||
var = cat_search_variable_by_name(&at, &cmds2[0], "var_apx2_1");
|
||||
assert(var == NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,149 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char run_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int print_name(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, cmd->name);
|
||||
strcat(run_results, " ");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+TEST",
|
||||
.run = print_name
|
||||
},
|
||||
{
|
||||
.name = "+TEST_A",
|
||||
.run = print_name
|
||||
},
|
||||
{
|
||||
.name = "+TEST_B",
|
||||
.run = print_name
|
||||
},
|
||||
{
|
||||
.name = "+ONE",
|
||||
.run = print_name
|
||||
},
|
||||
{
|
||||
.name = "+TWO",
|
||||
.run = print_name
|
||||
},
|
||||
};
|
||||
|
||||
static char buf[256];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(run_results, 0, sizeof(run_results));
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT\nAT+\nAT+T\nAT+TE\nAT+TES\nAT+TEST\nAT+TEST_\nAT+TEST_A\nAT+TEST_B\nAT+O\nAT+ON\nAT+ONE\nAT+TW\nAT+TWO\n";
|
||||
|
||||
static void print_raw_text(char *p)
|
||||
{
|
||||
while (*p != '\0') {
|
||||
if (*p == '\n') {
|
||||
printf("\\n");
|
||||
} else {
|
||||
putchar(*p);
|
||||
}
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nERROR\n\nERROR\n\nERROR\n\nERROR\n\nOK\n\nERROR\n\nOK\n\nOK\n\nOK\n\nOK\n\nOK\n\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(run_results, "+TEST +TEST_A +TEST_B +ONE +ONE +ONE +TWO +TWO ") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,183 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char test_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int a_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(test_results, " A:");
|
||||
strcat(test_results, cmd->name);
|
||||
|
||||
snprintf(data, max_data_size, "%s=A-val", cmd->name);
|
||||
*data_size = strlen(data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(test_results, " AP:");
|
||||
strcat(test_results, cmd->name);
|
||||
|
||||
*data_size = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(test_results, " AP_W:");
|
||||
strcat(test_results, cmd->name);
|
||||
|
||||
assert(args_num == 0);
|
||||
assert(data[0] == 'a');
|
||||
assert(data_size == 1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apw_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(test_results, " APW:");
|
||||
strcat(test_results, cmd->name);
|
||||
|
||||
assert(args_num == 0);
|
||||
assert(data[0] == '?');
|
||||
assert(data_size == 1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(test_results, " +TEST:");
|
||||
strcat(test_results, cmd->name);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "A",
|
||||
.test = a_test
|
||||
},
|
||||
{
|
||||
.name = "AP",
|
||||
.test = ap_test,
|
||||
.write = ap_write
|
||||
},
|
||||
{
|
||||
.name = "APW",
|
||||
.write = apw_write
|
||||
},
|
||||
{
|
||||
.name = "+TEST",
|
||||
.test = test_test
|
||||
},
|
||||
{
|
||||
.name = "+EMPTY"
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(test_results, 0, sizeof(test_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT\r\nAT\nATAP=?\nATAP=?a\nATAP=a\nATAPW=?\nAT+TEST=?\nATA=?\nAT+EMPTY=?\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\r\nOK\r\n\nOK\n\nAP=\n\nOK\n\nERROR\n\nOK\n\nOK\n\nERROR\n\nA=A-val\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(test_results, " AP:AP AP_W:AP APW:APW +TEST:+TEST A:A") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,459 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char ack_results[256];
|
||||
|
||||
static int8_t var_int8;
|
||||
static int16_t var_int16;
|
||||
static int32_t var_int32;
|
||||
static uint8_t var_uint8;
|
||||
static uint16_t var_uint16;
|
||||
static uint32_t var_uint32;
|
||||
static uint8_t var_hex8;
|
||||
static uint16_t var_hex16;
|
||||
static uint32_t var_hex32;
|
||||
static uint8_t var_buf[4];
|
||||
static char var_string[16];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int cmd_override_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(data, "\ntest");
|
||||
*data_size = strlen(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_error_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int cmd_ok_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcpy(data, "test1");
|
||||
*data_size = strlen(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_ok2_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(data, "test2");
|
||||
*data_size = strlen(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int8,
|
||||
.data_size = sizeof(var_int8),
|
||||
.name = "x"
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int16,
|
||||
.data_size = sizeof(var_int16),
|
||||
.name = "y"
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int32,
|
||||
.data_size = sizeof(var_int32)
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint8,
|
||||
.data_size = sizeof(var_uint8)
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint16,
|
||||
.data_size = sizeof(var_uint16)
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint32,
|
||||
.data_size = sizeof(var_uint32)
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex8,
|
||||
.data_size = sizeof(var_hex8)
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex16,
|
||||
.data_size = sizeof(var_hex16)
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex32,
|
||||
.data_size = sizeof(var_hex32)
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_HEX,
|
||||
.data = &var_buf,
|
||||
.data_size = sizeof(var_buf)
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = &var_string,
|
||||
.data_size = sizeof(var_string),
|
||||
.name = "msg"
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars_ro[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int8,
|
||||
.data_size = sizeof(var_int8),
|
||||
.name = "x",
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int16,
|
||||
.data_size = sizeof(var_int16),
|
||||
.name = "y",
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int32,
|
||||
.data_size = sizeof(var_int32),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint8,
|
||||
.data_size = sizeof(var_uint8),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint16,
|
||||
.data_size = sizeof(var_uint16),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint32,
|
||||
.data_size = sizeof(var_uint32),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex8,
|
||||
.data_size = sizeof(var_hex8),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex16,
|
||||
.data_size = sizeof(var_hex16),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex32,
|
||||
.data_size = sizeof(var_hex32),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_HEX,
|
||||
.data = &var_buf,
|
||||
.data_size = sizeof(var_buf),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = &var_string,
|
||||
.data_size = sizeof(var_string),
|
||||
.name = "msg",
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars_wo[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int8,
|
||||
.data_size = sizeof(var_int8),
|
||||
.name = "x",
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int16,
|
||||
.data_size = sizeof(var_int16),
|
||||
.name = "y",
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int32,
|
||||
.data_size = sizeof(var_int32),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint8,
|
||||
.data_size = sizeof(var_uint8),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint16,
|
||||
.data_size = sizeof(var_uint16),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint32,
|
||||
.data_size = sizeof(var_uint32),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex8,
|
||||
.data_size = sizeof(var_hex8),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex16,
|
||||
.data_size = sizeof(var_hex16),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex32,
|
||||
.data_size = sizeof(var_hex32),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_HEX,
|
||||
.data = &var_buf,
|
||||
.data_size = sizeof(var_buf),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = &var_string,
|
||||
.data_size = sizeof(var_string),
|
||||
.name = "msg",
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars2[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int8,
|
||||
.data_size = sizeof(var_int8),
|
||||
.name = "var"
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+SET",
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+SETRO",
|
||||
|
||||
.var = vars_ro,
|
||||
.var_num = sizeof(vars_ro) / sizeof(vars_ro[0])
|
||||
},
|
||||
{
|
||||
.name = "+SETWO",
|
||||
|
||||
.var = vars_wo,
|
||||
.var_num = sizeof(vars_wo) / sizeof(vars_wo[0])
|
||||
},
|
||||
{
|
||||
.name = "+TEST",
|
||||
.description = "test_desc",
|
||||
.test = cmd_override_test,
|
||||
|
||||
.var = vars2,
|
||||
.var_num = sizeof(vars2) / sizeof(vars2[0])
|
||||
},
|
||||
{
|
||||
.name = "+TEST2",
|
||||
.description = "test2_desc",
|
||||
|
||||
.var = vars2,
|
||||
.var_num = sizeof(vars2) / sizeof(vars2[0])
|
||||
},
|
||||
{
|
||||
.name = "+AP",
|
||||
.test = cmd_error_test,
|
||||
|
||||
.var = vars2,
|
||||
.var_num = sizeof(vars2) / sizeof(vars2[0])
|
||||
},
|
||||
{
|
||||
.name = "+ZZ",
|
||||
.test = cmd_ok_test,
|
||||
},
|
||||
{
|
||||
.name = "+ZZ2",
|
||||
.description = "zz2_desc",
|
||||
.test = cmd_ok_test,
|
||||
},
|
||||
{
|
||||
.name = "+ZZ3",
|
||||
.description = "zz3_desc",
|
||||
.test = cmd_ok2_test,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[256];
|
||||
static char unsolicited_buf[256];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
.unsolicited_buf = unsolicited_buf,
|
||||
.unsolicited_buf_size = sizeof(unsolicited_buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var_int8 = -8;
|
||||
var_int16 = -16;
|
||||
var_int32 = -32;
|
||||
var_uint8 = 8;
|
||||
var_uint8 = 16;
|
||||
var_uint8 = 32;
|
||||
var_hex8 = 0x08;
|
||||
var_hex16 = 0x16;
|
||||
var_hex32 = 0x32;
|
||||
var_hex16 = 0x0123;
|
||||
var_hex32 = 0xFF001234;
|
||||
|
||||
var_buf[0] = 0x12;
|
||||
var_buf[1] = 0x34;
|
||||
var_buf[2] = 0x56;
|
||||
var_buf[3] = 0x78;
|
||||
|
||||
sprintf(var_string, "TST");
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+SET=?\n";
|
||||
static const char test_case_1_ro[] = "\nAT+SETRO=?\n";
|
||||
static const char test_case_1_wo[] = "\nAT+SETWO=?\n";
|
||||
static const char test_case_2[] = "\nAT+TEST=?\nAT+TEST2=?\r\nAT+AP=?\n";
|
||||
static const char test_case_3[] = "\nAT+ZZ=?\nAT+ZZ2=?\nAT+ZZ3=?\r\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+SET=<x:INT8[RW]>,<y:INT16[RW]>,<INT32[RW]>,<UINT8[RW]>,<UINT16[RW]>,<UINT32[RW]>,<HEX8[RW]>,<HEX16[RW]>,<HEX32[RW]>,<HEXBUF[RW]>,<msg:STRING[RW]>\n\nOK\n") == 0);
|
||||
|
||||
prepare_input(test_case_1_ro);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+SETRO=<x:INT8[RO]>,<y:INT16[RO]>,<INT32[RO]>,<UINT8[RO]>,<UINT16[RO]>,<UINT32[RO]>,<HEX8[RO]>,<HEX16[RO]>,<HEX32[RO]>,<HEXBUF[RO]>,<msg:STRING[RO]>\n\nOK\n") == 0);
|
||||
|
||||
prepare_input(test_case_1_wo);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+SETWO=<x:INT8[WO]>,<y:INT16[WO]>,<INT32[WO]>,<UINT8[WO]>,<UINT16[WO]>,<UINT32[WO]>,<HEX8[WO]>,<HEX16[WO]>,<HEX32[WO]>,<HEXBUF[WO]>,<msg:STRING[WO]>\n\nOK\n") == 0);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+TEST=<var:INT8[RW]>\ntest_desc\ntest\n\nOK\n\r\n+TEST2=<var:INT8[RW]>\r\ntest2_desc\r\n\r\nOK\r\n\nERROR\n") == 0);
|
||||
|
||||
prepare_input(test_case_3);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\ntest1\n\nOK\n\ntest1\n\nOK\n\r\n+ZZ3=\r\nzz3_desctest2\r\n\r\nOK\r\n") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,173 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char cmd_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int ap_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(cmd_results, " test:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
strcpy(data, "ap_test");
|
||||
*data_size = strlen(data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(cmd_results, " run:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
strcat(cmd_results, " read:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
strcpy(data, "ap_read");
|
||||
*data_size = strlen(data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(cmd_results, " write:");
|
||||
strcat(cmd_results, cmd->name);
|
||||
|
||||
assert(strcmp(data, "1") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "AP1",
|
||||
.test = ap_test,
|
||||
.write = ap_write,
|
||||
.read = ap_read,
|
||||
.run = ap_run,
|
||||
.only_test = true
|
||||
},
|
||||
{
|
||||
.name = "AP2",
|
||||
.test = ap_test,
|
||||
.write = ap_write,
|
||||
.read = ap_read,
|
||||
.run = ap_run,
|
||||
.only_test = false
|
||||
},
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(cmd_results, 0, sizeof(cmd_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nATAP1=?\n\nATAP1?\n\nATAP1=1\n\nATAP1\n";
|
||||
static const char test_case_2[] = "\nATAP2=?\n\nATAP2?\n\nATAP2=1\n\nATAP2\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nap_test\n\nOK\n\nERROR\n\nERROR\n\nERROR\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:AP1") == 0);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nap_test\n\nOK\n\nap_read\n\nOK\n\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(cmd_results, " test:AP2 read:AP2 write:AP2 run:AP2") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,203 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char read_results[256];
|
||||
static char var_read_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x, var_u1, var_u2;
|
||||
static struct cat_object at;
|
||||
|
||||
static struct cat_command u_cmds[];
|
||||
|
||||
static cat_return_state cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
strcat(read_results, " read:");
|
||||
strcat(read_results, cmd->name);
|
||||
|
||||
if (strcmp(cmd->name, "+CMD") == 0) {
|
||||
s = cat_trigger_unsolicited_read(&at, &u_cmds[1]);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
}
|
||||
|
||||
return CAT_RETURN_STATE_DATA_OK;
|
||||
}
|
||||
|
||||
static int var_read(const struct cat_variable *var)
|
||||
{
|
||||
strcat(var_read_results, " var_read:");
|
||||
strcat(var_read_results, var->name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable u_vars[] = {
|
||||
{
|
||||
.name = "U1",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u1,
|
||||
.data_size = sizeof(var_u1),
|
||||
.read = var_read
|
||||
},
|
||||
{
|
||||
.name = "U2",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u2,
|
||||
.data_size = sizeof(var_u2),
|
||||
.read = var_read
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x),
|
||||
.read = var_read
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.read = cmd_read,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command u_cmds[] = {
|
||||
{
|
||||
.name = "+U1CMD",
|
||||
.read = cmd_read,
|
||||
.var = &u_vars[0],
|
||||
.var_num = 1,
|
||||
},
|
||||
{
|
||||
.name = "+U2CMD",
|
||||
.read = cmd_read,
|
||||
.var = &u_vars[1],
|
||||
.var_num = 1,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var_x = 1;
|
||||
var_u1 = 2;
|
||||
var_u2 = 3;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(read_results, 0, sizeof(read_results));
|
||||
memset(var_read_results, 0, sizeof(var_read_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD?\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_trigger_unsolicited_event(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
assert(s == CAT_STATUS_ERROR_BUFFER_FULL);
|
||||
s = cat_trigger_unsolicited_read(&at, &u_cmds[1]);
|
||||
assert(s == CAT_STATUS_ERROR_BUFFER_FULL);
|
||||
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+U1CMD=2\n\n+CMD=1\n\n+U2CMD=3\n\nOK\n") == 0);
|
||||
assert(strcmp(read_results, " read:+U1CMD read:+CMD read:+U2CMD") == 0);
|
||||
assert(strcmp(var_read_results, " var_read:U1 var_read:X var_read:U2") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,238 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char read_results[256];
|
||||
static char var_read_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x, var_u1, var_u2;
|
||||
static struct cat_object at;
|
||||
|
||||
static struct cat_command u_cmds[];
|
||||
|
||||
static cat_return_state cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
strcat(read_results, " read:");
|
||||
strcat(read_results, cmd->name);
|
||||
|
||||
if (strcmp(cmd->name, "+CMD") == 0) {
|
||||
s = cat_trigger_unsolicited_read(&at, &u_cmds[1]);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
}
|
||||
|
||||
return CAT_RETURN_STATE_DATA_OK;
|
||||
}
|
||||
|
||||
static int var_read(const struct cat_variable *var)
|
||||
{
|
||||
strcat(var_read_results, " var_read:");
|
||||
strcat(var_read_results, var->name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable u_vars[] = {
|
||||
{
|
||||
.name = "U1",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u1,
|
||||
.data_size = sizeof(var_u1),
|
||||
.read = var_read
|
||||
},
|
||||
{
|
||||
.name = "U2",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u2,
|
||||
.data_size = sizeof(var_u2),
|
||||
.read = var_read
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x),
|
||||
.read = var_read
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.read = cmd_read,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command u_cmds[] = {
|
||||
{
|
||||
.name = "+U1CMD",
|
||||
.read = cmd_read,
|
||||
.var = &u_vars[0],
|
||||
.var_num = 1,
|
||||
},
|
||||
{
|
||||
.name = "+U2CMD",
|
||||
.read = cmd_read,
|
||||
.var = &u_vars[1],
|
||||
.var_num = 1,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var_x = 1;
|
||||
var_u1 = 2;
|
||||
var_u2 = 3;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(read_results, 0, sizeof(read_results));
|
||||
memset(var_read_results, 0, sizeof(var_read_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD?\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_NONE);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_trigger_unsolicited_event(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_TEST);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_NONE);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_trigger_unsolicited_event(&at, &u_cmds[1], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_TEST);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_NONE);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[1], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[1], CAT_CMD_TYPE_TEST);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[1], CAT_CMD_TYPE_NONE);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
assert(s == CAT_STATUS_ERROR_BUFFER_FULL);
|
||||
s = cat_trigger_unsolicited_read(&at, &u_cmds[1]);
|
||||
assert(s == CAT_STATUS_ERROR_BUFFER_FULL);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_TEST);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[1], CAT_CMD_TYPE_NONE);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+U1CMD=2\n\n+CMD=1\n\n+U2CMD=3\n\nOK\n\n+U2CMD=3\n") == 0);
|
||||
assert(strcmp(read_results, " read:+U1CMD read:+CMD read:+U2CMD read:+U2CMD") == 0);
|
||||
assert(strcmp(var_read_results, " var_read:U1 var_read:X var_read:U2 var_read:U2") == 0);
|
||||
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,211 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char read_results[256];
|
||||
static char var_read_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x, var_u1;
|
||||
static struct cat_object at;
|
||||
|
||||
static struct cat_command u_cmds[];
|
||||
|
||||
static cat_return_state cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
strcat(read_results, " read:");
|
||||
strcat(read_results, cmd->name);
|
||||
|
||||
return CAT_RETURN_STATE_DATA_OK;
|
||||
}
|
||||
|
||||
static int var_read(const struct cat_variable *var)
|
||||
{
|
||||
strcat(var_read_results, " var_read:");
|
||||
strcat(var_read_results, var->name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable u_vars[] = {
|
||||
{
|
||||
.name = "U1",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u1,
|
||||
.data_size = sizeof(var_u1),
|
||||
.read = var_read
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x),
|
||||
.read = var_read
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.read = cmd_read,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command u_cmds[] = {
|
||||
{
|
||||
.name = "+UCMD",
|
||||
.read = cmd_read,
|
||||
.var = u_vars,
|
||||
.var_num = sizeof(u_vars) / sizeof(u_vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var_x = 1;
|
||||
var_u1 = 2;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(read_results, 0, sizeof(read_results));
|
||||
memset(var_read_results, 0, sizeof(var_read_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD?\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
int events = 4;
|
||||
struct cat_command const *cmd;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
|
||||
cmd = cat_get_processed_command(&at, CAT_FSM_TYPE_ATCMD);
|
||||
assert(cmd == NULL);
|
||||
cmd = cat_get_processed_command(&at, CAT_FSM_TYPE_UNSOLICITED);
|
||||
assert(cmd == NULL);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_NONE);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
|
||||
while (events > 0) {
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
cmd = cat_get_processed_command(&at, CAT_FSM_TYPE_UNSOLICITED);
|
||||
if ((s == CAT_STATUS_OK) && (cmd == NULL)) {
|
||||
var_u1 = events;
|
||||
s = cat_trigger_unsolicited_event(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
events--;
|
||||
} else {
|
||||
assert(cmd == &u_cmds[0]);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_READ);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_TEST);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_event_buffered(&at, &u_cmds[0], CAT_CMD_TYPE_NONE);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
}
|
||||
s = cat_service(&at);
|
||||
assert(s == CAT_STATUS_BUSY);
|
||||
}
|
||||
|
||||
while (cat_service(&at) != 0) {};
|
||||
cmd = cat_get_processed_command(&at, CAT_FSM_TYPE_ATCMD);
|
||||
assert(cmd == NULL);
|
||||
cmd = cat_get_processed_command(&at, CAT_FSM_TYPE_UNSOLICITED);
|
||||
assert(cmd == NULL);
|
||||
|
||||
assert(strcmp(ack_results, "\n+UCMD=4\n\n+CMD=1\n\n+UCMD=3\n\nOK\n\n+UCMD=2\n\n+UCMD=1\n") == 0);
|
||||
assert(strcmp(read_results, " read:+UCMD read:+CMD read:+UCMD read:+UCMD read:+UCMD") == 0);
|
||||
assert(strcmp(var_read_results, " var_read:U1 var_read:X var_read:U1 var_read:U1 var_read:U1") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,189 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char read_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var_x, var_u1, var_u2;
|
||||
static struct cat_object at;
|
||||
|
||||
static struct cat_command u_cmds[];
|
||||
|
||||
static cat_return_state cmd_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
strcat(read_results, " test:");
|
||||
strcat(read_results, cmd->name);
|
||||
|
||||
if (strcmp(cmd->name, "+CMD") == 0) {
|
||||
s = cat_trigger_unsolicited_test(&at, &u_cmds[1]);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
}
|
||||
|
||||
return CAT_RETURN_STATE_DATA_OK;
|
||||
}
|
||||
|
||||
static struct cat_variable u_vars[] = {
|
||||
{
|
||||
.name = "U1",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u1,
|
||||
.data_size = sizeof(var_u1)
|
||||
},
|
||||
{
|
||||
.name = "U2",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_u2,
|
||||
.data_size = sizeof(var_u2)
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.name = "X",
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_x,
|
||||
.data_size = sizeof(var_x)
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+CMD",
|
||||
.test = cmd_test,
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command u_cmds[] = {
|
||||
{
|
||||
.name = "+U1CMD",
|
||||
.test = cmd_test,
|
||||
.var = &u_vars[0],
|
||||
.var_num = 1,
|
||||
},
|
||||
{
|
||||
.name = "+U2CMD",
|
||||
.test = cmd_test,
|
||||
.var = &u_vars[1],
|
||||
.var_num = 1,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var_x = 1;
|
||||
var_u1 = 2;
|
||||
var_u2 = 3;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(read_results, 0, sizeof(read_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+CMD=?\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cat_status s;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_trigger_unsolicited_event(&at, &u_cmds[0], CAT_CMD_TYPE_TEST);
|
||||
assert(s == CAT_STATUS_OK);
|
||||
s = cat_is_unsolicited_buffer_full(&at);
|
||||
assert(s == CAT_STATUS_ERROR_BUFFER_FULL);
|
||||
s = cat_trigger_unsolicited_test(&at, &u_cmds[1]);
|
||||
assert(s == CAT_STATUS_ERROR_BUFFER_FULL);
|
||||
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+U1CMD=<U1:INT32[RW]>\n\n+CMD=<X:INT32[RW]>\n\n+U2CMD=<U2:INT32[RW]>\n\nOK\n") == 0);
|
||||
assert(strcmp(read_results, " test:+U1CMD test:+CMD test:+U2CMD") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,545 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char ack_results[256];
|
||||
|
||||
static int8_t var1;
|
||||
static int8_t var2;
|
||||
static int8_t var3;
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int var2_write_cntr;
|
||||
static int var3_read_cntr;
|
||||
|
||||
static int8_t var_int8;
|
||||
static int16_t var_int16;
|
||||
static int32_t var_int32;
|
||||
static uint8_t var_uint8;
|
||||
static uint16_t var_uint16;
|
||||
static uint32_t var_uint32;
|
||||
static uint8_t var_hex8;
|
||||
static uint16_t var_hex16;
|
||||
static uint32_t var_hex32;
|
||||
static uint8_t var_buf[4];
|
||||
static char var_string[16];
|
||||
|
||||
static int cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_read(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_test(const struct cat_command *cmd, uint8_t *data, size_t *data_size, const size_t max_data_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_run(const struct cat_command *cmd)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var1_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var1_read(const struct cat_variable *var)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var2_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
var2_write_cntr++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var2_read(const struct cat_variable *var)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var3_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var3_read(const struct cat_variable *var)
|
||||
{
|
||||
var3_read_cntr++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int print_cmd_list(const struct cat_command *cmd)
|
||||
{
|
||||
return CAT_RETURN_STATE_PRINT_CMD_LIST_OK;
|
||||
}
|
||||
|
||||
static struct cat_variable vars_ro[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write,
|
||||
.read = var2_read,
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars_wo[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var3,
|
||||
.data_size = sizeof(var3),
|
||||
.write = var3_write,
|
||||
.read = var3_read,
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write,
|
||||
.read = var1_read,
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write,
|
||||
.read = var2_read,
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var3,
|
||||
.data_size = sizeof(var3),
|
||||
.write = var3_write,
|
||||
.read = var3_read,
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars_misc_ro[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int8,
|
||||
.data_size = sizeof(var_int8),
|
||||
.name = "x",
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int16,
|
||||
.data_size = sizeof(var_int16),
|
||||
.name = "y",
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int32,
|
||||
.data_size = sizeof(var_int32),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint8,
|
||||
.data_size = sizeof(var_uint8),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint16,
|
||||
.data_size = sizeof(var_uint16),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint32,
|
||||
.data_size = sizeof(var_uint32),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex8,
|
||||
.data_size = sizeof(var_hex8),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex16,
|
||||
.data_size = sizeof(var_hex16),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex32,
|
||||
.data_size = sizeof(var_hex32),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_HEX,
|
||||
.data = &var_buf,
|
||||
.data_size = sizeof(var_buf),
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = &var_string,
|
||||
.data_size = sizeof(var_string),
|
||||
.name = "msg",
|
||||
.access = CAT_VAR_ACCESS_READ_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_variable vars_misc_wo[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.access = CAT_VAR_ACCESS_READ_WRITE
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int8,
|
||||
.data_size = sizeof(var_int8),
|
||||
.name = "x",
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int16,
|
||||
.data_size = sizeof(var_int16),
|
||||
.name = "y",
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var_int32,
|
||||
.data_size = sizeof(var_int32),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint8,
|
||||
.data_size = sizeof(var_uint8),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint16,
|
||||
.data_size = sizeof(var_uint16),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var_uint32,
|
||||
.data_size = sizeof(var_uint32),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex8,
|
||||
.data_size = sizeof(var_hex8),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex16,
|
||||
.data_size = sizeof(var_hex16),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var_hex32,
|
||||
.data_size = sizeof(var_hex32),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_HEX,
|
||||
.data = &var_buf,
|
||||
.data_size = sizeof(var_buf),
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = &var_string,
|
||||
.data_size = sizeof(var_string),
|
||||
.name = "msg",
|
||||
.access = CAT_VAR_ACCESS_WRITE_ONLY
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+VRW",
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+VRO",
|
||||
.var = vars_ro,
|
||||
.var_num = sizeof(vars_ro) / sizeof(vars_ro[0])
|
||||
},
|
||||
{
|
||||
.name = "+VWO",
|
||||
.var = vars_wo,
|
||||
.var_num = sizeof(vars_wo) / sizeof(vars_wo[0])
|
||||
},
|
||||
{
|
||||
.name = "+MRO",
|
||||
.var = vars_misc_ro,
|
||||
.var_num = sizeof(vars_misc_ro) / sizeof(vars_misc_ro[0])
|
||||
},
|
||||
{
|
||||
.name = "+MWO",
|
||||
.var = vars_misc_wo,
|
||||
.var_num = sizeof(vars_misc_wo) / sizeof(vars_misc_wo[0])
|
||||
},
|
||||
{
|
||||
.name = "#HELP",
|
||||
.run = print_cmd_list,
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[256];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
}
|
||||
|
||||
static void print_raw_text(char *p)
|
||||
{
|
||||
while (*p != '\0') {
|
||||
if (*p == '\n') {
|
||||
printf("\\n");
|
||||
} else {
|
||||
putchar(*p);
|
||||
}
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input("\nAT#HELP\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nAT+VRW?\nAT+VRW=\nAT+VRW=?\n\nAT+VRO?\nAT+VRO=?\n\nAT+VWO=\nAT+VWO=?\n\nAT+MRO?\nAT+MRO=\nAT+MRO=?\n\nAT+MWO?\nAT+MWO=\nAT+MWO=?\n\nAT#HELP\n\nOK\n") == 0);
|
||||
|
||||
prepare_input("\nAT+VRW=?\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+VRW=<INT8[RW]>,<INT8[RO]>,<INT8[WO]>\n\nOK\n") == 0);
|
||||
|
||||
prepare_input("\nAT+VRO=?\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+VRO=<INT8[RO]>\n\nOK\n") == 0);
|
||||
|
||||
prepare_input("\nAT+VWO=?\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+VWO=<INT8[WO]>\n\nOK\n") == 0);
|
||||
|
||||
var2 = 1;
|
||||
prepare_input("\nAT+VRO=1\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(var2 == 1);
|
||||
|
||||
var3 = 3;
|
||||
prepare_input("\nAT+VWO?\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n") == 0);
|
||||
assert(var3 == 3);
|
||||
|
||||
var1 = -1;
|
||||
var2 = -2;
|
||||
var3 = -3;
|
||||
var2_write_cntr = 0;
|
||||
var3_read_cntr = 0;
|
||||
|
||||
prepare_input("\nAT+VRW?\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+VRW=-1,-2,0\n\nOK\n") == 0);
|
||||
assert(var2_write_cntr == 0);
|
||||
assert(var3_read_cntr == 1);
|
||||
|
||||
prepare_input("\nAT+VRW=1,2,3\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(var2_write_cntr == 1);
|
||||
assert(var3_read_cntr == 1);
|
||||
assert(var1 == 1);
|
||||
assert(var2 == -2);
|
||||
assert(var3 == 3);
|
||||
|
||||
var1 = 100;
|
||||
var_int8 = 1;
|
||||
var_int16 = 2;
|
||||
var_int32 = 3;
|
||||
var_uint8 = 4;
|
||||
var_uint16 = 5;
|
||||
var_uint32 = 6;
|
||||
var_hex8 = 7;
|
||||
var_hex16 = 8;
|
||||
var_hex32 = 9;
|
||||
var_buf[0] = 0x10;
|
||||
var_buf[1] = 0x11;
|
||||
var_buf[2] = 0x12;
|
||||
var_buf[3] = 0x13;
|
||||
strcpy(var_string, "test_string");
|
||||
|
||||
prepare_input("\nAT+MWO?\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+MWO=100,0,0,0,0,0,0,0x00,0x0000,0x00000000,00000000,\"\"\n\nOK\n") == 0);
|
||||
|
||||
prepare_input("\nAT+MWO=1,2,3,4,5,6,7,0x08,0x0009,0x0000000A,01020304,\"abc\"\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(var1 == 1);
|
||||
assert(var_int8 == 2);
|
||||
assert(var_int16 == 3);
|
||||
assert(var_int32 == 4);
|
||||
assert(var_uint8 == 5);
|
||||
assert(var_uint16 == 6);
|
||||
assert(var_uint32 == 7);
|
||||
assert(var_hex8 == 8);
|
||||
assert(var_hex16 == 9);
|
||||
assert(var_hex32 == 10);
|
||||
assert(var_buf[0] == 0x01);
|
||||
assert(var_buf[1] == 0x02);
|
||||
assert(var_buf[2] == 0x03);
|
||||
assert(var_buf[3] == 0x04);
|
||||
assert(strcmp(var_string, "abc") == 0);
|
||||
|
||||
prepare_input("\nAT+MRO?\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\n+MRO=1,2,3,4,5,6,7,0x08,0x0009,0x0000000A,01020304,\"abc\"\n\nOK\n") == 0);
|
||||
|
||||
prepare_input("\nAT+MRO=2,0,0,0,0,0,0,0x00,0x0000,0x00000000,00000000,\"cba\"\n");
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n") == 0);
|
||||
assert(var1 == 2);
|
||||
assert(var_int8 == 2);
|
||||
assert(var_int16 == 3);
|
||||
assert(var_int32 == 4);
|
||||
assert(var_uint8 == 5);
|
||||
assert(var_uint16 == 6);
|
||||
assert(var_uint32 == 7);
|
||||
assert(var_hex8 == 8);
|
||||
assert(var_hex16 == 9);
|
||||
assert(var_hex32 == 10);
|
||||
assert(var_buf[0] == 0x01);
|
||||
assert(var_buf[1] == 0x02);
|
||||
assert(var_buf[2] == 0x03);
|
||||
assert(var_buf[3] == 0x04);
|
||||
assert(strcmp(var_string, "abc") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,166 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char run_results[256];
|
||||
static char write_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int a_run(const struct cat_command *cmd)
|
||||
{
|
||||
strcat(run_results, " A_");
|
||||
strcat(run_results, cmd->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int a_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(write_results, " A:");
|
||||
strncat(write_results, data, data_size);
|
||||
|
||||
assert(args_num == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ap_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(write_results, " AP:");
|
||||
strncat(write_results, data, data_size);
|
||||
|
||||
assert(args_num == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(write_results, " +TEST:");
|
||||
strncat(write_results, data, data_size);
|
||||
|
||||
assert(args_num == 0);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "A",
|
||||
.write = a_write,
|
||||
.run = a_run
|
||||
},
|
||||
{
|
||||
.name = "AP",
|
||||
.write = ap_write
|
||||
},
|
||||
{
|
||||
.name = "+TEST",
|
||||
.write = test_write
|
||||
},
|
||||
{
|
||||
.name = "+EMPTY"
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(run_results, 0, sizeof(run_results));
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(write_results, 0, sizeof(write_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT\nAT+\nAT+?\nATA=123\r\nATA=\nATAP?\nATAP=11\r22\r\nAT+TEST=456\nAT+te=789\nAT+e=1\nAT+empTY=2\r\nATA\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nERROR\n\nERROR\n\r\nOK\r\n\nOK\n\nERROR\n\r\nOK\r\n\nERROR\n\nERROR\n\nERROR\n\r\nERROR\r\n\nOK\n") == 0);
|
||||
assert(strcmp(run_results, " A_A") == 0);
|
||||
assert(strcmp(write_results, " A:123 A: AP:1122 +TEST:456 +TEST:789") == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,174 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char write_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static uint8_t var[4];
|
||||
static size_t var_write_size[4];
|
||||
static int var_write_size_index;
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(write_results, " CMD:");
|
||||
strncat(write_results, data, data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
var_write_size[var_write_size_index++] = write_size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_BUF_HEX,
|
||||
.data = var,
|
||||
.data_size = sizeof(var),
|
||||
.write = var_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+SET",
|
||||
.write = cmd_write,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(var, 0, sizeof(var));
|
||||
memset(var_write_size, 0, sizeof(var_write_size));
|
||||
var_write_size_index = 0;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(write_results, 0, sizeof(write_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+SET=0\nAT+SET=aa\nAT+SET=001\nAT+SET=12345678\nAT+SET=ffAA\n";
|
||||
static const char test_case_2[] = "\nAT+SET=0x11\nAT+SET=11\nAT+SET=-1\nAT+SET=87654321\nAT+SET=0001\nAT+SET=1122334455\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nERROR\n\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:aa CMD:12345678 CMD:ffAA") == 0);
|
||||
|
||||
assert(var[0] == 0xFF);
|
||||
assert(var[1] == 0xAA);
|
||||
assert(var[2] == 0x56);
|
||||
assert(var[3] == 0x78);
|
||||
|
||||
assert(var_write_size[0] == 1);
|
||||
assert(var_write_size[1] == 4);
|
||||
assert(var_write_size[2] == 2);
|
||||
assert(var_write_size[3] == 0);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nERROR\n\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:11 CMD:87654321 CMD:0001") == 0);
|
||||
|
||||
assert(var[0] == 0x11);
|
||||
assert(var[1] == 0x22);
|
||||
assert(var[2] == 0x33);
|
||||
assert(var[3] == 0x44);
|
||||
|
||||
assert(var_write_size[0] == 1);
|
||||
assert(var_write_size[1] == 4);
|
||||
assert(var_write_size[2] == 2);
|
||||
assert(var_write_size[3] == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,212 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char write_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static uint8_t var1, var1b;
|
||||
static uint16_t var2, var2b;
|
||||
static uint32_t var3, var3b;
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(write_results, " CMD:");
|
||||
strncat(write_results, data, data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var1_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 1);
|
||||
var1b = *(uint8_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var2_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 2);
|
||||
var2b = *(uint16_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var3_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 4);
|
||||
var3b = *(uint32_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_NUM_HEX,
|
||||
.data = &var3,
|
||||
.data_size = sizeof(var3),
|
||||
.write = var3_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+SET",
|
||||
.write = cmd_write,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var1 = 1;
|
||||
var2 = 2;
|
||||
var3 = 3;
|
||||
var1b = 10;
|
||||
var2b = 20;
|
||||
var3b = 30;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(write_results, 0, sizeof(write_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+SET=0\nAT+SET=0x0\nAT+SET=0x01\nAT+SET=0x0ff\nAT+SET=0x100\n";
|
||||
static const char test_case_2[] = "\nAT+SET=0x,0x00\nAT+SET=0x1,0x00\nAT+SET=0x2,0xFFf\nAT+SET=0x3,0xFFFF\nAT+SET=0x4,0xFFFFF\n";
|
||||
static const char test_case_3[] = "\nAT+SET=0x0,0x0,0\nAT+SET=0x0,0x0,0x0000000000000\nAT+SET=0x0,0x0,0x1\nAT+SET=0x0,0x0,0xffffFFFF\nAT+SET=0x10,0x20,0x100000000\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:0x0 CMD:0x01 CMD:0x0ff") == 0);
|
||||
|
||||
assert(var1 == 255);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 2);
|
||||
assert(var2b == 20);
|
||||
assert(var3 == 3);
|
||||
assert(var3b == 30);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:0x1,0x00 CMD:0x2,0xFFf CMD:0x3,0xFFFF") == 0);
|
||||
|
||||
assert(var1 == 4);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 0xFFFF);
|
||||
assert(var2b == var2);
|
||||
assert(var3 == 3);
|
||||
assert(var3b == 30);
|
||||
|
||||
prepare_input(test_case_3);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:0x0,0x0,0x0000000000000 CMD:0x0,0x0,0x1 CMD:0x0,0x0,0xffffFFFF") == 0);
|
||||
|
||||
assert(var1 == 0x10);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 0x20);
|
||||
assert(var2b == var2);
|
||||
assert(var3 == 0xFFFFFFFF);
|
||||
assert(var3b == var3);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,212 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char write_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static int8_t var1, var1b;
|
||||
static int16_t var2, var2b;
|
||||
static int32_t var3, var3b;
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(write_results, " CMD:");
|
||||
strncat(write_results, data, data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var1_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 1);
|
||||
var1b = *(int8_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var2_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 2);
|
||||
var2b = *(int16_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var3_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 4);
|
||||
var3b = *(int32_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var3,
|
||||
.data_size = sizeof(var3),
|
||||
.write = var3_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+SET",
|
||||
.write = cmd_write,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf),
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var1 = 1;
|
||||
var2 = 2;
|
||||
var3 = 3;
|
||||
var1b = -1;
|
||||
var2b = -2;
|
||||
var3b = -3;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(write_results, 0, sizeof(write_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+SET=-128\nAT+SET=-129\nAT+SET=127\nAT+SET=128\n";
|
||||
static const char test_case_2[] = "\nAT+SET=-128,-32768\nAT+SET=-128,-40000\nAT+SET=-128,32767\nAT+SET=-100,40000\n";
|
||||
static const char test_case_3[] = "\nAT+SET=0,0,-2147483648\nAT+SET=0,0,-2147483649\nAT+SET=1,1,2147483647\nAT+SET=2,2,2147483648\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nERROR\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:-128 CMD:127") == 0);
|
||||
|
||||
assert(var1 == 127);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 2);
|
||||
assert(var2b == -2);
|
||||
assert(var3 == 3);
|
||||
assert(var3b == -3);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nERROR\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:-128,-32768 CMD:-128,32767") == 0);
|
||||
|
||||
assert(var1 == -100);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 32767);
|
||||
assert(var2b == var2);
|
||||
assert(var3 == 3);
|
||||
assert(var3b == -3);
|
||||
|
||||
prepare_input(test_case_3);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nERROR\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:0,0,-2147483648 CMD:1,1,2147483647") == 0);
|
||||
|
||||
assert(var1 == 2);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 2);
|
||||
assert(var2b == var2);
|
||||
assert(var3 == 2147483647);
|
||||
assert(var3b == var3);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,234 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char write_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static int8_t var1, var2, var3;
|
||||
static int8_t var1b, var2b, var3b;
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int cmd_write1(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
char tmp[32];
|
||||
sprintf(tmp, " CMD1_%ld:", args_num);
|
||||
strcat(write_results, tmp);
|
||||
strncat(write_results, data, data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_write3(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
char tmp[32];
|
||||
sprintf(tmp, " CMD3_%ld:", args_num);
|
||||
strcat(write_results, tmp);
|
||||
strncat(write_results, data, data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var1_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 1);
|
||||
var1b = *(int8_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var2_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 1);
|
||||
var2b = *(int8_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var3_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 1);
|
||||
var3b = *(int8_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_INT_DEC,
|
||||
.data = &var3,
|
||||
.data_size = sizeof(var3),
|
||||
.write = var3_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+SET1",
|
||||
.write = cmd_write1,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+SET3",
|
||||
.write = cmd_write3,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
},
|
||||
{
|
||||
.name = "+SETALL",
|
||||
.write = cmd_write3,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0]),
|
||||
.need_all_vars = true
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var1 = 1;
|
||||
var2 = 2;
|
||||
var3 = 3;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(write_results, 0, sizeof(write_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+SET=-10,-20,-30\r\nAT+SET1=-10,-20,-30\r\nAT+SET1=-1\r\n";
|
||||
static const char test_case_2[] = "\nAT+SET3=-1,-2,-3,0\nAT+SET3=-1,-2,-3\nAT+SET3=-100\n";
|
||||
static const char test_case_3[] = "\nAT+SETALL=-11,-22,-33\nAT+SETALL=-1,-2,-3\nAT+SETALL=100\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\r\nERROR\r\n\r\nOK\r\n\r\nOK\r\n") == 0);
|
||||
assert(strcmp(write_results, " CMD1_3:-10,-20,-30 CMD1_1:-1") == 0);
|
||||
|
||||
assert(var1 == -1);
|
||||
assert(var2 == -20);
|
||||
assert(var3 == -30);
|
||||
assert(var1b == -1);
|
||||
assert(var2b == -20);
|
||||
assert(var3b == -30);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(write_results, " CMD3_3:-1,-2,-3 CMD3_1:-100") == 0);
|
||||
|
||||
assert(var1 == -100);
|
||||
assert(var2 == -2);
|
||||
assert(var3 == -3);
|
||||
assert(var1b == -100);
|
||||
assert(var2b == -2);
|
||||
assert(var3b == -3);
|
||||
|
||||
prepare_input(test_case_3);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD3_3:-11,-22,-33 CMD3_3:-1,-2,-3") == 0);
|
||||
|
||||
assert(var1 == 100);
|
||||
assert(var2 == -2);
|
||||
assert(var3 == -3);
|
||||
assert(var1b == 100);
|
||||
assert(var2b == -2);
|
||||
assert(var3b == -3);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,168 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char write_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static uint8_t var[8];
|
||||
static size_t var_write_size[4];
|
||||
static int var_write_size_index;
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(write_results, " CMD:");
|
||||
strncat(write_results, data, data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
var_write_size[var_write_size_index++] = write_size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_BUF_STRING,
|
||||
.data = var,
|
||||
.data_size = sizeof(var),
|
||||
.write = var_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+SET",
|
||||
.write = cmd_write,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
memset(var, 0, sizeof(var));
|
||||
memset(var_write_size, 0, sizeof(var_write_size));
|
||||
var_write_size_index = 0;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(write_results, 0, sizeof(write_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+SET=0\nAT+SET=\"\\\"abcd\\\"\"\nAT+SET=\"\"a\nAT+SET=\"1122334\"\nAT+SET=\"t\"\r\n";
|
||||
static const char test_case_2[] = "\nAT+SET=\"12345678\"\nAT+SET=\"\"\nAT+SET=\"\\\\\\\\\"\nAT+SET=\"r1\\nr2\\n\"\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nERROR\n\nOK\n\r\nOK\r\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:\"\\\"abcd\\\"\" CMD:\"1122334\" CMD:\"t\"") == 0);
|
||||
|
||||
assert(strcmp(var, "t") == 0);
|
||||
|
||||
assert(var_write_size[0] == 6);
|
||||
assert(var_write_size[1] == 7);
|
||||
assert(var_write_size[2] == 1);
|
||||
assert(var_write_size[3] == 0);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nOK\n\nOK\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:\"\" CMD:\"\\\\\\\\\" CMD:\"r1\\nr2\\n\"") == 0);
|
||||
|
||||
assert(strcmp(var, "r1\nr2\n") == 0);
|
||||
|
||||
assert(var_write_size[0] == 0);
|
||||
assert(var_write_size[1] == 2);
|
||||
assert(var_write_size[2] == 6);
|
||||
assert(var_write_size[3] == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,212 +0,0 @@
|
||||
/*
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Marcin Borowicz
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "../src/cat.h"
|
||||
|
||||
static char write_results[256];
|
||||
static char ack_results[256];
|
||||
|
||||
static uint8_t var1, var1b;
|
||||
static uint16_t var2, var2b;
|
||||
static uint32_t var3, var3b;
|
||||
|
||||
static char const *input_text;
|
||||
static size_t input_index;
|
||||
|
||||
static int cmd_write(const struct cat_command *cmd, const uint8_t *data, const size_t data_size, const size_t args_num)
|
||||
{
|
||||
strcat(write_results, " CMD:");
|
||||
strncat(write_results, data, data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var1_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 1);
|
||||
var1b = *(uint8_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var2_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 2);
|
||||
var2b = *(uint16_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int var3_write(const struct cat_variable *var, size_t write_size)
|
||||
{
|
||||
assert(write_size == 4);
|
||||
var3b = *(uint32_t*)(var->data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct cat_variable vars[] = {
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var1,
|
||||
.data_size = sizeof(var1),
|
||||
.write = var1_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var2,
|
||||
.data_size = sizeof(var2),
|
||||
.write = var2_write
|
||||
},
|
||||
{
|
||||
.type = CAT_VAR_UINT_DEC,
|
||||
.data = &var3,
|
||||
.data_size = sizeof(var3),
|
||||
.write = var3_write
|
||||
}
|
||||
};
|
||||
|
||||
static struct cat_command cmds[] = {
|
||||
{
|
||||
.name = "+SET",
|
||||
.write = cmd_write,
|
||||
|
||||
.var = vars,
|
||||
.var_num = sizeof(vars) / sizeof(vars[0])
|
||||
}
|
||||
};
|
||||
|
||||
static char buf[128];
|
||||
|
||||
static struct cat_command_group cmd_group = {
|
||||
.cmd = cmds,
|
||||
.cmd_num = sizeof(cmds) / sizeof(cmds[0]),
|
||||
};
|
||||
|
||||
static struct cat_command_group *cmd_desc[] = {
|
||||
&cmd_group
|
||||
};
|
||||
|
||||
static struct cat_descriptor desc = {
|
||||
.cmd_group = cmd_desc,
|
||||
.cmd_group_num = sizeof(cmd_desc) / sizeof(cmd_desc[0]),
|
||||
|
||||
.buf = buf,
|
||||
.buf_size = sizeof(buf)
|
||||
};
|
||||
|
||||
static int write_char(char ch)
|
||||
{
|
||||
char str[2];
|
||||
str[0] = ch;
|
||||
str[1] = 0;
|
||||
strcat(ack_results, str);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_char(char *ch)
|
||||
{
|
||||
if (input_index >= strlen(input_text))
|
||||
return 0;
|
||||
|
||||
*ch = input_text[input_index];
|
||||
input_index++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct cat_io_interface iface = {
|
||||
.read = read_char,
|
||||
.write = write_char
|
||||
};
|
||||
|
||||
static void prepare_input(const char *text)
|
||||
{
|
||||
input_text = text;
|
||||
input_index = 0;
|
||||
|
||||
var1 = 1;
|
||||
var2 = 2;
|
||||
var3 = 3;
|
||||
var1b = 10;
|
||||
var2b = 20;
|
||||
var3b = 30;
|
||||
|
||||
memset(ack_results, 0, sizeof(ack_results));
|
||||
memset(write_results, 0, sizeof(write_results));
|
||||
}
|
||||
|
||||
static const char test_case_1[] = "\nAT+SET=-128\nAT+SET=0\nAT+SET=255\nAT+SET=256\n";
|
||||
static const char test_case_2[] = "\nAT+SET=0,-1\nAT+SET=0,0\nAT+SET=0,65535\nAT+SET=1,65536\n";
|
||||
static const char test_case_3[] = "\nAT+SET=0,0,-1\nAT+SET=0,0,0\nAT+SET=1,1,4294967295\nAT+SET=2,2,4294967296\n";
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct cat_object at;
|
||||
|
||||
cat_init(&at, &desc, &iface, NULL);
|
||||
|
||||
prepare_input(test_case_1);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:0 CMD:255") == 0);
|
||||
|
||||
assert(var1 == 255);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 2);
|
||||
assert(var2b == 20);
|
||||
assert(var3 == 3);
|
||||
assert(var3b == 30);
|
||||
|
||||
prepare_input(test_case_2);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:0,0 CMD:0,65535") == 0);
|
||||
|
||||
assert(var1 == 1);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 65535);
|
||||
assert(var2b == var2);
|
||||
assert(var3 == 3);
|
||||
assert(var3b == 30);
|
||||
|
||||
prepare_input(test_case_3);
|
||||
while (cat_service(&at) != 0) {};
|
||||
|
||||
assert(strcmp(ack_results, "\nERROR\n\nOK\n\nOK\n\nERROR\n") == 0);
|
||||
assert(strcmp(write_results, " CMD:0,0,0 CMD:1,1,4294967295") == 0);
|
||||
|
||||
assert(var1 == 2);
|
||||
assert(var1b == var1);
|
||||
assert(var2 == 2);
|
||||
assert(var2b == var2);
|
||||
assert(var3 == 4294967295);
|
||||
assert(var3b == var3);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
#include "api.h"
|
||||
|
||||
void api_init(void)
|
||||
{
|
||||
//modbus_init();
|
||||
}
|
||||
@@ -1,575 +0,0 @@
|
||||
#include <string.h>
|
||||
#include "sdkconfig.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "esp_wifi.h"
|
||||
#include "esp_ota_ops.h"
|
||||
#include "esp_timer.h"
|
||||
#include "esp_chip_info.h"
|
||||
#include "esp_mac.h"
|
||||
|
||||
#include "json.h"
|
||||
#include "mqtt.h"
|
||||
#include "network.h"
|
||||
#include "timeout_utils.h"
|
||||
#include "evse_error.h"
|
||||
#include "evse_api.h"
|
||||
#include "auth.h"
|
||||
#include "evse_limits.h"
|
||||
#include "evse_state.h"
|
||||
#include "evse_config.h"
|
||||
#include "ocpp.h"
|
||||
#include "board_config.h"
|
||||
#include "socket_lock.h"
|
||||
#include "proximity.h"
|
||||
//#include "modbus.h"
|
||||
//#include "modbus_tcp.h"
|
||||
//#include "rest.h"
|
||||
#include "temp_sensor.h"
|
||||
// #include "script.h"
|
||||
#include "date_time.h"
|
||||
#include "evse_meter.h"
|
||||
|
||||
|
||||
#define RETURN_ON_ERROR(x) \
|
||||
do \
|
||||
{ \
|
||||
esp_err_t err_rc_ = (x); \
|
||||
if (unlikely(err_rc_ != ESP_OK)) \
|
||||
{ \
|
||||
return err_rc_; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
cJSON *json_get_evse_config(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
|
||||
cJSON_AddNumberToObject(root, "maxChargingCurrent", evse_get_max_charging_current());
|
||||
cJSON_AddNumberToObject(root, "chargingCurrent", evse_get_charging_current());
|
||||
cJSON_AddNumberToObject(root, "defaultChargingCurrent", evse_get_default_charging_current());
|
||||
cJSON_AddBoolToObject(root, "requireAuth", auth_get_mode());
|
||||
cJSON_AddBoolToObject(root, "socketOutlet", evse_get_socket_outlet());
|
||||
cJSON_AddBoolToObject(root, "rcm", evse_is_rcm());
|
||||
cJSON_AddNumberToObject(root, "temperatureThreshold", evse_get_temp_threshold());
|
||||
cJSON_AddNumberToObject(root, "consumptionLimit", evse_get_consumption_limit());
|
||||
cJSON_AddNumberToObject(root, "defaultConsumptionLimit", evse_get_default_consumption_limit());
|
||||
cJSON_AddNumberToObject(root, "chargingTimeLimit", evse_get_charging_time_limit());
|
||||
cJSON_AddNumberToObject(root, "defaultChargingTimeLimit", evse_get_default_charging_time_limit());
|
||||
cJSON_AddNumberToObject(root, "underPowerLimit", evse_get_under_power_limit());
|
||||
cJSON_AddNumberToObject(root, "defaultUnderPowerLimit", evse_get_default_under_power_limit());
|
||||
|
||||
cJSON_AddNumberToObject(root, "socketLockOperatingTime", socket_lock_get_operating_time());
|
||||
cJSON_AddNumberToObject(root, "socketLockBreakTime", socket_lock_get_break_time());
|
||||
cJSON_AddBoolToObject(root, "socketLockDetectionHigh", socket_lock_is_detection_high());
|
||||
cJSON_AddNumberToObject(root, "socketLockRetryCount", socket_lock_get_retry_count());
|
||||
|
||||
//cJSON_AddStringToObject(root, "modelMeter", meter_model_to_str(meter_get_model()));
|
||||
//cJSON_AddNumberToObject(root, "maxGridCurrent", grid_get_max_current());
|
||||
//cJSON_AddStringToObject(root, "stateMeter", meter_state_to_str(meter_get_state()));
|
||||
|
||||
char str[64];
|
||||
cJSON_AddBoolToObject(root, "enabledocpp", ocpp_get_enabled());
|
||||
ocpp_get_server(str);
|
||||
cJSON_AddStringToObject(root, "serverocpp", str);
|
||||
//ocpp_get_rfid(str);
|
||||
//cJSON_AddStringToObject(root, "rfid", str);
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
esp_err_t json_set_evse_config(cJSON *root)
|
||||
{
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "maxChargingCurrent")))
|
||||
{
|
||||
RETURN_ON_ERROR(evse_set_max_charging_current(cJSON_GetObjectItem(root, "maxChargingCurrent")->valuedouble));
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "chargingCurrent")))
|
||||
{
|
||||
RETURN_ON_ERROR(evse_set_charging_current(cJSON_GetObjectItem(root, "chargingCurrent")->valuedouble));
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "defaultChargingCurrent")))
|
||||
{
|
||||
RETURN_ON_ERROR(evse_set_default_charging_current(cJSON_GetObjectItem(root, "defaultChargingCurrent")->valuedouble));
|
||||
}
|
||||
if (cJSON_IsBool(cJSON_GetObjectItem(root, "requireAuth")))
|
||||
{
|
||||
//auth_set_mode(cJSON_IsTrue(cJSON_GetObjectItem(root, "requireAuth")));
|
||||
}
|
||||
if (cJSON_IsBool(cJSON_GetObjectItem(root, "socketOutlet")))
|
||||
{
|
||||
RETURN_ON_ERROR(evse_set_socket_outlet(cJSON_IsTrue(cJSON_GetObjectItem(root, "socketOutlet"))));
|
||||
}
|
||||
if (cJSON_IsBool(cJSON_GetObjectItem(root, "rcm")))
|
||||
{
|
||||
RETURN_ON_ERROR(evse_set_rcm(cJSON_IsTrue(cJSON_GetObjectItem(root, "rcm"))));
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "temperatureThreshold")))
|
||||
{
|
||||
RETURN_ON_ERROR(evse_set_temp_threshold(cJSON_GetObjectItem(root, "temperatureThreshold")->valuedouble));
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "consumptionLimit")))
|
||||
{
|
||||
evse_set_consumption_limit(cJSON_GetObjectItem(root, "consumptionLimit")->valuedouble);
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "defaultConsumptionLimit")))
|
||||
{
|
||||
evse_set_default_consumption_limit(cJSON_GetObjectItem(root, "defaultConsumptionLimit")->valuedouble);
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "chargingTimeLimit")))
|
||||
{
|
||||
evse_set_charging_time_limit(cJSON_GetObjectItem(root, "chargingTimeLimit")->valuedouble);
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "defaultChargingTimeLimit")))
|
||||
{
|
||||
evse_set_default_charging_time_limit(cJSON_GetObjectItem(root, "defaultChargingTimeLimit")->valuedouble);
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "underPowerLimit")))
|
||||
{
|
||||
evse_set_under_power_limit(cJSON_GetObjectItem(root, "underPowerLimit")->valuedouble);
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "defaultUnderPowerLimit")))
|
||||
{
|
||||
evse_set_default_under_power_limit(cJSON_GetObjectItem(root, "defaultUnderPowerLimit")->valuedouble);
|
||||
}
|
||||
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "socketLockOperatingTime")))
|
||||
{
|
||||
RETURN_ON_ERROR(socket_lock_set_operating_time(cJSON_GetObjectItem(root, "socketLockOperatingTime")->valuedouble));
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "socketLockBreakTime")))
|
||||
{
|
||||
RETURN_ON_ERROR(socket_lock_set_break_time(cJSON_GetObjectItem(root, "socketLockBreakTime")->valuedouble));
|
||||
}
|
||||
if (cJSON_IsBool(cJSON_GetObjectItem(root, "socketLockDetectionHigh")))
|
||||
{
|
||||
socket_lock_set_detection_high(cJSON_IsTrue(cJSON_GetObjectItem(root, "socketLockDetectionHigh")));
|
||||
}
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "socketLockRetryCount")))
|
||||
{
|
||||
socket_lock_set_retry_count(cJSON_GetObjectItem(root, "socketLockRetryCount")->valuedouble);
|
||||
}
|
||||
|
||||
/*
|
||||
if (cJSON_IsString(cJSON_GetObjectItem(root, "modelMeter")))
|
||||
{
|
||||
RETURN_ON_ERROR(meter_set_model(meter_str_to_model(cJSON_GetObjectItem(root, "modelMeter")->valuestring)));
|
||||
}
|
||||
|
||||
if (cJSON_IsString(cJSON_GetObjectItem(root, "stateMeter")))
|
||||
{
|
||||
RETURN_ON_ERROR(meter_set_state(meter_str_to_state(cJSON_GetObjectItem(root, "stateMeter")->valuestring)));
|
||||
}
|
||||
|
||||
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "maxGridCurrent")))
|
||||
{
|
||||
RETURN_ON_ERROR(grid_set_max_current(cJSON_GetObjectItem(root, "maxGridCurrent")->valuedouble));
|
||||
}
|
||||
*/
|
||||
|
||||
if (cJSON_IsBool(cJSON_GetObjectItem(root, "enabledocpp")))
|
||||
{
|
||||
ocpp_set_enabled(cJSON_IsTrue(cJSON_GetObjectItem(root, "enabledocpp")));
|
||||
}
|
||||
|
||||
if (cJSON_IsString(cJSON_GetObjectItem(root, "serverocpp")))
|
||||
{
|
||||
ocpp_set_server(cJSON_GetStringValue(cJSON_GetObjectItem(root, "serverocpp")));
|
||||
}
|
||||
|
||||
//if (cJSON_IsString(cJSON_GetObjectItem(root, "rfid")))
|
||||
//{
|
||||
// ocpp_set_rfid(cJSON_GetStringValue(cJSON_GetObjectItem(root, "rfid")));
|
||||
//}
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
cJSON *json_get_wifi_config(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
|
||||
char str[32];
|
||||
|
||||
cJSON_AddBoolToObject(root, "enabled", wifi_get_enabled());
|
||||
wifi_get_ssid(str);
|
||||
cJSON_AddStringToObject(root, "ssid", str);
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
esp_err_t json_set_wifi_config(cJSON *root, bool timeout)
|
||||
{
|
||||
bool enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "enabled"));
|
||||
char *ssid = cJSON_GetStringValue(cJSON_GetObjectItem(root, "ssid"));
|
||||
char *password = cJSON_GetStringValue(cJSON_GetObjectItem(root, "password"));
|
||||
|
||||
if (timeout)
|
||||
{
|
||||
return timeout_wifi_set_config(enabled, ssid, password);
|
||||
}
|
||||
else
|
||||
{
|
||||
return wifi_set_config(enabled, ssid, password);
|
||||
}
|
||||
}
|
||||
|
||||
cJSON *json_get_wifi_scan(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateArray();
|
||||
|
||||
|
||||
wifi_scan_ap_t scan_aps[WIFI_SCAN_SCAN_LIST_SIZE];
|
||||
uint16_t number = wifi_scan(scan_aps);
|
||||
for (int i = 0; i < number; i++)
|
||||
{
|
||||
cJSON *item = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(item, "ssid", scan_aps[i].ssid);
|
||||
cJSON_AddNumberToObject(item, "rssi", scan_aps[i].rssi);
|
||||
cJSON_AddBoolToObject(item, "auth", scan_aps[i].auth);
|
||||
cJSON_AddItemToArray(root, item);
|
||||
}
|
||||
|
||||
return root;
|
||||
}
|
||||
*/
|
||||
|
||||
cJSON *json_get_mqtt_config(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
|
||||
char str[64];
|
||||
|
||||
cJSON_AddBoolToObject(root, "enabled", mqtt_get_enabled());
|
||||
mqtt_get_server(str);
|
||||
cJSON_AddStringToObject(root, "server", str);
|
||||
mqtt_get_base_topic(str);
|
||||
cJSON_AddStringToObject(root, "baseTopic", str);
|
||||
mqtt_get_user(str);
|
||||
cJSON_AddStringToObject(root, "user", str);
|
||||
mqtt_get_password(str);
|
||||
cJSON_AddStringToObject(root, "password", str);
|
||||
cJSON_AddNumberToObject(root, "periodicity", mqtt_get_periodicity());
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
esp_err_t json_set_mqtt_config(cJSON *root)
|
||||
{
|
||||
bool enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "enabled"));
|
||||
char *server = cJSON_GetStringValue(cJSON_GetObjectItem(root, "server"));
|
||||
char *base_topic = cJSON_GetStringValue(cJSON_GetObjectItem(root, "baseTopic"));
|
||||
char *user = cJSON_GetStringValue(cJSON_GetObjectItem(root, "user"));
|
||||
char *password = cJSON_GetStringValue(cJSON_GetObjectItem(root, "password"));
|
||||
uint16_t periodicity = cJSON_GetNumberValue(cJSON_GetObjectItem(root, "periodicity"));
|
||||
|
||||
return mqtt_set_config(enabled, server, base_topic, user, password, periodicity);
|
||||
}
|
||||
|
||||
|
||||
|
||||
cJSON *json_get_modbus_config(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
|
||||
//cJSON_AddBoolToObject(root, "tcpEnabled", modbus_tcp_is_enabled());
|
||||
//cJSON_AddNumberToObject(root, "unitId", modbus_get_unit_id());
|
||||
|
||||
cJSON_AddBoolToObject(root, "tcpEnabled", false);
|
||||
cJSON_AddNumberToObject(root, "unitId", 1);
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
esp_err_t json_set_modbus_config(cJSON *root)
|
||||
{
|
||||
//bool tcp_enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "tcpEnabled"));
|
||||
//uint8_t unit_id = cJSON_GetObjectItem(root, "unitId")->valuedouble;
|
||||
|
||||
//modbus_tcp_set_enabled(tcp_enabled);
|
||||
return 0; //modbus_set_unit_id(unit_id);
|
||||
}
|
||||
/*
|
||||
|
||||
cJSON* json_get_script_config(void)
|
||||
{
|
||||
cJSON* root = cJSON_CreateObject();
|
||||
|
||||
cJSON_AddBoolToObject(root, "enabled", script_is_enabled());
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
esp_err_t json_set_script_config(cJSON* root)
|
||||
{
|
||||
bool enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "enabled"));
|
||||
|
||||
script_set_enabled(enabled);
|
||||
|
||||
return ESP_OK;
|
||||
}*/
|
||||
|
||||
cJSON *json_get_time_config(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
char str[64];
|
||||
|
||||
cJSON_AddBoolToObject(root, "ntpEnabled", date_time_is_ntp_enabled());
|
||||
date_time_get_ntp_server(str);
|
||||
cJSON_AddStringToObject(root, "ntpServer", str);
|
||||
cJSON_AddBoolToObject(root, "ntpFromDhcp", date_time_is_ntp_from_dhcp());
|
||||
date_time_get_timezone(str);
|
||||
cJSON_AddStringToObject(root, "timezone", str);
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
esp_err_t json_set_time_config(cJSON *root)
|
||||
{
|
||||
char *ntp_server = cJSON_GetStringValue(cJSON_GetObjectItem(root, "ntpServer"));
|
||||
bool ntp_enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "ntpEnabled"));
|
||||
bool ntp_from_dhcp = cJSON_IsTrue(cJSON_GetObjectItem(root, "ntpFromDhcp"));
|
||||
char *timezone = cJSON_GetStringValue(cJSON_GetObjectItem(root, "timezone"));
|
||||
|
||||
date_time_set_ntp_config(ntp_enabled, ntp_server, ntp_from_dhcp);
|
||||
return date_time_set_timezone(timezone);
|
||||
}
|
||||
|
||||
cJSON *json_get_state(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
|
||||
cJSON_AddStringToObject(root, "state", evse_state_to_str(evse_get_state()));
|
||||
cJSON_AddBoolToObject(root, "available", evse_config_is_available());
|
||||
cJSON_AddBoolToObject(root, "enabled", evse_config_is_enabled());
|
||||
cJSON_AddBoolToObject(root, "pendingAuth", auth_get_mode());
|
||||
cJSON_AddBoolToObject(root, "limitReached", evse_is_limit_reached());
|
||||
|
||||
uint32_t error = evse_error_get_bits();
|
||||
if (error == 0)
|
||||
{
|
||||
cJSON_AddNullToObject(root, "errors");
|
||||
}
|
||||
else
|
||||
{
|
||||
cJSON *errors = cJSON_CreateArray();
|
||||
if (error & EVSE_ERR_PILOT_FAULT_BIT)
|
||||
{
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("pilot_fault"));
|
||||
}
|
||||
if (error & EVSE_ERR_DIODE_SHORT_BIT)
|
||||
{
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("diode_short"));
|
||||
}
|
||||
if (error & EVSE_ERR_LOCK_FAULT_BIT)
|
||||
{
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("lock_fault"));
|
||||
}
|
||||
if (error & EVSE_ERR_UNLOCK_FAULT_BIT)
|
||||
{
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("unlock_fault"));
|
||||
}
|
||||
if (error & EVSE_ERR_RCM_TRIGGERED_BIT)
|
||||
{
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("rcm_triggered"));
|
||||
}
|
||||
if (error & EVSE_ERR_RCM_SELFTEST_FAULT_BIT)
|
||||
{
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("rcm_selftest_fault"));
|
||||
}
|
||||
if (error & EVSE_ERR_TEMPERATURE_HIGH_BIT)
|
||||
{
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("temperature_high"));
|
||||
}
|
||||
if (error & EVSE_ERR_TEMPERATURE_FAULT_BIT)
|
||||
{
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("temperature_fault"));
|
||||
}
|
||||
cJSON_AddItemToObject(root, "errors", errors);
|
||||
}
|
||||
|
||||
|
||||
// dentro da sua função de gerar JSON:
|
||||
evse_session_t sess;
|
||||
if (evse_get_session(&sess)) {
|
||||
// Há sessão atual ou última disponível
|
||||
cJSON_AddNumberToObject(root, "sessionTime", (double)sess.start_tick);
|
||||
cJSON_AddNumberToObject(root, "chargingTime", (double)sess.duration_s);
|
||||
cJSON_AddNumberToObject(root, "consumption", (double)sess.energy_wh);
|
||||
} else {
|
||||
// Nenhuma sessão disponível
|
||||
cJSON_AddNullToObject(root, "sessionTime");
|
||||
cJSON_AddNumberToObject(root, "chargingTime", 0);
|
||||
cJSON_AddNumberToObject(root, "consumption", 0);
|
||||
}
|
||||
|
||||
// 1) Arrays temporários para ler dados do medidor
|
||||
float voltage_f[EVSE_METER_PHASE_COUNT];
|
||||
float current_f[EVSE_METER_PHASE_COUNT];
|
||||
int power_w[ EVSE_METER_PHASE_COUNT];
|
||||
|
||||
// 2) Leitura dos valores via API pública
|
||||
evse_meter_get_voltage(voltage_f); // já em volts
|
||||
evse_meter_get_current(current_f); // já em amperes
|
||||
evse_meter_get_power(power_w); // em watts por fase
|
||||
|
||||
// 4) Energia acumulada em kWh
|
||||
//float consumption_kwh = evse_meter_get_total_energy() / 1000.0f; // Wh → kWh
|
||||
|
||||
// 6) Arrays de tensão e corrente
|
||||
cJSON_AddItemToObject(root, "power",
|
||||
cJSON_CreateIntArray(power_w, EVSE_METER_PHASE_COUNT));
|
||||
cJSON_AddItemToObject(root, "voltage",
|
||||
cJSON_CreateFloatArray(voltage_f, EVSE_METER_PHASE_COUNT));
|
||||
cJSON_AddItemToObject(root, "current",
|
||||
cJSON_CreateFloatArray(current_f, EVSE_METER_PHASE_COUNT));
|
||||
|
||||
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
cJSON *json_get_info(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
|
||||
cJSON_AddNumberToObject(root, "uptime", esp_timer_get_time() / 1000000);
|
||||
const esp_app_desc_t *app_desc = esp_app_get_description();
|
||||
cJSON_AddStringToObject(root, "appVersion", app_desc->version);
|
||||
cJSON_AddStringToObject(root, "appDate", app_desc->date);
|
||||
cJSON_AddStringToObject(root, "appTime", app_desc->time);
|
||||
cJSON_AddStringToObject(root, "idfVersion", app_desc->idf_ver);
|
||||
cJSON_AddStringToObject(root, "chip", CONFIG_IDF_TARGET);
|
||||
esp_chip_info_t chip_info;
|
||||
esp_chip_info(&chip_info);
|
||||
cJSON_AddNumberToObject(root, "chipCores", chip_info.cores);
|
||||
chip_info.revision = 301;
|
||||
cJSON_AddNumberToObject(root, "chipRevision", chip_info.revision / 100);
|
||||
multi_heap_info_t heap_info;
|
||||
heap_caps_get_info(&heap_info, MALLOC_CAP_INTERNAL);
|
||||
cJSON_AddNumberToObject(root, "heapSize", heap_info.total_allocated_bytes);
|
||||
cJSON_AddNumberToObject(root, "maxHeapSize", heap_info.total_free_bytes + heap_info.total_allocated_bytes);
|
||||
uint8_t mac[6];
|
||||
char str[32];
|
||||
esp_wifi_get_mac(ESP_IF_WIFI_STA, mac);
|
||||
sprintf(str, MACSTR, MAC2STR(mac));
|
||||
cJSON_AddStringToObject(root, "mac", str);
|
||||
esp_netif_ip_info_t ip_info;
|
||||
esp_netif_get_ip_info(esp_netif_get_handle_from_ifkey("WIFI_STA_DEF"), &ip_info);
|
||||
esp_ip4addr_ntoa(&ip_info.ip, str, sizeof(str));
|
||||
cJSON_AddStringToObject(root, "ip", str);
|
||||
esp_wifi_get_mac(ESP_IF_WIFI_AP, mac);
|
||||
sprintf(str, MACSTR, MAC2STR(mac));
|
||||
cJSON_AddStringToObject(root, "macAp", str);
|
||||
esp_netif_get_ip_info(esp_netif_get_handle_from_ifkey("WIFI_AP_DEF"), &ip_info);
|
||||
esp_ip4addr_ntoa(&ip_info.ip, str, sizeof(str));
|
||||
cJSON_AddStringToObject(root, "ipAp", str);
|
||||
cJSON_AddNumberToObject(root, "temperatureSensorCount", temp_sensor_get_count());
|
||||
cJSON_AddNumberToObject(root, "temperatureLow", temp_sensor_get_low() / 100.0);
|
||||
cJSON_AddNumberToObject(root, "temperatureHigh", temp_sensor_get_high() / 100.0);
|
||||
return root;
|
||||
}
|
||||
|
||||
static const char *serial_to_str(board_config_serial_t serial)
|
||||
{
|
||||
switch (serial)
|
||||
{
|
||||
case BOARD_CONFIG_SERIAL_UART:
|
||||
return "uart";
|
||||
case BOARD_CONFIG_SERIAL_RS485:
|
||||
return "rs485";
|
||||
default:
|
||||
return "none";
|
||||
}
|
||||
}
|
||||
|
||||
cJSON *json_get_board_config(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
|
||||
cJSON_AddStringToObject(root, "deviceName", board_config.device_name);
|
||||
cJSON_AddBoolToObject(root, "socketLock", board_config.socket_lock);
|
||||
cJSON_AddBoolToObject(root, "proximity", board_config.proximity);
|
||||
cJSON_AddNumberToObject(root, "socketLockMinBreakTime", board_config.socket_lock_min_break_time);
|
||||
cJSON_AddBoolToObject(root, "rcm", board_config.rcm);
|
||||
cJSON_AddBoolToObject(root, "temperatureSensor", board_config.onewire && board_config.onewire_temp_sensor);
|
||||
|
||||
/*
|
||||
switch (board_config.energy_meter)
|
||||
{
|
||||
case BOARD_CONFIG_ENERGY_METER_CUR:
|
||||
cJSON_AddStringToObject(root, "energyMeter", "cur");
|
||||
break;
|
||||
case BOARD_CONFIG_ENERGY_METER_CUR_VLT:
|
||||
cJSON_AddStringToObject(root, "energyMeter", "cur_vlt");
|
||||
break;
|
||||
default:
|
||||
cJSON_AddStringToObject(root, "energyMeter", "none");
|
||||
}
|
||||
//cJSON_AddBoolToObject(root, "energyMeterThreePhases", board_config.energy_meter_three_phases);
|
||||
*/
|
||||
|
||||
cJSON_AddStringToObject(root, "serial1", serial_to_str(board_config.serial_1));
|
||||
cJSON_AddStringToObject(root, "serial1Name", board_config.serial_1_name);
|
||||
cJSON_AddStringToObject(root, "serial2", serial_to_str(board_config.serial_2));
|
||||
cJSON_AddStringToObject(root, "serial2Name", board_config.serial_2_name);
|
||||
#if SOC_UART_NUM > 2
|
||||
cJSON_AddStringToObject(root, "serial3", serial_to_str(board_config.serial_3));
|
||||
cJSON_AddStringToObject(root, "serial3Name", board_config.serial_3_name);
|
||||
#else
|
||||
cJSON_AddStringToObject(root, "serial3", serial_to_str(BOARD_CONFIG_SERIAL_NONE));
|
||||
cJSON_AddStringToObject(root, "serial3Name", "");
|
||||
#endif
|
||||
|
||||
cJSON *aux = cJSON_CreateArray();
|
||||
if (board_config.aux_in_1)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_in_1_name));
|
||||
}
|
||||
if (board_config.aux_in_2)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_in_2_name));
|
||||
}
|
||||
if (board_config.aux_in_3)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_in_3_name));
|
||||
}
|
||||
if (board_config.aux_in_4)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_in_4_name));
|
||||
}
|
||||
cJSON_AddItemToObject(root, "auxIn", aux);
|
||||
|
||||
aux = cJSON_CreateArray();
|
||||
if (board_config.aux_out_1)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_out_1_name));
|
||||
}
|
||||
if (board_config.aux_out_2)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_out_2_name));
|
||||
}
|
||||
if (board_config.aux_out_3)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_out_3_name));
|
||||
}
|
||||
if (board_config.aux_out_4)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_out_4_name));
|
||||
}
|
||||
cJSON_AddItemToObject(root, "auxOut", aux);
|
||||
|
||||
aux = cJSON_CreateArray();
|
||||
if (board_config.aux_ain_1)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_ain_1_name));
|
||||
}
|
||||
if (board_config.aux_ain_2)
|
||||
{
|
||||
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_ain_2_name));
|
||||
}
|
||||
cJSON_AddItemToObject(root, "auxAin", aux);
|
||||
|
||||
return root;
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
#include <string.h>
|
||||
#include "esp_log.h"
|
||||
#include "esp_err.h"
|
||||
#include "esp_http_client.h"
|
||||
#include "cJSON.h"
|
||||
|
||||
#include "ota.h"
|
||||
|
||||
static const char* TAG = "ota";
|
||||
|
||||
extern const char server_cert_pem_start[] asm("_binary_ca_cert_pem_start");
|
||||
extern const char server_cert_pem_end[] asm("_binary_ca_cert_pem_end");
|
||||
|
||||
static void http_client_cleanup(esp_http_client_handle_t client)
|
||||
{
|
||||
esp_http_client_close(client);
|
||||
esp_http_client_cleanup(client);
|
||||
}
|
||||
|
||||
esp_err_t ota_get_available_version(char* version)
|
||||
{
|
||||
esp_http_client_config_t config = {
|
||||
.url = OTA_VERSION_URL,
|
||||
.cert_pem = server_cert_pem_start
|
||||
};
|
||||
|
||||
esp_http_client_handle_t client = esp_http_client_init(&config);
|
||||
|
||||
esp_err_t err = esp_http_client_open(client, 0);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "Failed to open HTTP connection: %s", esp_err_to_name(err));
|
||||
esp_http_client_cleanup(client);
|
||||
return err;
|
||||
}
|
||||
|
||||
int content_length = esp_http_client_fetch_headers(client);
|
||||
if (content_length > 0) {
|
||||
esp_http_client_read(client, version, content_length);
|
||||
version[content_length] = '\0';
|
||||
http_client_cleanup(client);
|
||||
return ESP_OK;
|
||||
} else {
|
||||
http_client_cleanup(client);
|
||||
ESP_LOGI(TAG, "No firmware available");
|
||||
return ESP_ERR_NOT_FOUND;
|
||||
}
|
||||
}
|
||||
|
||||
bool ota_is_newer_version(const char* actual, const char* available)
|
||||
{
|
||||
// available version has no suffix eg: vX.X.X-beta
|
||||
|
||||
char actual_trimed[32];
|
||||
strcpy(actual_trimed, actual);
|
||||
|
||||
char* saveptr;
|
||||
strtok_r(actual_trimed, "-", &saveptr);
|
||||
bool actual_has_suffix = strtok_r(NULL, "-", &saveptr);
|
||||
|
||||
int diff = strcmp(available, actual_trimed);
|
||||
if (diff == 0) {
|
||||
return actual_has_suffix;
|
||||
} else {
|
||||
return diff > 0;
|
||||
}
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
#include <string.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_system.h"
|
||||
|
||||
#include "timeout_utils.h"
|
||||
#include "network.h"
|
||||
//#include "rest.h"
|
||||
|
||||
static void restart_func(void* arg)
|
||||
{
|
||||
vTaskDelay(pdMS_TO_TICKS(5000));
|
||||
|
||||
//esp_restart();
|
||||
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
void timeout_restart()
|
||||
{
|
||||
//xTaskCreate(restart_func, "restart_task", 2 * 1024, NULL, 10, NULL);
|
||||
}
|
||||
|
||||
typedef struct
|
||||
{
|
||||
bool enabled;
|
||||
bool ssid_blank;
|
||||
char ssid[32];
|
||||
bool password_blank;
|
||||
char password[64];
|
||||
} wifi_set_config_arg_t;
|
||||
|
||||
static void wifi_set_config_func(void* arg)
|
||||
{
|
||||
vTaskDelay(pdMS_TO_TICKS(1000));
|
||||
|
||||
wifi_set_config_arg_t* config = (wifi_set_config_arg_t*)arg;
|
||||
wifi_set_config(config->enabled, config->ssid_blank ? NULL : config->ssid, config->password_blank ? NULL : config->password);
|
||||
free((void*)config);
|
||||
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
esp_err_t timeout_wifi_set_config(bool enabled, const char* ssid, const char* password)
|
||||
{
|
||||
if (enabled) {
|
||||
if (ssid == NULL || strlen(ssid) == 0) {
|
||||
char old_ssid[32];
|
||||
wifi_get_ssid(old_ssid);
|
||||
if (strlen(old_ssid) == 0) {
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
wifi_set_config_arg_t* config = (wifi_set_config_arg_t*)malloc(sizeof(wifi_set_config_arg_t));
|
||||
config->enabled = enabled;
|
||||
if (ssid == NULL || ssid[0] == '\0') {
|
||||
config->ssid_blank = true;
|
||||
} else {
|
||||
config->ssid_blank = false;
|
||||
strcpy(config->ssid, ssid);
|
||||
}
|
||||
if (password == NULL || password[0] == '\0') {
|
||||
config->password_blank = true;
|
||||
} else {
|
||||
config->password_blank = false;
|
||||
strcpy(config->password, password);
|
||||
}
|
||||
|
||||
xTaskCreate(wifi_set_config_func, "wifi_set_config", 4 * 1024, (void*)config, 10, NULL);
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
@@ -174,23 +174,6 @@ auth_mode_t auth_get_mode(void) {
|
||||
return s_mode;
|
||||
}
|
||||
|
||||
const char *auth_mode_to_str(auth_mode_t mode) {
|
||||
switch (mode) {
|
||||
case AUTH_MODE_OPEN: return "open";
|
||||
case AUTH_MODE_LOCAL_RFID: return "local";
|
||||
case AUTH_MODE_OCPP_RFID: return "ocpp";
|
||||
default: return "open";
|
||||
}
|
||||
}
|
||||
|
||||
bool auth_mode_from_str(const char *s, auth_mode_t *out) {
|
||||
if (!s || !out) return false;
|
||||
if (!strcasecmp(s, "open")) { *out = AUTH_MODE_OPEN; return true; }
|
||||
if (!strcasecmp(s, "local")) { *out = AUTH_MODE_LOCAL_RFID; return true; }
|
||||
if (!strcasecmp(s, "ocpp")) { *out = AUTH_MODE_OCPP_RFID; return true; }
|
||||
return false;
|
||||
}
|
||||
|
||||
bool auth_add_tag(const char *tag) {
|
||||
if (tag_count >= MAX_TAGS) return false;
|
||||
if (!tag || strlen(tag) >= AUTH_TAG_MAX_LEN) return false;
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <inttypes.h>
|
||||
#include <freertos/FreeRTOS.h>
|
||||
#include <freertos/task.h>
|
||||
#include <freertos/queue.h>
|
||||
@@ -7,28 +8,190 @@
|
||||
#include <wiegand.h>
|
||||
#include "auth.h"
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define CONFIG_EXAMPLE_BUF_SIZE 50
|
||||
#define IDTAG_MAX_LEN 20
|
||||
|
||||
static const char *TAG = "WiegandReader";
|
||||
|
||||
// ---- Parâmetro global/locale para controlar a convenção de paridade ----
|
||||
static const bool PARITY_INVERTED = false; // mude para true se o seu leitor vier "invertido"
|
||||
|
||||
static wiegand_reader_t reader;
|
||||
static QueueHandle_t queue = NULL;
|
||||
|
||||
typedef struct {
|
||||
typedef struct
|
||||
{
|
||||
uint8_t data[CONFIG_EXAMPLE_BUF_SIZE];
|
||||
size_t bits;
|
||||
size_t bytes;
|
||||
} data_packet_t;
|
||||
|
||||
static void reader_callback(wiegand_reader_t *r) {
|
||||
data_packet_t p;
|
||||
p.bits = r->bits;
|
||||
memcpy(p.data, r->buf, CONFIG_EXAMPLE_BUF_SIZE);
|
||||
xQueueSendToBack(queue, &p, 0);
|
||||
static inline uint8_t get_bit_msb_first(const uint8_t *buf, size_t bit_index)
|
||||
{
|
||||
return (buf[bit_index / 8] >> (7 - (bit_index % 8))) & 0x01;
|
||||
}
|
||||
|
||||
static void wiegand_task(void *arg) {
|
||||
queue = xQueueCreate(5, sizeof(data_packet_t));
|
||||
if (!queue) {
|
||||
// Versão parametrizável
|
||||
static bool check_parity_param(const uint8_t *buf, size_t bits, bool invert)
|
||||
{
|
||||
if (bits != 26 && bits != 34)
|
||||
return false;
|
||||
|
||||
const int first_parity = get_bit_msb_first(buf, 0);
|
||||
const int last_parity = get_bit_msb_first(buf, bits - 1);
|
||||
|
||||
uint32_t left = 0, right = 0;
|
||||
|
||||
if (bits == 26)
|
||||
{
|
||||
for (int i = 1; i <= 12; i++)
|
||||
if (get_bit_msb_first(buf, i))
|
||||
left++;
|
||||
for (int i = 13; i <= 24; i++)
|
||||
if (get_bit_msb_first(buf, i))
|
||||
right++;
|
||||
}
|
||||
else
|
||||
{ // 34
|
||||
for (int i = 1; i <= 16; i++)
|
||||
if (get_bit_msb_first(buf, i))
|
||||
left++;
|
||||
for (int i = 17; i <= 32; i++)
|
||||
if (get_bit_msb_first(buf, i))
|
||||
right++;
|
||||
}
|
||||
|
||||
// Regra padrão (W26/W34 “normais”): primeiro = PAR (left), último = ÍMPAR (right)
|
||||
bool exp_first = (left % 2 == 0);
|
||||
bool exp_last = (right % 2 == 1);
|
||||
|
||||
// Se invertido, troca as expectativas (par <-> ímpar)
|
||||
if (invert)
|
||||
{
|
||||
exp_first = !exp_first;
|
||||
exp_last = !exp_last;
|
||||
}
|
||||
|
||||
return (first_parity == exp_first) && (last_parity == exp_last);
|
||||
}
|
||||
|
||||
// CRC-8/ATM (polinómio 0x07, init 0x00, sem ref, xor 0x00)
|
||||
static uint8_t crc8_atm(const uint8_t *data, size_t len)
|
||||
{
|
||||
uint8_t crc = 0x00;
|
||||
for (size_t i = 0; i < len; i++)
|
||||
{
|
||||
crc ^= data[i];
|
||||
for (int b = 0; b < 8; b++)
|
||||
{
|
||||
crc = (crc & 0x80) ? (uint8_t)((crc << 1) ^ 0x07) : (uint8_t)(crc << 1);
|
||||
}
|
||||
}
|
||||
return crc;
|
||||
}
|
||||
|
||||
// CRC-16/IBM (CRC-16-ANSI) poly 0xA001 (refin/refout), init 0xFFFF
|
||||
static uint16_t crc16_ibm(const uint8_t *data, size_t len)
|
||||
{
|
||||
uint16_t crc = 0xFFFF;
|
||||
for (size_t i = 0; i < len; i++)
|
||||
{
|
||||
crc ^= data[i];
|
||||
for (int b = 0; b < 8; b++)
|
||||
{
|
||||
if (crc & 1)
|
||||
crc = (crc >> 1) ^ 0xA001;
|
||||
else
|
||||
crc >>= 1;
|
||||
}
|
||||
}
|
||||
return crc;
|
||||
}
|
||||
|
||||
// Extrai payload (sem paridades) e devolve FC/CN para W26/34
|
||||
static bool wiegand_extract_fc_cn(const uint8_t *buf, size_t bits, uint32_t *fc, uint32_t *cn)
|
||||
{
|
||||
if (bits != 26 && bits != 34)
|
||||
return false;
|
||||
uint32_t payload = 0;
|
||||
size_t payload_bits = bits - 2;
|
||||
for (size_t i = 0; i < payload_bits; i++)
|
||||
{
|
||||
size_t bit = 1 + i; // ignora bit de paridade inicial
|
||||
uint8_t bitval = (buf[bit / 8] >> (7 - (bit % 8))) & 0x01;
|
||||
payload = (payload << 1) | bitval;
|
||||
}
|
||||
if (bits == 26)
|
||||
{
|
||||
*fc = (payload >> 16) & 0xFF; // 8b
|
||||
*cn = payload & 0xFFFF; // 16b
|
||||
}
|
||||
else
|
||||
{
|
||||
*fc = (payload >> 16) & 0xFFFF; // 16b
|
||||
*cn = payload & 0xFFFF; // 16b
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool build_idtag_w26_4B(uint32_t fc, uint32_t cn, char *out, size_t outlen)
|
||||
{
|
||||
uint8_t raw[4] = {
|
||||
(uint8_t)(fc & 0xFF),
|
||||
(uint8_t)((cn >> 8) & 0xFF),
|
||||
(uint8_t)(cn & 0xFF),
|
||||
0};
|
||||
raw[3] = crc8_atm(raw, 3);
|
||||
if (outlen < 9)
|
||||
return false;
|
||||
int n = snprintf(out, outlen, "%02X%02X%02X%02X", raw[0], raw[1], raw[2], raw[3]);
|
||||
return (n > 0 && (size_t)n < outlen);
|
||||
}
|
||||
|
||||
static bool build_idtag_w34_7B(uint32_t fc, uint32_t cn, char *out, size_t outlen)
|
||||
{
|
||||
uint8_t raw[7];
|
||||
raw[0] = 0x34;
|
||||
raw[1] = (uint8_t)((fc >> 8) & 0xFF);
|
||||
raw[2] = (uint8_t)(fc & 0xFF);
|
||||
raw[3] = (uint8_t)((cn >> 8) & 0xFF);
|
||||
raw[4] = (uint8_t)(cn & 0xFF);
|
||||
uint16_t crc = crc16_ibm(raw, 5);
|
||||
raw[5] = (uint8_t)((crc >> 8) & 0xFF);
|
||||
raw[6] = (uint8_t)(crc & 0xFF);
|
||||
if (outlen < 15)
|
||||
return false;
|
||||
int n = snprintf(out, outlen, "%02X%02X%02X%02X%02X%02X%02X",
|
||||
raw[0], raw[1], raw[2], raw[3], raw[4], raw[5], raw[6]);
|
||||
return (n > 0 && (size_t)n < outlen);
|
||||
}
|
||||
|
||||
// Se o callback for de ISR, troque para xQueueSendToBackFromISR.
|
||||
static void reader_callback(wiegand_reader_t *r)
|
||||
{
|
||||
data_packet_t p = {0};
|
||||
p.bits = r->bits;
|
||||
p.bytes = (r->bits + 7) / 8;
|
||||
if (p.bytes > sizeof(p.data))
|
||||
p.bytes = sizeof(p.data);
|
||||
memcpy(p.data, r->buf, p.bytes);
|
||||
|
||||
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
|
||||
// Se NÃO for ISR, use xQueueSendToBack(queue, &p, 0);
|
||||
xQueueSendToBackFromISR(queue, &p, &xHigherPriorityTaskWoken);
|
||||
if (xHigherPriorityTaskWoken)
|
||||
portYIELD_FROM_ISR();
|
||||
}
|
||||
|
||||
static void wiegand_task(void *arg)
|
||||
{
|
||||
queue = xQueueCreate(8, sizeof(data_packet_t));
|
||||
if (!queue)
|
||||
{
|
||||
ESP_LOGE(TAG, "Failed to create queue");
|
||||
vTaskDelete(NULL);
|
||||
return;
|
||||
@@ -38,30 +201,79 @@ static void wiegand_task(void *arg) {
|
||||
true, CONFIG_EXAMPLE_BUF_SIZE, reader_callback, WIEGAND_MSB_FIRST, WIEGAND_LSB_FIRST));
|
||||
|
||||
data_packet_t p;
|
||||
while (1) {
|
||||
for (;;)
|
||||
{
|
||||
ESP_LOGI(TAG, "Waiting for Wiegand data...");
|
||||
if (xQueueReceive(queue, &p, portMAX_DELAY) == pdPASS) {
|
||||
ESP_LOGI(TAG, "Bits received: %d", p.bits);
|
||||
if (xQueueReceive(queue, &p, portMAX_DELAY) != pdPASS)
|
||||
continue;
|
||||
|
||||
char tag[20] = {0};
|
||||
ESP_LOGI(TAG, "Bits received: %d", (int)p.bits);
|
||||
|
||||
if (p.bits == 26) {
|
||||
snprintf(tag, sizeof(tag), "%03d%03d%03d", p.data[0], p.data[1], p.data[2]);
|
||||
} else if (p.bits == 34) {
|
||||
snprintf(tag, sizeof(tag), "%03d%03d%03d%03d", p.data[0], p.data[1], p.data[2], p.data[3]);
|
||||
} else {
|
||||
ESP_LOGW(TAG, "Unsupported bit length: %d", (int)p.bits);
|
||||
ESP_LOG_BUFFER_HEX(TAG, p.data, sizeof(p.data)); // loga o buffer bruto
|
||||
if (!check_parity_param(p.data, p.bits, PARITY_INVERTED))
|
||||
{
|
||||
ESP_LOGW(TAG, "Parity check failed (%d bits). Dump:", (int)p.bits);
|
||||
ESP_LOG_BUFFER_HEX(TAG, p.data, p.bytes);
|
||||
continue;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Tag read: %s", tag);
|
||||
auth_process_tag(tag); // agora delega toda a lógica à auth.c
|
||||
char tag[21] = {0}; // OCPP 1.6: máx 20 chars (+NUL)
|
||||
uint32_t fc = 0, cn = 0;
|
||||
|
||||
if (!wiegand_extract_fc_cn(p.data, p.bits, &fc, &cn))
|
||||
{
|
||||
ESP_LOGW(TAG, "Unsupported bit length: %d", (int)p.bits);
|
||||
continue;
|
||||
}
|
||||
|
||||
bool ok = false;
|
||||
if (p.bits == 26)
|
||||
{
|
||||
ok = build_idtag_w26_4B(fc, cn, tag, sizeof(tag)); // 8 hex
|
||||
}
|
||||
else
|
||||
{ // 34
|
||||
ok = build_idtag_w34_7B(fc, cn, tag, sizeof(tag)); // 14 hex
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
ESP_LOGW(TAG, "Failed to build idTag");
|
||||
continue;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "idTag: %s", tag); // apenas [0-9A-F], alfanumérico
|
||||
auth_process_tag(tag);
|
||||
}
|
||||
}
|
||||
|
||||
static void wiegand_sim_task(void *arg)
|
||||
{
|
||||
// lista fixa de idTags simuladas
|
||||
static const char *idtaglist[] = {
|
||||
"0000004134962107",
|
||||
"W2602312345",
|
||||
"W34ABCDE12345",
|
||||
};
|
||||
const size_t list_size = sizeof(idtaglist) / sizeof(idtaglist[0]);
|
||||
|
||||
for (;;)
|
||||
{
|
||||
for (size_t i = 0; i < list_size; i++)
|
||||
{
|
||||
ESP_LOGI(TAG, "Simulação -> idTag: %s", idtaglist[i]);
|
||||
auth_process_tag(idtaglist[i]);
|
||||
|
||||
// espera 20 segundos entre cada tag
|
||||
vTaskDelay(pdMS_TO_TICKS(30000));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void initWiegand(void) {
|
||||
void initWiegand(void)
|
||||
{
|
||||
ESP_LOGI(TAG, "Initializing Wiegand reader");
|
||||
xTaskCreate(wiegand_task, TAG, configMINIMAL_STACK_SIZE * 4, NULL, 4, NULL);
|
||||
|
||||
// ESP_LOGI(TAG, "Inicializando Wiegand simulado");
|
||||
// xTaskCreate(wiegand_sim_task, "WiegandSim", configMINIMAL_STACK_SIZE * 3, NULL, 3, NULL);
|
||||
}
|
||||
|
||||
@@ -1,11 +1,66 @@
|
||||
// buzzer.h
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
#include "buzzer_events.h" // para buzzer_pattern_id_t
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Inicializa hardware, fila e task do buzzer; registra event handlers.
|
||||
*/
|
||||
void buzzer_init(void);
|
||||
|
||||
/**
|
||||
* @brief Desinicializa o buzzer (opcional), removendo handlers e task.
|
||||
*/
|
||||
void buzzer_deinit(void);
|
||||
|
||||
/**
|
||||
* @brief Solicita tocar um padrão de buzzer de forma assíncrona.
|
||||
* @param id Enum do padrão (ver buzzer_events.h).
|
||||
*/
|
||||
void buzzer_play(buzzer_pattern_id_t id);
|
||||
|
||||
/**
|
||||
* @brief Interrompe imediatamente qualquer padrão em execução e esvazia a fila.
|
||||
*/
|
||||
void buzzer_stop(void);
|
||||
|
||||
/**
|
||||
* @brief Ativa/Desativa globalmente o buzzer (mute).
|
||||
* Quando desativado, não toca e garante nível/desligado.
|
||||
*/
|
||||
void buzzer_set_enabled(bool enabled);
|
||||
|
||||
/**
|
||||
* @brief Retorna o estado atual de enable/mute do buzzer.
|
||||
*/
|
||||
bool buzzer_get_enabled(void);
|
||||
|
||||
/**
|
||||
* @brief Define quiet hours (janela silenciosa) em minutos desde 00:00.
|
||||
* @param enabled Habilita/desabilita quiet hours.
|
||||
* @param start_min Início (0..1439).
|
||||
* @param end_min Fim (0..1439). Pode cruzar meia-noite.
|
||||
*/
|
||||
void buzzer_set_quiet_hours(bool enabled, uint16_t start_min, uint16_t end_min);
|
||||
|
||||
/**
|
||||
* @brief Ajusta a frequência PWM (somente PASSIVE/LEDC; timer exclusivo recomendado).
|
||||
* @return ESP_OK em sucesso; erro se modo inválido ou argumento fora do range.
|
||||
*/
|
||||
esp_err_t buzzer_set_frequency(uint32_t hz);
|
||||
|
||||
/**
|
||||
* @brief Define o duty cycle em porcentagem (0..100) para PASSIVE/LEDC.
|
||||
*/
|
||||
void buzzer_set_duty_percent(uint8_t pct);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -17,6 +17,7 @@ typedef enum {
|
||||
BUZZER_PATTERN_CARD_READ,
|
||||
BUZZER_PATTERN_CARD_ADD,
|
||||
BUZZER_PATTERN_CARD_DENIED,
|
||||
BUZZER_PATTERN_FAULT,
|
||||
BUZZER_PATTERN_MAX
|
||||
} buzzer_pattern_id_t;
|
||||
|
||||
|
||||
@@ -1,28 +1,96 @@
|
||||
// buzzer.c
|
||||
#include "buzzer_events.h"
|
||||
#include "evse_events.h"
|
||||
#include "auth_events.h"
|
||||
#include "network_events.h"
|
||||
|
||||
#include "esp_event.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_err.h"
|
||||
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/ledc.h" // Para buzzer passivo
|
||||
#include "freertos/queue.h"
|
||||
|
||||
#define BUZZER_GPIO GPIO_NUM_27
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/ledc.h"
|
||||
|
||||
#include <time.h>
|
||||
#include <string.h>
|
||||
|
||||
// ===================== Configuração padrão (pode migrar para Kconfig) =====================
|
||||
#ifndef CONFIG_BUZZER_GPIO
|
||||
#define CONFIG_BUZZER_GPIO GPIO_NUM_27
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_MODE_PASSIVE // 1 = PASSIVE (PWM), 0 = ACTIVE (on/off)
|
||||
#define CONFIG_BUZZER_MODE_PASSIVE 1
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_FREQ_HZ
|
||||
#define CONFIG_BUZZER_FREQ_HZ 3500
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_DUTY_PCT
|
||||
#define CONFIG_BUZZER_DUTY_PCT 70
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_QUEUE_LEN
|
||||
#define CONFIG_BUZZER_QUEUE_LEN 8
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_TASK_STACK
|
||||
#define CONFIG_BUZZER_TASK_STACK 2048
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_TASK_PRIO
|
||||
#define CONFIG_BUZZER_TASK_PRIO (tskIDLE_PRIORITY + 1)
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_MIN_GAP_MS // anti-spam (gap mínimo entre toques)
|
||||
#define CONFIG_BUZZER_MIN_GAP_MS 70
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_ENABLE_DEFAULT
|
||||
#define CONFIG_BUZZER_ENABLE_DEFAULT 1
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_QUIET_START_MIN // quiet hours start (minutos desde 00:00)
|
||||
#define CONFIG_BUZZER_QUIET_START_MIN (22 * 60)
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_BUZZER_QUIET_END_MIN // quiet hours end (minutos desde 00:00)
|
||||
#define CONFIG_BUZZER_QUIET_END_MIN (7 * 60)
|
||||
#endif
|
||||
|
||||
// ===================== Tipos e estado =====================
|
||||
static const char *TAG = "Buzzer";
|
||||
|
||||
// --- Configuração de modo ---
|
||||
typedef enum {
|
||||
typedef enum
|
||||
{
|
||||
BUZZER_MODE_ACTIVE = 0,
|
||||
BUZZER_MODE_PASSIVE
|
||||
} buzzer_mode_t;
|
||||
|
||||
typedef struct {
|
||||
typedef struct
|
||||
{
|
||||
uint16_t on_ms;
|
||||
uint16_t off_ms;
|
||||
} buzzer_step_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
const buzzer_step_t *steps;
|
||||
size_t length;
|
||||
} buzzer_pattern_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
buzzer_mode_t mode;
|
||||
gpio_num_t gpio;
|
||||
|
||||
// Apenas para PASSIVE
|
||||
uint32_t freq_hz; // ex: 4000
|
||||
// PASSIVE (PWM)
|
||||
uint32_t freq_hz;
|
||||
uint8_t duty_percent; // 0–100
|
||||
ledc_mode_t ledc_speed_mode; // LEDC_LOW_SPEED_MODE
|
||||
ledc_timer_t ledc_timer; // LEDC_TIMER_1
|
||||
@@ -30,37 +98,65 @@ typedef struct {
|
||||
ledc_timer_bit_t duty_resolution; // LEDC_TIMER_10_BIT
|
||||
} buzzer_config_t;
|
||||
|
||||
// Controlo runtime
|
||||
static struct
|
||||
{
|
||||
bool enabled;
|
||||
uint16_t quiet_start_min; // [0..1440)
|
||||
uint16_t quiet_end_min; // [0..1440)
|
||||
bool quiet_enabled;
|
||||
} s_buzzer_ctl = {
|
||||
.enabled = CONFIG_BUZZER_ENABLE_DEFAULT,
|
||||
.quiet_start_min = CONFIG_BUZZER_QUIET_START_MIN,
|
||||
.quiet_end_min = CONFIG_BUZZER_QUIET_END_MIN,
|
||||
.quiet_enabled = false,
|
||||
};
|
||||
|
||||
// Hardware cfg
|
||||
static buzzer_config_t s_buzzer_cfg = {
|
||||
.mode = BUZZER_MODE_PASSIVE, // Mude para PASSIVE se for buzzer passivo
|
||||
.gpio = BUZZER_GPIO,
|
||||
.freq_hz = 4000,
|
||||
.duty_percent = 50,
|
||||
.mode = CONFIG_BUZZER_MODE_PASSIVE ? BUZZER_MODE_PASSIVE : BUZZER_MODE_ACTIVE,
|
||||
.gpio = CONFIG_BUZZER_GPIO,
|
||||
.freq_hz = CONFIG_BUZZER_FREQ_HZ,
|
||||
.duty_percent = CONFIG_BUZZER_DUTY_PCT,
|
||||
.ledc_speed_mode = LEDC_LOW_SPEED_MODE,
|
||||
.ledc_timer = LEDC_TIMER_1,
|
||||
.ledc_channel = LEDC_CHANNEL_1,
|
||||
.duty_resolution = LEDC_TIMER_10_BIT
|
||||
.duty_resolution = LEDC_TIMER_10_BIT};
|
||||
|
||||
// Fila e task
|
||||
static QueueHandle_t s_buzzer_q = NULL;
|
||||
static TaskHandle_t s_buzzer_task = NULL;
|
||||
|
||||
// Anti-spam básico
|
||||
static TickType_t s_last_play_tick = 0;
|
||||
static const TickType_t s_min_gap_ticks = pdMS_TO_TICKS(CONFIG_BUZZER_MIN_GAP_MS);
|
||||
|
||||
// ===================== Padrões (afinados) =====================
|
||||
// NOTA: os enums BUZZER_PATTERN_* vêm de buzzer_events.h
|
||||
|
||||
// Curtos e claros
|
||||
static const buzzer_step_t pattern_plugged[] = {{180, 120}}; // ~300 ms
|
||||
static const buzzer_step_t pattern_card_read[] = {{80, 80}, {80, 0}}; // 160 ms audível
|
||||
|
||||
// Um pouco mais longos, ritmo marcante
|
||||
static const buzzer_step_t pattern_unplugged[] = {{140, 140}, {140, 140}, {140, 0}}; // ~700 ms
|
||||
static const buzzer_step_t pattern_card_add[] = {{100, 100}, {100, 100}, {120, 0}}; // ~520 ms
|
||||
static const buzzer_step_t pattern_ap_start[] = {{250, 150}, {250, 0}}; // ~650 ms
|
||||
|
||||
// Charging mais curta (evento frequente)
|
||||
static const buzzer_step_t pattern_charging[] = {{80, 90}, {90, 80}, {100, 0}}; // ~440 ms
|
||||
|
||||
// Denied mais “duro”
|
||||
static const buzzer_step_t pattern_card_denied[] = {{250, 120}, {300, 0}}; // ~670 ms
|
||||
|
||||
// Fault crítico (duas trincas, ~1.7 s)
|
||||
static const buzzer_step_t pattern_fault[] = {
|
||||
{350, 120}, {350, 120}, {450, 250}, // bloco 1
|
||||
{350, 120},
|
||||
{350, 120},
|
||||
{450, 0} // bloco 2
|
||||
};
|
||||
|
||||
// --- Estrutura de passos ---
|
||||
typedef struct {
|
||||
uint16_t on_ms;
|
||||
uint16_t off_ms;
|
||||
} buzzer_step_t;
|
||||
|
||||
// Padrões de buzzer
|
||||
static const buzzer_step_t pattern_plugged[] = {{200, 100}};
|
||||
static const buzzer_step_t pattern_unplugged[] = {{150, 150}, {150, 150}, {150, 0}};
|
||||
static const buzzer_step_t pattern_charging[] = {{80, 150}, {100, 120}, {120, 100}, {140, 0}};
|
||||
static const buzzer_step_t pattern_ap_start[] = {{300, 150}, {300, 0}};
|
||||
static const buzzer_step_t pattern_card_read[] = {{50, 50}, {50, 0}};
|
||||
static const buzzer_step_t pattern_card_add[] = {{100, 100}, {100, 100}, {100, 0}};
|
||||
static const buzzer_step_t pattern_card_denied[] = {{300, 100}, {300, 0}};
|
||||
|
||||
typedef struct {
|
||||
const buzzer_step_t *steps;
|
||||
size_t length;
|
||||
} buzzer_pattern_t;
|
||||
|
||||
static const buzzer_pattern_t buzzer_patterns[] = {
|
||||
[BUZZER_PATTERN_PLUGGED] = {pattern_plugged, sizeof(pattern_plugged) / sizeof(buzzer_step_t)},
|
||||
[BUZZER_PATTERN_UNPLUGGED] = {pattern_unplugged, sizeof(pattern_unplugged) / sizeof(buzzer_step_t)},
|
||||
@@ -69,79 +165,231 @@ static const buzzer_pattern_t buzzer_patterns[] = {
|
||||
[BUZZER_PATTERN_CARD_READ] = {pattern_card_read, sizeof(pattern_card_read) / sizeof(buzzer_step_t)},
|
||||
[BUZZER_PATTERN_CARD_ADD] = {pattern_card_add, sizeof(pattern_card_add) / sizeof(buzzer_step_t)},
|
||||
[BUZZER_PATTERN_CARD_DENIED] = {pattern_card_denied, sizeof(pattern_card_denied) / sizeof(buzzer_step_t)},
|
||||
[BUZZER_PATTERN_FAULT] = {pattern_fault, sizeof(pattern_fault) / sizeof(buzzer_step_t)},
|
||||
};
|
||||
|
||||
// --- Funções de controle ---
|
||||
static inline uint32_t duty_from_percent(uint8_t pct, ledc_timer_bit_t res) {
|
||||
if (pct == 0) return 0;
|
||||
// ===================== Helpers HW =====================
|
||||
static inline uint32_t duty_from_percent(uint8_t pct, ledc_timer_bit_t res)
|
||||
{
|
||||
if (pct == 0)
|
||||
return 0;
|
||||
if (pct > 100)
|
||||
pct = 100;
|
||||
uint32_t max = (1U << res) - 1U;
|
||||
return (uint32_t)((pct * max) / 100U);
|
||||
}
|
||||
|
||||
static void buzzer_on(void) {
|
||||
if (s_buzzer_cfg.mode == BUZZER_MODE_PASSIVE) {
|
||||
ledc_set_freq(s_buzzer_cfg.ledc_speed_mode,
|
||||
s_buzzer_cfg.ledc_timer,
|
||||
s_buzzer_cfg.freq_hz);
|
||||
ledc_set_duty(s_buzzer_cfg.ledc_speed_mode,
|
||||
static inline bool is_pattern_valid(buzzer_pattern_id_t id)
|
||||
{
|
||||
return (id > BUZZER_PATTERN_NONE && id < BUZZER_PATTERN_MAX);
|
||||
}
|
||||
|
||||
static void buzzer_on(void)
|
||||
{
|
||||
if (s_buzzer_cfg.mode == BUZZER_MODE_PASSIVE)
|
||||
{
|
||||
// Não mudar freq a cada beep; já foi configurada na init.
|
||||
esp_err_t err1 = ledc_set_duty(s_buzzer_cfg.ledc_speed_mode,
|
||||
s_buzzer_cfg.ledc_channel,
|
||||
duty_from_percent(s_buzzer_cfg.duty_percent, s_buzzer_cfg.duty_resolution));
|
||||
ledc_update_duty(s_buzzer_cfg.ledc_speed_mode, s_buzzer_cfg.ledc_channel);
|
||||
} else {
|
||||
if (err1 != ESP_OK)
|
||||
ESP_LOGW(TAG, "ledc_set_duty err=%s", esp_err_to_name(err1));
|
||||
esp_err_t err2 = ledc_update_duty(s_buzzer_cfg.ledc_speed_mode, s_buzzer_cfg.ledc_channel);
|
||||
if (err2 != ESP_OK)
|
||||
ESP_LOGW(TAG, "ledc_update_duty err=%s", esp_err_to_name(err2));
|
||||
}
|
||||
else
|
||||
{
|
||||
gpio_set_level(s_buzzer_cfg.gpio, 1);
|
||||
}
|
||||
}
|
||||
|
||||
static void buzzer_off(void) {
|
||||
if (s_buzzer_cfg.mode == BUZZER_MODE_PASSIVE) {
|
||||
ledc_set_duty(s_buzzer_cfg.ledc_speed_mode, s_buzzer_cfg.ledc_channel, 0);
|
||||
ledc_update_duty(s_buzzer_cfg.ledc_speed_mode, s_buzzer_cfg.ledc_channel);
|
||||
} else {
|
||||
static void buzzer_off(void)
|
||||
{
|
||||
if (s_buzzer_cfg.mode == BUZZER_MODE_PASSIVE)
|
||||
{
|
||||
esp_err_t err1 = ledc_set_duty(s_buzzer_cfg.ledc_speed_mode, s_buzzer_cfg.ledc_channel, 0);
|
||||
if (err1 != ESP_OK)
|
||||
ESP_LOGW(TAG, "ledc_set_duty(0) err=%s", esp_err_to_name(err1));
|
||||
esp_err_t err2 = ledc_update_duty(s_buzzer_cfg.ledc_speed_mode, s_buzzer_cfg.ledc_channel);
|
||||
if (err2 != ESP_OK)
|
||||
ESP_LOGW(TAG, "ledc_update_duty err=%s", esp_err_to_name(err2));
|
||||
}
|
||||
else
|
||||
{
|
||||
gpio_set_level(s_buzzer_cfg.gpio, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// --- Execução de padrões ---
|
||||
static void buzzer_execute(buzzer_pattern_id_t pattern_id) {
|
||||
if ((int)pattern_id <= BUZZER_PATTERN_NONE || pattern_id >= BUZZER_PATTERN_MAX) {
|
||||
static bool in_quiet_hours(void)
|
||||
{
|
||||
if (!s_buzzer_ctl.quiet_enabled)
|
||||
return false;
|
||||
|
||||
time_t now = time(NULL);
|
||||
struct tm lt;
|
||||
if (localtime_r(&now, <) == NULL)
|
||||
return false;
|
||||
|
||||
uint16_t minutes = (uint16_t)(lt.tm_hour * 60 + lt.tm_min);
|
||||
uint16_t start = s_buzzer_ctl.quiet_start_min;
|
||||
uint16_t end = s_buzzer_ctl.quiet_end_min;
|
||||
|
||||
if (start == end)
|
||||
return false; // desativado
|
||||
if (start < end)
|
||||
{
|
||||
return (minutes >= start && minutes < end);
|
||||
}
|
||||
else
|
||||
{ // janela cruza meia-noite
|
||||
return (minutes >= start || minutes < end);
|
||||
}
|
||||
}
|
||||
|
||||
// ===================== Execução do padrão (apenas dentro da task) =====================
|
||||
static void buzzer_execute(buzzer_pattern_id_t pattern_id)
|
||||
{
|
||||
if (!is_pattern_valid(pattern_id))
|
||||
{
|
||||
ESP_LOGW(TAG, "Invalid buzzer pattern id: %d", pattern_id);
|
||||
return;
|
||||
}
|
||||
|
||||
ESP_LOGD(TAG, "Executing buzzer pattern ID: %d", pattern_id);
|
||||
const buzzer_pattern_t *pattern = &buzzer_patterns[pattern_id];
|
||||
for (size_t i = 0; i < pattern->length; i++) {
|
||||
for (size_t i = 0; i < pattern->length; i++)
|
||||
{
|
||||
buzzer_on();
|
||||
vTaskDelay(pdMS_TO_TICKS(pattern->steps[i].on_ms));
|
||||
buzzer_off();
|
||||
if (pattern->steps[i].off_ms > 0) {
|
||||
if (pattern->steps[i].off_ms > 0)
|
||||
{
|
||||
vTaskDelay(pdMS_TO_TICKS(pattern->steps[i].off_ms));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- Event Handlers ---
|
||||
static void buzzer_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data) {
|
||||
if (base != BUZZER_EVENTS || id != BUZZER_EVENT_PLAY_PATTERN || data == NULL) return;
|
||||
// ===================== Task & Fila =====================
|
||||
static void buzzer_task(void *arg)
|
||||
{
|
||||
buzzer_pattern_id_t id;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
if (xQueueReceive(s_buzzer_q, &id, portMAX_DELAY) == pdTRUE)
|
||||
{
|
||||
|
||||
ESP_LOGD(TAG, "dequeue pattern %d", id); // na buzzer_task()
|
||||
|
||||
if (!s_buzzer_ctl.enabled)
|
||||
continue;
|
||||
|
||||
// Quiet hours: permitir apenas alertas críticos/negativos
|
||||
if (in_quiet_hours())
|
||||
{
|
||||
if (!(id == BUZZER_PATTERN_FAULT || id == BUZZER_PATTERN_CARD_DENIED))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Anti-spam global
|
||||
TickType_t now = xTaskGetTickCount();
|
||||
if ((now - s_last_play_tick) < s_min_gap_ticks)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
s_last_play_tick = now;
|
||||
|
||||
buzzer_execute(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ===================== API pública =====================
|
||||
void buzzer_play(buzzer_pattern_id_t id)
|
||||
{
|
||||
|
||||
ESP_LOGD(TAG, "enqueue pattern %d", id); // dentro de buzzer_play()
|
||||
|
||||
if (!is_pattern_valid(id) || s_buzzer_q == NULL)
|
||||
return;
|
||||
(void)xQueueSend(s_buzzer_q, &id, 0);
|
||||
}
|
||||
|
||||
void buzzer_stop(void)
|
||||
{
|
||||
// Interrompe imediatamente: esvazia fila e desliga
|
||||
if (s_buzzer_q)
|
||||
xQueueReset(s_buzzer_q);
|
||||
buzzer_off();
|
||||
}
|
||||
|
||||
void buzzer_set_enabled(bool enabled)
|
||||
{
|
||||
s_buzzer_ctl.enabled = enabled;
|
||||
if (!enabled)
|
||||
buzzer_off();
|
||||
}
|
||||
|
||||
bool buzzer_get_enabled(void)
|
||||
{
|
||||
return s_buzzer_ctl.enabled;
|
||||
}
|
||||
|
||||
void buzzer_set_quiet_hours(bool enabled, uint16_t start_min, uint16_t end_min)
|
||||
{
|
||||
s_buzzer_ctl.quiet_enabled = enabled;
|
||||
if (start_min < 1440)
|
||||
s_buzzer_ctl.quiet_start_min = start_min;
|
||||
if (end_min < 1440)
|
||||
s_buzzer_ctl.quiet_end_min = end_min;
|
||||
}
|
||||
|
||||
// Opcional: mudar tom dinamicamente (apenas se o timer for exclusivo do buzzer)
|
||||
esp_err_t buzzer_set_frequency(uint32_t hz)
|
||||
{
|
||||
if (s_buzzer_cfg.mode != BUZZER_MODE_PASSIVE)
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
if (hz < 50 || hz > 20000)
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
s_buzzer_cfg.freq_hz = hz;
|
||||
return ledc_set_freq(s_buzzer_cfg.ledc_speed_mode, s_buzzer_cfg.ledc_timer, hz);
|
||||
}
|
||||
|
||||
void buzzer_set_duty_percent(uint8_t pct)
|
||||
{
|
||||
if (pct > 100)
|
||||
pct = 100;
|
||||
s_buzzer_cfg.duty_percent = pct;
|
||||
}
|
||||
|
||||
// ===================== Event Handlers =====================
|
||||
static void buzzer_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data)
|
||||
{
|
||||
if (base != BUZZER_EVENTS || id != BUZZER_EVENT_PLAY_PATTERN || data == NULL)
|
||||
return;
|
||||
|
||||
buzzer_event_data_t *evt = (buzzer_event_data_t *)data;
|
||||
if ((int)evt->pattern < BUZZER_PATTERN_NONE || evt->pattern >= BUZZER_PATTERN_MAX) {
|
||||
if (!is_pattern_valid(evt->pattern))
|
||||
{
|
||||
ESP_LOGW(TAG, "Invalid buzzer pattern received: %d", evt->pattern);
|
||||
return;
|
||||
}
|
||||
|
||||
buzzer_execute(evt->pattern);
|
||||
buzzer_play(evt->pattern);
|
||||
}
|
||||
|
||||
static void evse_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data) {
|
||||
if (base != EVSE_EVENTS || id != EVSE_EVENT_STATE_CHANGED || data == NULL) return;
|
||||
static void evse_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data)
|
||||
{
|
||||
if (base != EVSE_EVENTS || id != EVSE_EVENT_STATE_CHANGED || data == NULL)
|
||||
return;
|
||||
|
||||
const evse_state_event_data_t *evt = (const evse_state_event_data_t *)data;
|
||||
ESP_LOGI(TAG, "EVSE event received: state = %d", evt->state);
|
||||
ESP_LOGD(TAG, "EVSE event: state=%d", evt->state);
|
||||
|
||||
buzzer_event_data_t buzzer_evt = {0};
|
||||
|
||||
switch (evt->state) {
|
||||
switch (evt->state)
|
||||
{
|
||||
case EVSE_STATE_EVENT_IDLE:
|
||||
buzzer_evt.pattern = BUZZER_PATTERN_UNPLUGGED;
|
||||
break;
|
||||
@@ -152,6 +400,10 @@ static void evse_event_handler(void *arg, esp_event_base_t base, int32_t id, voi
|
||||
buzzer_evt.pattern = BUZZER_PATTERN_CHARGING;
|
||||
break;
|
||||
case EVSE_STATE_EVENT_FAULT:
|
||||
// Preempta qualquer beep em andamento
|
||||
buzzer_stop();
|
||||
buzzer_evt.pattern = BUZZER_PATTERN_FAULT;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
@@ -159,47 +411,56 @@ static void evse_event_handler(void *arg, esp_event_base_t base, int32_t id, voi
|
||||
esp_event_post(BUZZER_EVENTS, BUZZER_EVENT_PLAY_PATTERN, &buzzer_evt, sizeof(buzzer_evt), portMAX_DELAY);
|
||||
}
|
||||
|
||||
static void network_event_handler(void *handler_args, esp_event_base_t base, int32_t id, void *event_data) {
|
||||
if (id == NETWORK_EVENT_AP_STARTED) {
|
||||
buzzer_event_data_t evt = {
|
||||
.pattern = BUZZER_PATTERN_AP_START
|
||||
};
|
||||
static void network_event_handler(void *handler_args, esp_event_base_t base, int32_t id, void *event_data)
|
||||
{
|
||||
if (base != NETWORK_EVENTS)
|
||||
return;
|
||||
if (id == NETWORK_EVENT_AP_STARTED)
|
||||
{
|
||||
buzzer_event_data_t evt = {.pattern = BUZZER_PATTERN_AP_START};
|
||||
esp_event_post(BUZZER_EVENTS, BUZZER_EVENT_PLAY_PATTERN, &evt, sizeof(evt), portMAX_DELAY);
|
||||
}
|
||||
}
|
||||
|
||||
static void auth_event_handler(void *arg, esp_event_base_t base, int32_t id, void *event_data) {
|
||||
if (base != AUTH_EVENTS || event_data == NULL) return;
|
||||
static void auth_event_handler(void *arg, esp_event_base_t base, int32_t id, void *event_data)
|
||||
{
|
||||
if (base != AUTH_EVENTS || event_data == NULL)
|
||||
return;
|
||||
|
||||
buzzer_event_data_t buzzer_evt = {0};
|
||||
|
||||
if (id == AUTH_EVENT_TAG_PROCESSED) {
|
||||
if (id == AUTH_EVENT_TAG_PROCESSED)
|
||||
{
|
||||
const auth_tag_event_data_t *evt = (const auth_tag_event_data_t *)event_data;
|
||||
ESP_LOGI(TAG, "AUTH processed: tag=%s authorized=%d", evt->tag, evt->authorized);
|
||||
ESP_LOGD(TAG, "AUTH processed: tag=%s authorized=%d", evt->tag, evt->authorized);
|
||||
buzzer_evt.pattern = evt->authorized ? BUZZER_PATTERN_CARD_READ : BUZZER_PATTERN_CARD_DENIED;
|
||||
} else if (id == AUTH_EVENT_TAG_SAVED) {
|
||||
}
|
||||
else if (id == AUTH_EVENT_TAG_SAVED)
|
||||
{
|
||||
buzzer_evt.pattern = BUZZER_PATTERN_CARD_ADD;
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
esp_event_post(BUZZER_EVENTS, BUZZER_EVENT_PLAY_PATTERN, &buzzer_evt, sizeof(buzzer_evt), portMAX_DELAY);
|
||||
}
|
||||
|
||||
// --- Inicialização ---
|
||||
void buzzer_init(void) {
|
||||
if (s_buzzer_cfg.mode == BUZZER_MODE_PASSIVE) {
|
||||
// Configura temporizador do PWM
|
||||
// ===================== Inicialização / Deinit =====================
|
||||
void buzzer_init(void)
|
||||
{
|
||||
// Config HW
|
||||
if (s_buzzer_cfg.mode == BUZZER_MODE_PASSIVE)
|
||||
{
|
||||
ledc_timer_config_t tcfg = {
|
||||
.speed_mode = s_buzzer_cfg.ledc_speed_mode,
|
||||
.duty_resolution = s_buzzer_cfg.duty_resolution,
|
||||
.timer_num = s_buzzer_cfg.ledc_timer,
|
||||
.freq_hz = s_buzzer_cfg.freq_hz,
|
||||
.clk_cfg = LEDC_AUTO_CLK
|
||||
};
|
||||
.clk_cfg = LEDC_AUTO_CLK};
|
||||
ESP_ERROR_CHECK(ledc_timer_config(&tcfg));
|
||||
|
||||
// Configura canal PWM
|
||||
ledc_channel_config_t ccfg = {
|
||||
.gpio_num = s_buzzer_cfg.gpio,
|
||||
.speed_mode = s_buzzer_cfg.ledc_speed_mode,
|
||||
@@ -207,45 +468,74 @@ void buzzer_init(void) {
|
||||
.intr_type = LEDC_INTR_DISABLE,
|
||||
.timer_sel = s_buzzer_cfg.ledc_timer,
|
||||
.duty = 0,
|
||||
.hpoint = 0
|
||||
};
|
||||
.hpoint = 0};
|
||||
ESP_ERROR_CHECK(ledc_channel_config(&ccfg));
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
gpio_config_t io = {
|
||||
.pin_bit_mask = (1ULL << s_buzzer_cfg.gpio),
|
||||
.mode = GPIO_MODE_OUTPUT,
|
||||
.pull_down_en = 0,
|
||||
.pull_up_en = 0,
|
||||
.intr_type = GPIO_INTR_DISABLE
|
||||
};
|
||||
gpio_config(&io);
|
||||
.intr_type = GPIO_INTR_DISABLE};
|
||||
ESP_ERROR_CHECK(gpio_config(&io));
|
||||
gpio_set_level(s_buzzer_cfg.gpio, 0);
|
||||
}
|
||||
|
||||
buzzer_set_quiet_hours(false, 0, 0);
|
||||
buzzer_set_enabled(true);
|
||||
|
||||
buzzer_off();
|
||||
|
||||
// Registro de handlers
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(BUZZER_EVENTS,
|
||||
BUZZER_EVENT_PLAY_PATTERN,
|
||||
buzzer_event_handler,
|
||||
NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(EVSE_EVENTS,
|
||||
EVSE_EVENT_STATE_CHANGED,
|
||||
evse_event_handler,
|
||||
NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(AUTH_EVENTS,
|
||||
AUTH_EVENT_TAG_PROCESSED,
|
||||
auth_event_handler,
|
||||
NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(AUTH_EVENTS,
|
||||
AUTH_EVENT_TAG_SAVED,
|
||||
auth_event_handler,
|
||||
NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(NETWORK_EVENTS,
|
||||
NETWORK_EVENT_AP_STARTED,
|
||||
network_event_handler,
|
||||
NULL));
|
||||
// Fila + Task
|
||||
s_buzzer_q = xQueueCreate(CONFIG_BUZZER_QUEUE_LEN, sizeof(buzzer_pattern_id_t));
|
||||
configASSERT(s_buzzer_q != NULL);
|
||||
BaseType_t ok = xTaskCreatePinnedToCore(
|
||||
buzzer_task,
|
||||
"buzzer_task",
|
||||
CONFIG_BUZZER_TASK_STACK,
|
||||
NULL,
|
||||
CONFIG_BUZZER_TASK_PRIO,
|
||||
&s_buzzer_task,
|
||||
tskNO_AFFINITY);
|
||||
configASSERT(ok == pdPASS);
|
||||
|
||||
ESP_LOGI(TAG, "Buzzer initialized on GPIO %d (%s)",
|
||||
// Handlers
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(BUZZER_EVENTS, BUZZER_EVENT_PLAY_PATTERN, buzzer_event_handler, NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(EVSE_EVENTS, EVSE_EVENT_STATE_CHANGED, evse_event_handler, NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(AUTH_EVENTS, AUTH_EVENT_TAG_PROCESSED, auth_event_handler, NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(AUTH_EVENTS, AUTH_EVENT_TAG_SAVED, auth_event_handler, NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(NETWORK_EVENTS, NETWORK_EVENT_AP_STARTED, network_event_handler, NULL));
|
||||
|
||||
ESP_LOGI(TAG, "Buzzer initialized on GPIO %d (%s), freq=%lu Hz, duty=%u%%, enabled=%d",
|
||||
s_buzzer_cfg.gpio,
|
||||
s_buzzer_cfg.mode == BUZZER_MODE_PASSIVE ? "passive/PWM" : "active/ON-OFF");
|
||||
s_buzzer_cfg.mode == BUZZER_MODE_PASSIVE ? "passive/PWM" : "active/ON-OFF",
|
||||
(unsigned long)s_buzzer_cfg.freq_hz,
|
||||
(unsigned)s_buzzer_cfg.duty_percent,
|
||||
(int)s_buzzer_ctl.enabled);
|
||||
}
|
||||
|
||||
void buzzer_deinit(void)
|
||||
{
|
||||
(void)esp_event_handler_unregister(BUZZER_EVENTS, BUZZER_EVENT_PLAY_PATTERN, buzzer_event_handler);
|
||||
(void)esp_event_handler_unregister(EVSE_EVENTS, EVSE_EVENT_STATE_CHANGED, evse_event_handler);
|
||||
(void)esp_event_handler_unregister(AUTH_EVENTS, AUTH_EVENT_TAG_PROCESSED, auth_event_handler);
|
||||
(void)esp_event_handler_unregister(AUTH_EVENTS, AUTH_EVENT_TAG_SAVED, auth_event_handler);
|
||||
(void)esp_event_handler_unregister(NETWORK_EVENTS, NETWORK_EVENT_AP_STARTED, network_event_handler);
|
||||
|
||||
if (s_buzzer_q)
|
||||
{
|
||||
vQueueDelete(s_buzzer_q);
|
||||
s_buzzer_q = NULL;
|
||||
}
|
||||
|
||||
if (s_buzzer_task)
|
||||
{
|
||||
vTaskDelete(s_buzzer_task);
|
||||
s_buzzer_task = NULL;
|
||||
}
|
||||
|
||||
buzzer_off();
|
||||
ESP_LOGI(TAG, "Buzzer deinitialized");
|
||||
}
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
// === Início de: components/evse/evse_manager.c ===
|
||||
#include "evse_manager.h"
|
||||
#include "evse_state.h"
|
||||
#include "evse_error.h"
|
||||
@@ -14,6 +15,7 @@
|
||||
#include "freertos/queue.h"
|
||||
#include "esp_log.h"
|
||||
#include <string.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
#include "auth_events.h"
|
||||
#include "loadbalancer_events.h"
|
||||
@@ -25,8 +27,46 @@ static const char *TAG = "EVSE_Manager";
|
||||
static SemaphoreHandle_t evse_mutex;
|
||||
static bool auth_enabled = false;
|
||||
|
||||
// Estado de pausa controlado pelo Load Balancer
|
||||
static bool lb_paused = false;
|
||||
static bool lb_prev_authorized = false;
|
||||
|
||||
#define EVSE_MANAGER_TICK_PERIOD_MS 1000 // 1 segundo
|
||||
|
||||
// ================= Helpers internos =================
|
||||
|
||||
static void lb_clear_pause_state(void)
|
||||
{
|
||||
lb_paused = false;
|
||||
lb_prev_authorized = false;
|
||||
}
|
||||
|
||||
static void evse_manager_handle_auth_on_tick(void)
|
||||
{
|
||||
if (auth_enabled)
|
||||
{
|
||||
// Se o carro foi desconectado, revoga autorização
|
||||
if (evse_state_get_authorized() && evse_get_state() == EVSE_STATE_A)
|
||||
{
|
||||
ESP_LOGI(TAG, "Vehicle disconnected → revoking authorization.");
|
||||
evse_state_set_authorized(false);
|
||||
// Desconexão física invalida qualquer pausa pendente do LB
|
||||
lb_clear_pause_state();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Se autenticação está desativada, garante autorização sempre ativa
|
||||
if (!evse_state_get_authorized())
|
||||
{
|
||||
evse_state_set_authorized(true);
|
||||
ESP_LOGI(TAG, "Authentication disabled → forced authorization.");
|
||||
// Em modo OPEN, pausa do LB não é tão relevante, mas limpamos mesmo assim
|
||||
lb_clear_pause_state();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ===== Task de ciclo principal =====
|
||||
static void evse_manager_task(void *arg)
|
||||
{
|
||||
@@ -51,6 +91,9 @@ static void on_auth_event(void *arg, esp_event_base_t base, int32_t id, void *da
|
||||
const auth_tag_event_data_t *evt = (const auth_tag_event_data_t *)data;
|
||||
ESP_LOGI(TAG, "Tag %s -> %s", evt->tag, evt->authorized ? "AUTHORIZED" : "DENIED");
|
||||
evse_state_set_authorized(evt->authorized);
|
||||
|
||||
// Qualquer alteração explícita de auth invalida pausa do LB
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -70,6 +113,9 @@ static void on_auth_event(void *arg, esp_event_base_t base, int32_t id, void *da
|
||||
evse_state_set_authorized(false);
|
||||
auth_enabled = true;
|
||||
}
|
||||
|
||||
// Modo mudou -> qualquer pausa antiga deixa de fazer sentido
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -83,14 +129,96 @@ static void on_loadbalancer_event(void *handler_arg, esp_event_base_t event_base
|
||||
{
|
||||
const loadbalancer_state_event_t *evt = (const loadbalancer_state_event_t *)event_data;
|
||||
ESP_LOGI(TAG, "Loadbalancer %s (ts: %lld)",
|
||||
evt->enabled ? "ENABLED" : "DISABLED", evt->timestamp_us);
|
||||
evt->enabled ? "ENABLED" : "DISABLED",
|
||||
(long long)evt->timestamp_us);
|
||||
// Ações adicionais podem ser adicionadas aqui conforme necessário
|
||||
}
|
||||
else if (event_id == LOADBALANCER_EVENT_MASTER_CURRENT_LIMIT)
|
||||
{
|
||||
const loadbalancer_master_limit_event_t *evt = (const loadbalancer_master_limit_event_t *)event_data;
|
||||
ESP_LOGI(TAG, "Novo limite de corrente (master): %u A (ts: %lld)", evt->max_current, evt->timestamp_us);
|
||||
const loadbalancer_master_limit_event_t *evt =
|
||||
(const loadbalancer_master_limit_event_t *)event_data;
|
||||
|
||||
ESP_LOGI(TAG,
|
||||
"Novo limite de corrente (master): %u A (ts: %lld)",
|
||||
evt->max_current, (long long)evt->timestamp_us);
|
||||
|
||||
if (evt->max_current == 0)
|
||||
{
|
||||
// Suspensão por LB (não interessa se é OPEN ou RFID/OCPP)
|
||||
lb_paused = true;
|
||||
lb_prev_authorized = evse_state_get_authorized();
|
||||
|
||||
if (lb_prev_authorized)
|
||||
{
|
||||
ESP_LOGI(TAG, "[LB] limit=0A → pausando sessão (authorized=false)");
|
||||
evse_state_set_authorized(false);
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGD(TAG, "[LB] limit=0A → já não estava autorizado");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Ajusta corrente em runtime
|
||||
evse_set_runtime_charging_current(evt->max_current);
|
||||
|
||||
if (lb_paused)
|
||||
{
|
||||
lb_paused = false;
|
||||
|
||||
// Só retomamos se EVSE estiver operacional
|
||||
bool can_resume =
|
||||
(evse_get_error() == 0) &&
|
||||
evse_config_is_available() &&
|
||||
evse_config_is_enabled();
|
||||
|
||||
if (!can_resume)
|
||||
{
|
||||
ESP_LOGW(TAG,
|
||||
"[LB] limit=%uA → não retoma automaticamente (erro/indisponível/desabilitado)",
|
||||
evt->max_current);
|
||||
lb_clear_pause_state();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!auth_enabled)
|
||||
{
|
||||
// Modo OPEN: retoma sempre
|
||||
ESP_LOGI(TAG,
|
||||
"[LB] limit=%uA → modo OPEN, reautorizando (authorized=true)",
|
||||
evt->max_current);
|
||||
evse_state_set_authorized(true);
|
||||
}
|
||||
else
|
||||
{
|
||||
// RFID/OCPP: só retoma se havia autorização antes da pausa
|
||||
if (lb_prev_authorized)
|
||||
{
|
||||
ESP_LOGI(TAG,
|
||||
"[LB] limit=%uA → RFID/OCPP, retomando autorização anterior (auto-resume)",
|
||||
evt->max_current);
|
||||
evse_state_set_authorized(true);
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGI(TAG,
|
||||
"[LB] limit=%uA → RFID/OCPP, sem autorização prévia, mantendo estado atual",
|
||||
evt->max_current);
|
||||
}
|
||||
}
|
||||
|
||||
// Limpa estado prévio (não reaplicar em pausas futuras)
|
||||
lb_prev_authorized = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Caso normal: apenas ajuste de corrente, sem mexer em auth
|
||||
ESP_LOGD(TAG,
|
||||
"[LB] limit=%uA → ajustando corrente runtime (sem mudança de autorização)",
|
||||
evt->max_current);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -104,38 +232,46 @@ static void on_ocpp_event(void *arg, esp_event_base_t base, int32_t id, void *da
|
||||
case OCPP_EVENT_AUTHORIZED:
|
||||
ESP_LOGI(TAG, "[OCPP] Authorized");
|
||||
evse_state_set_authorized(true);
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
|
||||
case OCPP_EVENT_AUTH_REJECTED:
|
||||
ESP_LOGW(TAG, "[OCPP] Authorization rejected");
|
||||
evse_state_set_authorized(false);
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
|
||||
case OCPP_EVENT_AUTH_TIMEOUT:
|
||||
ESP_LOGW(TAG, "[OCPP] Authorization timeout");
|
||||
evse_state_set_authorized(false);
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
|
||||
case OCPP_EVENT_REMOTE_START:
|
||||
ESP_LOGI(TAG, "[OCPP] RemoteStart");
|
||||
evse_state_set_authorized(true);
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
|
||||
case OCPP_EVENT_REMOTE_STOP:
|
||||
ESP_LOGI(TAG, "[OCPP] RemoteStop");
|
||||
evse_state_set_authorized(false);
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
|
||||
case OCPP_EVENT_START_TX:
|
||||
ESP_LOGI(TAG, "[OCPP] StartTx");
|
||||
// StartTx em si não precisa mexer em auth, mas limpamos estado de pausa por segurança
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
|
||||
case OCPP_EVENT_STOP_TX:
|
||||
ESP_LOGI(TAG, "[OCPP] StopTx");
|
||||
evse_state_set_authorized(false);
|
||||
lb_clear_pause_state();
|
||||
break;
|
||||
|
||||
// hegou ChangeAvailability remoto (operative/inoperative)
|
||||
// ChangeAvailability remoto (operative/inoperative)
|
||||
case OCPP_EVENT_OPERATIVE_UPDATED:
|
||||
{
|
||||
if (!data)
|
||||
@@ -149,6 +285,8 @@ static void on_ocpp_event(void *arg, esp_event_base_t base, int32_t id, void *da
|
||||
|
||||
// Mapear operative → enabled local (persiste e emite EVSE_EVENT_ENABLE_UPDATED)
|
||||
evse_config_set_enabled(ev->operative);
|
||||
// Opcional: poderias também limpar a pausa aqui, dependendo da política
|
||||
// lb_clear_pause_state();
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -172,7 +310,7 @@ void evse_manager_init(void)
|
||||
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(AUTH_EVENTS, ESP_EVENT_ANY_ID, &on_auth_event, NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(LOADBALANCER_EVENTS, ESP_EVENT_ANY_ID, &on_loadbalancer_event, NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(OCPP_EVENTS, ESP_EVENT_ANY_ID, &on_ocpp_event, NULL)); // <— AQUI
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(OCPP_EVENTS, ESP_EVENT_ANY_ID, &on_ocpp_event, NULL));
|
||||
|
||||
ESP_LOGI(TAG, "EVSE Manager inicializado.");
|
||||
xTaskCreate(evse_manager_task, "evse_manager_task", 4096, NULL, 5, NULL);
|
||||
@@ -189,24 +327,8 @@ void evse_manager_tick(void)
|
||||
evse_temperature_check();
|
||||
evse_session_tick();
|
||||
|
||||
if (auth_enabled)
|
||||
{
|
||||
// If the car is disconnected, revoke authorization
|
||||
if (evse_state_get_authorized() && evse_get_state() == EVSE_STATE_A)
|
||||
{
|
||||
ESP_LOGI(TAG, "Vehicle disconnected → revoking authorization.");
|
||||
evse_state_set_authorized(false);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// If authentication is disabled, ensure authorization is always granted
|
||||
if (!evse_state_get_authorized())
|
||||
{
|
||||
evse_state_set_authorized(true);
|
||||
ESP_LOGI(TAG, "Authentication disabled → forced authorization.");
|
||||
}
|
||||
}
|
||||
evse_manager_handle_auth_on_tick();
|
||||
|
||||
xSemaphoreGive(evse_mutex);
|
||||
}
|
||||
// === Fim de: components/evse/evse_manager.c ===
|
||||
|
||||
@@ -45,7 +45,7 @@ void evse_meter_on_meter_event(void *arg, void *event_data)
|
||||
meter_data.voltage[i] = evt->vrms[i];
|
||||
meter_data.current[i] = evt->irms[i];
|
||||
}
|
||||
meter_data.energy_wh = (uint32_t)(evt->total_energy * 1000.0f);
|
||||
meter_data.energy_wh = (uint32_t)(evt->total_energy);
|
||||
xSemaphoreGive(meter_mutex);
|
||||
|
||||
ESP_LOGI(TAG,
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
#include "esp_log.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "freertos/semphr.h"
|
||||
#include "input_filter.h"
|
||||
#include "nvs_flash.h"
|
||||
#include "nvs.h"
|
||||
@@ -25,6 +26,16 @@ static const char *TAG = "loadbalancer";
|
||||
#define MIN_GRID_CURRENT_LIMIT 6 // A
|
||||
#define MAX_GRID_CURRENT_LIMIT 100 // A
|
||||
|
||||
// Pequena tolerância para considerar "sem margem"
|
||||
#define AVAILABLE_EPS 1.0f
|
||||
|
||||
// Histerese de suspensão / retoma (em torno dos 6A)
|
||||
#define LB_SUSPEND_THRESHOLD 5.0f // abaixo disto -> suspende
|
||||
#define LB_RESUME_THRESHOLD 7.0f // acima disto -> pode retomar
|
||||
|
||||
// Timeout para perda de medição de GRID (fail-safe)
|
||||
#define GRID_METER_TIMEOUT_US (10LL * 1000000LL) // 30 segundos
|
||||
|
||||
// Parâmetros
|
||||
static uint8_t max_grid_current = MAX_GRID_CURRENT_LIMIT;
|
||||
static bool loadbalancer_enabled = false;
|
||||
@@ -34,9 +45,14 @@ static float evse_current = 0.0f;
|
||||
static input_filter_t grid_filter;
|
||||
static input_filter_t evse_filter;
|
||||
|
||||
static int64_t last_grid_timestamp_us = 0; // última atualização de medição GRID
|
||||
|
||||
#define MAX_SLAVES 255
|
||||
#define CONNECTOR_COUNT (MAX_SLAVES + 1)
|
||||
|
||||
// Proteção simples de concorrência
|
||||
static SemaphoreHandle_t lb_mutex = NULL;
|
||||
|
||||
// Estrutura unificada para master e slaves
|
||||
typedef struct
|
||||
{
|
||||
@@ -45,9 +61,12 @@ typedef struct
|
||||
bool charging;
|
||||
float hw_max_current;
|
||||
float runtime_current;
|
||||
int64_t timestamp; // microssegundos
|
||||
int64_t timestamp; // microssegundos (última métrica EVSE/slave)
|
||||
bool online;
|
||||
float assigned;
|
||||
float assigned; // limite calculado pelo LB
|
||||
int64_t started_us; // início da sessão de carregamento (para prioridade)
|
||||
uint16_t last_limit; // último max_current enviado
|
||||
bool suspended_by_lb; // flag de suspensão por LB (para histerese)
|
||||
} evse_connector_t;
|
||||
|
||||
static evse_connector_t connectors[CONNECTOR_COUNT];
|
||||
@@ -66,7 +85,11 @@ static void init_connectors(void)
|
||||
.runtime_current = 0,
|
||||
.timestamp = 0,
|
||||
.online = false,
|
||||
.assigned = 0.0f};
|
||||
.assigned = 0.0f,
|
||||
.started_us = 0,
|
||||
.last_limit = 0,
|
||||
.suspended_by_lb = false};
|
||||
|
||||
// slaves em 1..CONNECTOR_COUNT-1
|
||||
for (int i = 1; i < CONNECTOR_COUNT; i++)
|
||||
{
|
||||
@@ -78,7 +101,10 @@ static void init_connectors(void)
|
||||
.runtime_current = 0.0f,
|
||||
.timestamp = 0,
|
||||
.online = false,
|
||||
.assigned = 0.0f};
|
||||
.assigned = 0.0f,
|
||||
.started_us = 0,
|
||||
.last_limit = 0,
|
||||
.suspended_by_lb = false};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -100,12 +126,30 @@ static void on_slave_status(void *handler_arg, esp_event_base_t base, int32_t id
|
||||
}
|
||||
|
||||
int idx = status->slave_id + 1; // slaves começam no índice 1
|
||||
|
||||
bool was_charging;
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
was_charging = connectors[idx].charging;
|
||||
|
||||
connectors[idx].charging = status->charging;
|
||||
connectors[idx].hw_max_current = status->hw_max_current;
|
||||
connectors[idx].runtime_current = status->runtime_current;
|
||||
connectors[idx].timestamp = esp_timer_get_time();
|
||||
connectors[idx].online = true;
|
||||
|
||||
// Se começou agora a carregar, marca início da sessão
|
||||
if (status->charging && !was_charging)
|
||||
{
|
||||
connectors[idx].started_us = connectors[idx].timestamp;
|
||||
connectors[idx].suspended_by_lb = false; // reset
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
|
||||
ESP_LOGI(TAG,
|
||||
"Slave %d status: charging=%d hw_max_current=%.1fA runtime_current=%.2fA",
|
||||
status->slave_id, status->charging,
|
||||
@@ -120,33 +164,62 @@ static void on_evse_config_event(void *handler_arg,
|
||||
const evse_config_event_data_t *evt = (const evse_config_event_data_t *)event_data;
|
||||
|
||||
int idx = 0; // MASTER INDICE 0
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
connectors[idx].charging = evt->charging;
|
||||
connectors[idx].hw_max_current = evt->hw_max_current;
|
||||
connectors[idx].runtime_current = evt->runtime_current;
|
||||
connectors[idx].timestamp = esp_timer_get_time();
|
||||
connectors[idx].online = true;
|
||||
|
||||
if (!evt->charging)
|
||||
{
|
||||
connectors[idx].suspended_by_lb = false;
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
|
||||
ESP_LOGI(TAG, "EVSE config updated: charging=%d hw_max_current=%.1f runtime_current=%.1f",
|
||||
evt->charging, evt->hw_max_current, evt->runtime_current);
|
||||
}
|
||||
|
||||
// --- Handlers de eventos externos ---
|
||||
static void loadbalancer_meter_event_handler(void *handler_arg,
|
||||
esp_event_base_t base,
|
||||
int32_t id,
|
||||
void *event_data)
|
||||
static void loadbalancer_meter_event_handler(void *handler_arg, esp_event_base_t base, int32_t id, void *event_data)
|
||||
{
|
||||
if (id != METER_EVENT_DATA_READY || event_data == NULL)
|
||||
return;
|
||||
|
||||
const meter_event_data_t *evt = (const meter_event_data_t *)event_data;
|
||||
float max_irms = evt->irms[0];
|
||||
for (int i = 1; i < 3; ++i)
|
||||
{
|
||||
if (evt->irms[i] > max_irms)
|
||||
{
|
||||
max_irms = evt->irms[i];
|
||||
}
|
||||
}
|
||||
|
||||
float max_vrms = evt->vrms[0];
|
||||
for (int i = 1; i < 3; ++i)
|
||||
{
|
||||
if (evt->vrms[i] > max_vrms)
|
||||
{
|
||||
max_vrms = evt->vrms[i];
|
||||
}
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
if (evt->source && strcmp(evt->source, "GRID") == 0)
|
||||
{
|
||||
grid_current = input_filter_update(&grid_filter, max_irms);
|
||||
last_grid_timestamp_us = esp_timer_get_time();
|
||||
ESP_LOGI(TAG, "GRID IRMS (filtered): %.2f A", grid_current);
|
||||
ESP_LOGI(TAG, "GRID VRMS: %.2f V", max_vrms);
|
||||
}
|
||||
else if (evt->source && strcmp(evt->source, "EVSE") == 0)
|
||||
{
|
||||
@@ -157,6 +230,9 @@ static void loadbalancer_meter_event_handler(void *handler_arg,
|
||||
{
|
||||
ESP_LOGW(TAG, "Unknown meter event source: %s", evt->source);
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
}
|
||||
|
||||
static void loadbalancer_evse_event_handler(void *handler_arg,
|
||||
@@ -166,6 +242,9 @@ static void loadbalancer_evse_event_handler(void *handler_arg,
|
||||
{
|
||||
const evse_state_event_data_t *evt = (const evse_state_event_data_t *)event_data;
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
switch (evt->state)
|
||||
{
|
||||
case EVSE_STATE_EVENT_IDLE:
|
||||
@@ -175,29 +254,45 @@ static void loadbalancer_evse_event_handler(void *handler_arg,
|
||||
evt->state == EVSE_STATE_EVENT_IDLE ? "dis" : "");
|
||||
connectors[0].charging = false;
|
||||
connectors[0].online = true; // master está sempre online
|
||||
connectors[0].suspended_by_lb = false;
|
||||
break;
|
||||
|
||||
case EVSE_STATE_EVENT_CHARGING:
|
||||
{
|
||||
ESP_LOGI(TAG, "Local EVSE is CHARGING - resetting filters");
|
||||
grid_current = 0.0f;
|
||||
evse_current = 0.0f;
|
||||
input_filter_reset(&grid_filter);
|
||||
input_filter_reset(&evse_filter);
|
||||
|
||||
bool was_charging = connectors[0].charging;
|
||||
|
||||
connectors[0].charging = true;
|
||||
connectors[0].online = true;
|
||||
connectors[0].timestamp = esp_timer_get_time();
|
||||
|
||||
if (!was_charging)
|
||||
{
|
||||
connectors[0].started_us = connectors[0].timestamp;
|
||||
connectors[0].suspended_by_lb = false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case EVSE_STATE_EVENT_FAULT:
|
||||
ESP_LOGW(TAG, "Local EVSE is in FAULT state - disabling load balancing temporarily");
|
||||
connectors[0].charging = false;
|
||||
connectors[0].online = true; // EVSE está online mas com falha
|
||||
connectors[0].suspended_by_lb = false;
|
||||
break;
|
||||
|
||||
default:
|
||||
ESP_LOGW(TAG, "Unknown EVSE state: %d", evt->state);
|
||||
break;
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
}
|
||||
|
||||
// --- Config persistência ---
|
||||
@@ -207,8 +302,10 @@ static esp_err_t loadbalancer_load_config()
|
||||
esp_err_t err = nvs_open("loadbalancing", NVS_READWRITE, &handle);
|
||||
if (err != ESP_OK)
|
||||
return err;
|
||||
|
||||
bool needs_commit = false;
|
||||
uint8_t temp_u8;
|
||||
|
||||
err = nvs_get_u8(handle, "max_grid_curr", &temp_u8);
|
||||
if (err == ESP_OK && temp_u8 >= MIN_GRID_CURRENT_LIMIT && temp_u8 <= MAX_GRID_CURRENT_LIMIT)
|
||||
max_grid_current = temp_u8;
|
||||
@@ -218,6 +315,7 @@ static esp_err_t loadbalancer_load_config()
|
||||
nvs_set_u8(handle, "max_grid_curr", max_grid_current);
|
||||
needs_commit = true;
|
||||
}
|
||||
|
||||
err = nvs_get_u8(handle, "enabled", &temp_u8);
|
||||
if (err == ESP_OK && temp_u8 <= 1)
|
||||
loadbalancer_enabled = (temp_u8 != 0);
|
||||
@@ -227,6 +325,7 @@ static esp_err_t loadbalancer_load_config()
|
||||
nvs_set_u8(handle, "enabled", 0);
|
||||
needs_commit = true;
|
||||
}
|
||||
|
||||
if (needs_commit)
|
||||
nvs_commit(handle);
|
||||
nvs_close(handle);
|
||||
@@ -280,7 +379,7 @@ void loadbalancer_task(void *param)
|
||||
{
|
||||
if (!loadbalancer_is_enabled())
|
||||
{
|
||||
vTaskDelay(pdMS_TO_TICKS(5000));
|
||||
vTaskDelay(pdMS_TO_TICKS(30000));
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -289,9 +388,11 @@ void loadbalancer_task(void *param)
|
||||
int64_t now = esp_timer_get_time();
|
||||
|
||||
// --- Atualiza estado online e conta ativos ---
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
for (int i = 0; i < CONNECTOR_COUNT; i++)
|
||||
{
|
||||
|
||||
// --- Master nunca pode ficar offline ---
|
||||
if (connectors[i].is_master)
|
||||
{
|
||||
@@ -334,26 +435,131 @@ void loadbalancer_task(void *param)
|
||||
}
|
||||
}
|
||||
|
||||
// snapshot de grid_current e last_grid_timestamp sob mutex
|
||||
float grid_snapshot = grid_current;
|
||||
int64_t last_grid_ts_snapshot = last_grid_timestamp_us;
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
|
||||
ESP_LOGI(TAG, "Active connectors: %d", active_cnt);
|
||||
|
||||
// --- Calcula corrente disponível ---
|
||||
float available = max_grid_current - grid_current;
|
||||
if (available < MIN_CHARGING_CURRENT_LIMIT)
|
||||
if (active_cnt == 0)
|
||||
{
|
||||
available = MIN_CHARGING_CURRENT_LIMIT;
|
||||
vTaskDelay(pdMS_TO_TICKS(5000));
|
||||
continue;
|
||||
}
|
||||
else if (available > max_grid_current)
|
||||
{
|
||||
available = max_grid_current;
|
||||
}
|
||||
ESP_LOGI(TAG, "LB Calc: available=%.1fA, active_connectors=%d", available, active_cnt);
|
||||
|
||||
// --- Ordena conectores por hw_max_current (bubble sort simples) ---
|
||||
// --- Verifica timeout de medição de GRID (fail-safe) ---
|
||||
bool meter_timeout = (last_grid_ts_snapshot == 0 ||
|
||||
(now - last_grid_ts_snapshot) > GRID_METER_TIMEOUT_US);
|
||||
|
||||
if (meter_timeout)
|
||||
{
|
||||
ESP_LOGW(TAG,
|
||||
"GRID meter timeout (last update=%lld us ago). Applying fail-safe limits (<=%dA).",
|
||||
(long long)(now - last_grid_ts_snapshot), MIN_CHARGING_CURRENT_LIMIT);
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
// Fail-safe: limitar cada EV ao mínimo permitido (6A) ou menos, nunca aumentar
|
||||
for (int k = 0; k < active_cnt; k++)
|
||||
{
|
||||
int i = idxs[k];
|
||||
float cur = connectors[i].runtime_current;
|
||||
if (cur > MIN_CHARGING_CURRENT_LIMIT)
|
||||
connectors[i].assigned = (float)MIN_CHARGING_CURRENT_LIMIT;
|
||||
else
|
||||
connectors[i].assigned = cur;
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
}
|
||||
|
||||
// --- Calcula corrente disponível (headroom global) ---
|
||||
float available = (float)max_grid_current - grid_snapshot;
|
||||
ESP_LOGI(TAG, "LB raw headroom: max_grid=%uA, grid_current=%.1fA, available=%.2fA",
|
||||
max_grid_current, grid_snapshot, available);
|
||||
|
||||
// ==========================
|
||||
// ZONA A: overload significativo -> reduzir correntes (throttling)
|
||||
// ==========================
|
||||
if (available < -AVAILABLE_EPS)
|
||||
{
|
||||
ESP_LOGW(TAG, "Overload: grid=%.1fA, max=%.1fA (available=%.2fA) -> throttling",
|
||||
grid_snapshot, (float)max_grid_current, available);
|
||||
|
||||
float factor = ((float)max_grid_current) / grid_snapshot;
|
||||
if (factor < 0.0f)
|
||||
factor = 0.0f;
|
||||
if (factor > 1.0f)
|
||||
factor = 1.0f;
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
for (int k = 0; k < active_cnt; k++)
|
||||
{
|
||||
int i = idxs[k];
|
||||
connectors[i].assigned = connectors[i].runtime_current * factor;
|
||||
ESP_LOGI(TAG,
|
||||
"Connector[%d] overload throttling: runtime=%.1fA -> assigned=%.1fA",
|
||||
i, connectors[i].runtime_current, connectors[i].assigned);
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
}
|
||||
// ==========================
|
||||
// ZONA B: sem margem prática -> manter correntes atuais como limites
|
||||
// ==========================
|
||||
else if (fabsf(available) <= AVAILABLE_EPS)
|
||||
{
|
||||
ESP_LOGI(TAG,
|
||||
"No effective headroom: grid=%.1fA, max=%.1fA (available=%.2fA). Keeping current as limit.",
|
||||
grid_snapshot, (float)max_grid_current, available);
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
for (int k = 0; k < active_cnt; k++)
|
||||
{
|
||||
int i = idxs[k];
|
||||
connectors[i].assigned = connectors[i].runtime_current;
|
||||
ESP_LOGI(TAG,
|
||||
"Connector[%d] keep runtime as limit: assigned=%.1fA",
|
||||
i, connectors[i].assigned);
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
}
|
||||
// ==========================
|
||||
// ZONA C: há margem positiva -> garantir mínimo e depois water-filling SOBRE assigned
|
||||
// ==========================
|
||||
else // available > AVAILABLE_EPS
|
||||
{
|
||||
if (available > max_grid_current)
|
||||
{
|
||||
available = (float)max_grid_current;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "LB Calc (zone C): available=%.1fA, active_connectors=%d",
|
||||
available, active_cnt);
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
// 1) Ordenar conectores ativos por started_us (mais antigos primeiro)
|
||||
for (int a = 0; a < active_cnt - 1; a++)
|
||||
{
|
||||
for (int b = 0; b < active_cnt - 1 - a; b++)
|
||||
{
|
||||
if (connectors[idxs[b]].hw_max_current > connectors[idxs[b + 1]].hw_max_current)
|
||||
int i1 = idxs[b];
|
||||
int i2 = idxs[b + 1];
|
||||
if (connectors[i1].started_us > connectors[i2].started_us)
|
||||
{
|
||||
int tmp = idxs[b];
|
||||
idxs[b] = idxs[b + 1];
|
||||
@@ -362,51 +568,179 @@ void loadbalancer_task(void *param)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Distribui corrente (water-filling) ---
|
||||
float remaining = available;
|
||||
int remaining_cnt = active_cnt;
|
||||
// Inicialmente: assigned = runtime_current
|
||||
for (int k = 0; k < active_cnt; k++)
|
||||
{
|
||||
int i = idxs[k];
|
||||
float share = remaining / remaining_cnt;
|
||||
if (share >= connectors[i].hw_max_current)
|
||||
connectors[i].assigned = connectors[i].runtime_current;
|
||||
}
|
||||
|
||||
float remaining = available; // margem extra total
|
||||
|
||||
// 2) FASE 1: tentar garantir pelo menos 6A (ou hw_max, se menor) aos mais antigos
|
||||
for (int k = 0; k < active_cnt && remaining > 0.0f; k++)
|
||||
{
|
||||
connectors[i].assigned = connectors[i].hw_max_current;
|
||||
remaining -= connectors[i].assigned;
|
||||
remaining_cnt--;
|
||||
int i = idxs[k];
|
||||
|
||||
float current = connectors[i].runtime_current;
|
||||
float hw_max = connectors[i].hw_max_current;
|
||||
|
||||
float target_min = (float)MIN_CHARGING_CURRENT_LIMIT;
|
||||
if (hw_max < target_min)
|
||||
target_min = hw_max;
|
||||
|
||||
if (current >= target_min)
|
||||
{
|
||||
connectors[i].assigned = current;
|
||||
continue;
|
||||
}
|
||||
|
||||
float delta = target_min - current;
|
||||
if (delta <= remaining)
|
||||
{
|
||||
connectors[i].assigned = current + delta;
|
||||
remaining -= delta;
|
||||
}
|
||||
else
|
||||
{
|
||||
connectors[i].assigned = current;
|
||||
}
|
||||
}
|
||||
|
||||
// 3) FASE 2: "last in, first cut" -> cortar quem ficou abaixo do mínimo começando pelos mais recentes
|
||||
for (int k = active_cnt - 1; k >= 0; k--)
|
||||
{
|
||||
int i = idxs[k];
|
||||
if (connectors[i].assigned >= MIN_CHARGING_CURRENT_LIMIT)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Connector[%d] below min after phase1 (assigned=%.1fA) -> suspending (0A)",
|
||||
i, connectors[i].assigned);
|
||||
connectors[i].assigned = 0.0f;
|
||||
connectors[i].suspended_by_lb = true;
|
||||
}
|
||||
|
||||
// 4) FASE 3: se ainda sobrar margem, distribuir extra por cima dos que ficaram ON (assigned > 0)
|
||||
if (remaining > AVAILABLE_EPS)
|
||||
{
|
||||
int on_cnt = 0;
|
||||
for (int k = 0; k < active_cnt; k++)
|
||||
{
|
||||
int i = idxs[k];
|
||||
if (connectors[i].assigned > 0.0f)
|
||||
on_cnt++;
|
||||
}
|
||||
|
||||
float extra_remaining = remaining;
|
||||
int extra_cnt = on_cnt;
|
||||
|
||||
for (int k = 0; k < active_cnt; k++)
|
||||
{
|
||||
int i = idxs[k];
|
||||
|
||||
if (connectors[i].assigned <= 0.0f)
|
||||
continue;
|
||||
|
||||
if (extra_cnt <= 0 || extra_remaining <= 0.0f)
|
||||
break;
|
||||
|
||||
float headroom = connectors[i].hw_max_current - connectors[i].assigned;
|
||||
if (headroom <= 0.0f)
|
||||
{
|
||||
extra_cnt--;
|
||||
continue;
|
||||
}
|
||||
|
||||
float share = extra_remaining / (float)extra_cnt;
|
||||
|
||||
if (share >= headroom)
|
||||
{
|
||||
connectors[i].assigned += headroom;
|
||||
extra_remaining -= headroom;
|
||||
extra_cnt--;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int m = k; m < active_cnt; m++)
|
||||
{
|
||||
connectors[idxs[m]].assigned = share;
|
||||
int j = idxs[m];
|
||||
|
||||
if (connectors[j].assigned <= 0.0f)
|
||||
continue;
|
||||
|
||||
float headroom_j = connectors[j].hw_max_current - connectors[j].assigned;
|
||||
if (headroom_j <= 0.0f)
|
||||
continue;
|
||||
|
||||
float inc = MIN(share, headroom_j);
|
||||
connectors[j].assigned += inc;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
}
|
||||
|
||||
// --- Publicação de limites / suspensão com histerese ---
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
|
||||
// --- Aplica piso mínimo ---
|
||||
for (int k = 0; k < active_cnt; k++)
|
||||
{
|
||||
int i = idxs[k];
|
||||
if (connectors[i].assigned < MIN_CHARGING_CURRENT_LIMIT)
|
||||
float assigned = connectors[i].assigned;
|
||||
float effective = assigned;
|
||||
|
||||
// Histerese de suspensão / retoma
|
||||
if (connectors[i].suspended_by_lb)
|
||||
{
|
||||
connectors[i].assigned = MIN_CHARGING_CURRENT_LIMIT;
|
||||
// Está suspenso: só retoma se limite calculado for >= limiar de retoma
|
||||
if (assigned >= LB_RESUME_THRESHOLD)
|
||||
{
|
||||
effective = assigned;
|
||||
connectors[i].suspended_by_lb = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
effective = 0.0f;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Ainda não está suspenso: só suspende se ficar claramente abaixo do limiar
|
||||
if (assigned > 0.0f && assigned < LB_SUSPEND_THRESHOLD)
|
||||
{
|
||||
effective = 0.0f;
|
||||
connectors[i].suspended_by_lb = true;
|
||||
}
|
||||
}
|
||||
|
||||
// --- Publica limites de corrente ---
|
||||
for (int k = 0; k < active_cnt; k++)
|
||||
uint16_t max_cur;
|
||||
if (effective <= 0.0f)
|
||||
{
|
||||
int i = idxs[k];
|
||||
uint16_t max_cur = (uint16_t)MIN(connectors[i].assigned, MAX_CHARGING_CURRENT_LIMIT);
|
||||
uint16_t current_rounded = (uint16_t)roundf(connectors[i].runtime_current);
|
||||
max_cur = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
max_cur = (uint16_t)MIN(effective, (float)MAX_CHARGING_CURRENT_LIMIT);
|
||||
}
|
||||
|
||||
if (current_rounded == max_cur)
|
||||
// Evita flapping de comandos: só envia se o limite mudou
|
||||
if (connectors[i].last_limit == max_cur)
|
||||
{
|
||||
continue; // sem alteração
|
||||
}
|
||||
|
||||
connectors[i].last_limit = max_cur;
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
|
||||
if (connectors[i].is_master)
|
||||
{
|
||||
loadbalancer_master_limit_event_t master_evt = {
|
||||
@@ -415,8 +749,8 @@ void loadbalancer_task(void *param)
|
||||
.timestamp_us = now};
|
||||
esp_event_post(LOADBALANCER_EVENTS, LOADBALANCER_EVENT_MASTER_CURRENT_LIMIT,
|
||||
&master_evt, sizeof(master_evt), portMAX_DELAY);
|
||||
ESP_LOGI(TAG, "Master limit changed -> %.1f A (runtime=%.1f A)",
|
||||
(float)max_cur, connectors[i].runtime_current);
|
||||
ESP_LOGI(TAG, "Master limit changed -> %.1f A (assigned=%.2f A)",
|
||||
(float)max_cur, assigned);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -426,11 +760,17 @@ void loadbalancer_task(void *param)
|
||||
.timestamp_us = now};
|
||||
esp_event_post(LOADBALANCER_EVENTS, LOADBALANCER_EVENT_SLAVE_CURRENT_LIMIT,
|
||||
&slave_evt, sizeof(slave_evt), portMAX_DELAY);
|
||||
ESP_LOGI(TAG, "Slave %d limit changed -> %.1f A (runtime=%.1f A)",
|
||||
connectors[i].id, (float)max_cur, connectors[i].runtime_current);
|
||||
ESP_LOGI(TAG, "Slave %d limit changed -> %.1f A (assigned=%.2f A)",
|
||||
connectors[i].id, (float)max_cur, assigned);
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreTake(lb_mutex, portMAX_DELAY);
|
||||
}
|
||||
|
||||
if (lb_mutex)
|
||||
xSemaphoreGive(lb_mutex);
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(5000));
|
||||
}
|
||||
}
|
||||
@@ -441,6 +781,12 @@ void loadbalancer_init(void)
|
||||
if (loadbalancer_load_config() != ESP_OK)
|
||||
ESP_LOGW(TAG, "Failed to load/init config. Using defaults.");
|
||||
|
||||
lb_mutex = xSemaphoreCreateMutex();
|
||||
if (lb_mutex == NULL)
|
||||
{
|
||||
ESP_LOGE(TAG, "Failed to create loadbalancer mutex");
|
||||
}
|
||||
|
||||
init_connectors();
|
||||
input_filter_init(&grid_filter, 0.3f);
|
||||
input_filter_init(&evse_filter, 0.3f);
|
||||
|
||||
@@ -3,7 +3,11 @@ set(srcs
|
||||
"driver/meter_ade7758/meter_ade7758.c"
|
||||
"driver/meter_ade7758/ade7758.c"
|
||||
"driver/meter_orno/meter_orno513.c"
|
||||
"driver/meter_orno/meter_orno526.c"
|
||||
"driver/meter_orno/meter_orno516.c"
|
||||
"driver/meter_orno/meter_dts6619.c"
|
||||
"driver/meter_orno/meter_dds661.c"
|
||||
"driver/meter_orno/meter_ea777.c"
|
||||
"driver/meter_orno/modbus_params.c"
|
||||
"driver/meter_zigbee/meter_zigbee.c"
|
||||
"src/meter_manager.c"
|
||||
|
||||
289
components/meter_manager/driver/meter_orno/meter_dds661.c
Executable file
289
components/meter_manager/driver/meter_orno/meter_dds661.c
Executable file
@@ -0,0 +1,289 @@
|
||||
// components/meter_manager/driver/meter_dds661.c
|
||||
|
||||
#include "meter_dds661.h"
|
||||
|
||||
#include "modbus_params.h"
|
||||
#include "mbcontroller.h"
|
||||
#include "meter_events.h"
|
||||
|
||||
#include "esp_log.h"
|
||||
#include "driver/uart.h"
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#define TAG "serial_mdb_dds661"
|
||||
|
||||
// ======= UART/Modbus config =======
|
||||
#define MB_PORT_NUM 2
|
||||
#define MB_DEV_SPEED 9600
|
||||
|
||||
// Ajuste os pinos conforme seu hardware (evite GPIO2 para RTS/DE/RE se possível)
|
||||
#define MB_UART_TXD 17
|
||||
#define MB_UART_RXD 16
|
||||
#define MB_UART_RTS 2 // pino DE/RE do transceiver RS-485
|
||||
|
||||
#define UPDATE_INTERVAL (3000 / portTICK_PERIOD_MS)
|
||||
#define POLL_INTERVAL (120 / portTICK_PERIOD_MS)
|
||||
|
||||
// ======= Helpers típicos do teu projeto =======
|
||||
#define HOLD_OFFSET(field) ((uint16_t)(offsetof(holding_reg_params_t, field) + 1))
|
||||
#define STR(x) ((const char *)(x))
|
||||
#define OPTS(min, max, step) {.opt1 = min, .opt2 = max, .opt3 = step}
|
||||
|
||||
// ======= Estado =======
|
||||
static bool is_initialized = false;
|
||||
static TaskHandle_t meter_task = NULL;
|
||||
|
||||
// ======= CIDs (sequenciais) =======
|
||||
enum
|
||||
{
|
||||
CID_VOLTAGE = 0,
|
||||
CID_CURRENT,
|
||||
CID_ACTIVE_POWER_KW,
|
||||
CID_POWER_FACTOR,
|
||||
CID_FREQUENCY,
|
||||
CID_TOTAL_ACTIVE_ENERGY_KWH,
|
||||
CID_COUNT
|
||||
};
|
||||
|
||||
// ======= Mapa de registradores (Input Registers; FC=0x04) =======
|
||||
// Endereços típicos para DDS-661 (float32):
|
||||
#define REG_VOLTAGE 0x0000 // V (float32)
|
||||
#define REG_CURRENT 0x0008 // A (float32)
|
||||
#define REG_ACTIVE_POWER_KW 0x0012 // kW (float32)
|
||||
#define REG_POWER_FACTOR 0x002A // PF (float32)
|
||||
#define REG_FREQUENCY 0x0036 // Hz (float32)
|
||||
#define REG_E_ACTIVE_KWH 0x0100 // kWh (float32)
|
||||
|
||||
// ======= Tabela de parâmetros (Data Dictionary) =======
|
||||
const mb_parameter_descriptor_t device_parameters_dds661[] = {
|
||||
{CID_VOLTAGE, "Voltage", "V", 1,
|
||||
MB_PARAM_INPUT, REG_VOLTAGE, 2, HOLD_OFFSET(l1_voltage),
|
||||
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
|
||||
|
||||
{CID_CURRENT, "Current", "A", 1,
|
||||
MB_PARAM_INPUT, REG_CURRENT, 2, HOLD_OFFSET(l1_current),
|
||||
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 100, 0.1), PAR_PERMS_READ},
|
||||
|
||||
{CID_ACTIVE_POWER_KW, "Active Power", "kW", 1,
|
||||
MB_PARAM_INPUT, REG_ACTIVE_POWER_KW, 2, HOLD_OFFSET(active_power),
|
||||
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(-100, 100, 0.01), PAR_PERMS_READ},
|
||||
|
||||
{CID_POWER_FACTOR, "Power Factor", "", 1,
|
||||
MB_PARAM_INPUT, REG_POWER_FACTOR, 2, HOLD_OFFSET(power_factor),
|
||||
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(-1, 1, 0.001), PAR_PERMS_READ},
|
||||
|
||||
{CID_FREQUENCY, "Frequency", "Hz", 1,
|
||||
MB_PARAM_INPUT, REG_FREQUENCY, 2, HOLD_OFFSET(frequency),
|
||||
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 100, 0.1), PAR_PERMS_READ},
|
||||
|
||||
{CID_TOTAL_ACTIVE_ENERGY_KWH, "Total Active Energy", "kWh", 1,
|
||||
MB_PARAM_INPUT, REG_E_ACTIVE_KWH, 2, HOLD_OFFSET(active_energy),
|
||||
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 1000000, 0.01), PAR_PERMS_READ},
|
||||
};
|
||||
|
||||
const uint16_t num_device_parameters_dds661 =
|
||||
sizeof(device_parameters_dds661) / sizeof(device_parameters_dds661[0]);
|
||||
|
||||
// ======= Ponteiro para buffer destino =======
|
||||
static void *get_param_ptr(const mb_parameter_descriptor_t *param)
|
||||
{
|
||||
if (!param || param->param_offset == 0)
|
||||
return NULL;
|
||||
return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
|
||||
}
|
||||
|
||||
// ======= Tarefa de aquisição =======
|
||||
static void serial_mdb_task(void *param)
|
||||
{
|
||||
esp_err_t err;
|
||||
const mb_parameter_descriptor_t *desc = NULL;
|
||||
|
||||
// Valores lidos
|
||||
float v = 0.0f; // V
|
||||
float i = 0.0f; // A
|
||||
float pf = 0.0f; // -
|
||||
float hz = 0.0f; // Hz
|
||||
float e_kwh = 0.0f; // kWh
|
||||
float p_kw = 0.0f; // kW
|
||||
|
||||
// Buffers para o evento
|
||||
float voltage[3] = {0};
|
||||
float current[3] = {0};
|
||||
int watt[3] = {0};
|
||||
|
||||
while (1)
|
||||
{
|
||||
for (uint16_t cid = 0; cid < num_device_parameters_dds661; cid++)
|
||||
{
|
||||
err = mbc_master_get_cid_info(cid, &desc);
|
||||
if (err != ESP_OK || !desc)
|
||||
{
|
||||
ESP_LOGE(TAG, "get_cid_info(%u) failed: %s", cid, esp_err_to_name(err));
|
||||
continue;
|
||||
}
|
||||
|
||||
void *data_ptr = get_param_ptr(desc);
|
||||
if (!data_ptr)
|
||||
{
|
||||
ESP_LOGE(TAG, "CID %u (%s): null data_ptr", cid, desc->param_key);
|
||||
continue;
|
||||
}
|
||||
|
||||
uint8_t type = 0;
|
||||
err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGE(TAG, "CID %u (%s) read failed: %s", cid, desc->param_key, esp_err_to_name(err));
|
||||
vTaskDelay(POLL_INTERVAL);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Dump dos bytes recebidos (4 bytes do float bruto)
|
||||
uint8_t raw[4];
|
||||
memcpy(raw, data_ptr, 4);
|
||||
ESP_LOGD(TAG, "CID %u (%s) raw bytes: %02X %02X %02X %02X",
|
||||
cid, desc->param_key, raw[0], raw[1], raw[2], raw[3]);
|
||||
|
||||
float val = 0.0f;
|
||||
|
||||
val = *(float *)data_ptr;
|
||||
|
||||
ESP_LOGD(TAG, "%s: %.3f %s", desc->param_key, val, desc->param_units);
|
||||
|
||||
switch (cid)
|
||||
{
|
||||
case CID_VOLTAGE:
|
||||
v = val;
|
||||
voltage[0] = v;
|
||||
break;
|
||||
case CID_CURRENT:
|
||||
i = val;
|
||||
current[0] = i;
|
||||
break;
|
||||
case CID_POWER_FACTOR:
|
||||
pf = val;
|
||||
break;
|
||||
case CID_FREQUENCY:
|
||||
hz = val;
|
||||
break;
|
||||
case CID_ACTIVE_POWER_KW:
|
||||
{
|
||||
p_kw = val;
|
||||
float p_w = p_kw * 1000.0f;
|
||||
int pwi = (int)lrintf(p_w);
|
||||
watt[0] = pwi;
|
||||
watt[1] = pwi;
|
||||
watt[2] = pwi;
|
||||
break;
|
||||
}
|
||||
case CID_TOTAL_ACTIVE_ENERGY_KWH:
|
||||
e_kwh = val;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
vTaskDelay(POLL_INTERVAL);
|
||||
}
|
||||
|
||||
meter_event_data_t evt = {
|
||||
.frequency = hz,
|
||||
.power_factor = pf,
|
||||
.total_energy = e_kwh,
|
||||
.source = "GRID",
|
||||
};
|
||||
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
|
||||
memcpy(evt.irms, current, sizeof(evt.irms));
|
||||
memcpy(evt.watt, watt, sizeof(evt.watt));
|
||||
|
||||
esp_event_post(METER_EVENT, METER_EVENT_DATA_READY, &evt, sizeof(evt), pdMS_TO_TICKS(10));
|
||||
vTaskDelay(UPDATE_INTERVAL);
|
||||
}
|
||||
}
|
||||
|
||||
// ======= API pública =======
|
||||
esp_err_t meter_dds661_init(void)
|
||||
{
|
||||
if (is_initialized)
|
||||
{
|
||||
ESP_LOGW(TAG, "meter_dds661 already initialized");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "meter_dds661_init");
|
||||
|
||||
mb_communication_info_t comm = {
|
||||
.port = MB_PORT_NUM,
|
||||
.mode = MB_MODE_RTU,
|
||||
.baudrate = MB_DEV_SPEED,
|
||||
.parity = UART_PARITY_EVEN, // DDS-661: 9600 8E1
|
||||
};
|
||||
|
||||
void *handler = NULL;
|
||||
ESP_ERROR_CHECK(mbc_master_init(MB_PORT_SERIAL_MASTER, &handler));
|
||||
ESP_ERROR_CHECK(mbc_master_setup(&comm));
|
||||
|
||||
// Pinos e parâmetros básicos
|
||||
ESP_ERROR_CHECK(uart_set_pin(MB_PORT_NUM, MB_UART_TXD, MB_UART_RXD, MB_UART_RTS, UART_PIN_NO_CHANGE));
|
||||
ESP_ERROR_CHECK(uart_set_word_length(MB_PORT_NUM, UART_DATA_8_BITS));
|
||||
ESP_ERROR_CHECK(uart_set_hw_flow_ctrl(MB_PORT_NUM, UART_HW_FLOWCTRL_DISABLE, 0));
|
||||
ESP_ERROR_CHECK(uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_1));
|
||||
|
||||
// >>> IMPORTANTE: start antes do set_mode <<<
|
||||
ESP_ERROR_CHECK(mbc_master_start());
|
||||
|
||||
// Só agora muda para RS485 half duplex
|
||||
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
|
||||
|
||||
// (opcional) logs de debug Modbus
|
||||
esp_log_level_set("MB_CONTROLLER_MASTER", ESP_LOG_DEBUG);
|
||||
esp_log_level_set("MB_PORT_COMMON", ESP_LOG_DEBUG);
|
||||
esp_log_level_set("MB_SERIAL_MASTER", ESP_LOG_DEBUG);
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(5));
|
||||
|
||||
ESP_ERROR_CHECK(mbc_master_set_descriptor(device_parameters_dds661, num_device_parameters_dds661));
|
||||
|
||||
is_initialized = true;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t meter_dds661_start(void)
|
||||
{
|
||||
if (!is_initialized)
|
||||
{
|
||||
ESP_LOGE(TAG, "meter_dds661 not initialized");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
|
||||
if (meter_task == NULL)
|
||||
{
|
||||
xTaskCreate(serial_mdb_task, "meter_dds661_task", 4096, NULL, 3, &meter_task);
|
||||
ESP_LOGI(TAG, "meter_dds661 task started");
|
||||
}
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
void meter_dds661_stop(void)
|
||||
{
|
||||
if (!is_initialized)
|
||||
{
|
||||
ESP_LOGW(TAG, "meter_dds661 not initialized");
|
||||
return;
|
||||
}
|
||||
ESP_LOGI(TAG, "Stopping meter_dds661");
|
||||
|
||||
// 1) Destrói o master primeiro
|
||||
esp_err_t err = mbc_master_destroy();
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGW(TAG, "mbc_master_destroy() returned %s", esp_err_to_name(err));
|
||||
}
|
||||
|
||||
// 2) Depois solta a UART
|
||||
uart_driver_delete(MB_PORT_NUM);
|
||||
|
||||
is_initialized = false;
|
||||
}
|
||||
29
components/meter_manager/driver/meter_orno/meter_dds661.h
Executable file
29
components/meter_manager/driver/meter_orno/meter_dds661.h
Executable file
@@ -0,0 +1,29 @@
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
/**
|
||||
* @brief Inicializa o driver do medidor DDS 661 (SPI, mutex, registradores).
|
||||
*/
|
||||
esp_err_t meter_dds661_init(void);
|
||||
|
||||
/**
|
||||
* @brief Inicia a tarefa de leitura de dados do medidor DDS 661.
|
||||
*/
|
||||
esp_err_t meter_dds661_start(void);
|
||||
|
||||
/**
|
||||
* @brief Para a tarefa de leitura e limpa os dados internos do medidor DDS 661.
|
||||
*/
|
||||
void meter_dds661_stop(void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
326
components/meter_manager/driver/meter_orno/meter_dts6619.c
Executable file
326
components/meter_manager/driver/meter_orno/meter_dts6619.c
Executable file
@@ -0,0 +1,326 @@
|
||||
// meter_dts6619.c — Driver Modbus RTU para SINOTIMER DTS6619 (ESP-IDF)
|
||||
|
||||
#include "meter_events.h"
|
||||
#include "modbus_params.h"
|
||||
#include "mbcontroller.h"
|
||||
#include "esp_log.h"
|
||||
#include "driver/uart.h"
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
|
||||
#define TAG "serial_mdb_dts6619"
|
||||
|
||||
// ===== UART / RS-485 =====
|
||||
#define MB_PORT_NUM 2
|
||||
#define MB_DEV_SPEED 9600
|
||||
|
||||
// Ajuste os pinos conforme seu hardware (evite GPIO2 para RTS/DE/RE se possível)
|
||||
#define MB_UART_TXD 17
|
||||
#define MB_UART_RXD 16
|
||||
#define MB_UART_RTS 2 // pino DE/RE do transceiver RS-485
|
||||
|
||||
// ===== Timings =====
|
||||
#define UPDATE_INTERVAL (5000 / portTICK_PERIOD_MS)
|
||||
#define POLL_INTERVAL (200 / portTICK_PERIOD_MS) // DTS6619 prefere >100 ms
|
||||
|
||||
// ===== Helpers =====
|
||||
#define HOLD_OFFSET(field) ((uint16_t)(offsetof(holding_reg_params_t, field) + 1))
|
||||
#define STR(fieldname) ((const char *)(fieldname))
|
||||
#define OPTS(min_val, max_val, step_val) {.opt1 = min_val, .opt2 = max_val, .opt3 = step_val}
|
||||
|
||||
// ===== Estado =====
|
||||
static bool is_initialized = false;
|
||||
static TaskHandle_t meter_task = NULL;
|
||||
|
||||
// ====== Config de endianness ======
|
||||
// 0: usa float lido direto; 1: faz word-swap (DTS6619 em alguns firmwares)
|
||||
#ifndef DTS6619_WORD_SWAP
|
||||
#define DTS6619_WORD_SWAP 0
|
||||
#endif
|
||||
|
||||
static inline float maybe_swap_float(float in)
|
||||
{
|
||||
#if DTS6619_WORD_SWAP
|
||||
// swap de words: 0-1-2-3 -> 2-3-0-1
|
||||
float out;
|
||||
char *src = (char *)∈
|
||||
char *dst = (char *)&out;
|
||||
dst[0] = src[2];
|
||||
dst[1] = src[3];
|
||||
dst[2] = src[0];
|
||||
dst[3] = src[1];
|
||||
return out;
|
||||
#else
|
||||
return in;
|
||||
#endif
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// =================== MAPA DE REGISTROS DTS6619 (Input 0x04) ===============
|
||||
// Todos float32, 2 regs cada, endereços zero-based
|
||||
// Tensões
|
||||
#define DTS_L1VOLTAGE 0x0000
|
||||
#define DTS_L2VOLTAGE 0x0002
|
||||
#define DTS_L3VOLTAGE 0x0004
|
||||
// Correntes (total e por fase)
|
||||
#define DTS_TOTALCURRENT 0x0006
|
||||
#define DTS_L1CURRENT 0x0008
|
||||
#define DTS_L2CURRENT 0x000A
|
||||
#define DTS_L3CURRENT 0x000C
|
||||
// Potências ativas
|
||||
#define DTS_TOTALACTIVEPOWER 0x0010
|
||||
#define DTS_L1ACTIVEPOWER 0x0012
|
||||
#define DTS_L2ACTIVEPOWER 0x0014
|
||||
#define DTS_L3ACTIVEPOWER 0x0016
|
||||
// Fator de potência (por fase)
|
||||
#define DTS_PF_L1 0x002A
|
||||
#define DTS_PF_L2 0x002C
|
||||
#define DTS_PF_L3 0x002E
|
||||
// Frequência
|
||||
#define DTS_FREQUENCY 0x0036
|
||||
// Energia total ativa (Wh)
|
||||
#define DTS_TOTAL_ACTIVE_ENERGY 0x0100
|
||||
// ============================================================================
|
||||
|
||||
// ============ CIDs ============
|
||||
enum
|
||||
{
|
||||
CID_L1_VOLTAGE = 0,
|
||||
CID_L2_VOLTAGE,
|
||||
CID_L3_VOLTAGE,
|
||||
CID_L1_CURRENT,
|
||||
CID_L2_CURRENT,
|
||||
CID_L3_CURRENT,
|
||||
};
|
||||
|
||||
// ======= Descritores (usando INPUT registers) =======
|
||||
const mb_parameter_descriptor_t device_parameters_dts6619[] = {
|
||||
{CID_L1_VOLTAGE, STR("L1 Voltage"), STR("V"), 1, MB_PARAM_INPUT, DTS_L1VOLTAGE, 2,
|
||||
HOLD_OFFSET(l1_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
|
||||
{CID_L2_VOLTAGE, STR("L2 Voltage"), STR("V"), 1, MB_PARAM_INPUT, DTS_L2VOLTAGE, 2,
|
||||
HOLD_OFFSET(l2_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
|
||||
{CID_L3_VOLTAGE, STR("L3 Voltage"), STR("V"), 1, MB_PARAM_INPUT, DTS_L3VOLTAGE, 2,
|
||||
HOLD_OFFSET(l3_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
|
||||
|
||||
{CID_L1_CURRENT, STR("L1 Current"), STR("A"), 1, MB_PARAM_INPUT, DTS_L1CURRENT, 2,
|
||||
HOLD_OFFSET(l1_current), PARAM_TYPE_FLOAT, 4, OPTS(0, 1000, 0.1), PAR_PERMS_READ},
|
||||
{CID_L2_CURRENT, STR("L2 Current"), STR("A"), 1, MB_PARAM_INPUT, DTS_L2CURRENT, 2,
|
||||
HOLD_OFFSET(l2_current), PARAM_TYPE_FLOAT, 4, OPTS(0, 1000, 0.1), PAR_PERMS_READ},
|
||||
{CID_L3_CURRENT, STR("L3 Current"), STR("A"), 1, MB_PARAM_INPUT, DTS_L3CURRENT, 2,
|
||||
HOLD_OFFSET(l3_current), PARAM_TYPE_FLOAT, 4, OPTS(0, 1000, 0.1), PAR_PERMS_READ},
|
||||
|
||||
};
|
||||
const uint16_t num_device_parameters_dts6619 =
|
||||
sizeof(device_parameters_dts6619) / sizeof(device_parameters_dts6619[0]);
|
||||
|
||||
// ===== Ponteiro para a struct de holding (vinda do teu projeto)
|
||||
extern holding_reg_params_t holding_reg_params;
|
||||
|
||||
// ===== Acesso a memória local usada pela stack
|
||||
static void *get_param_ptr(const mb_parameter_descriptor_t *param)
|
||||
{
|
||||
if (!param || param->param_offset == 0)
|
||||
return NULL;
|
||||
return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
|
||||
}
|
||||
|
||||
// ===== Post do evento de medição
|
||||
static void meter_dts6619_post_event(float *voltage, float *current, int *power_w,
|
||||
float freq_hz, float pf_avg, float total_kwh)
|
||||
{
|
||||
meter_event_data_t evt = {
|
||||
.source = "GRID",
|
||||
.frequency = freq_hz,
|
||||
.power_factor = pf_avg,
|
||||
.total_energy = total_kwh};
|
||||
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
|
||||
memcpy(evt.irms, current, sizeof(evt.irms));
|
||||
memcpy(evt.watt, power_w, sizeof(evt.watt));
|
||||
|
||||
esp_err_t err = esp_event_post(METER_EVENT, METER_EVENT_DATA_READY,
|
||||
&evt, sizeof(evt), pdMS_TO_TICKS(10));
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGW(TAG, "Falha ao emitir evento: %s", esp_err_to_name(err));
|
||||
}
|
||||
}
|
||||
|
||||
// ===== Task de polling
|
||||
static void serial_mdb_task(void *param)
|
||||
{
|
||||
esp_err_t err;
|
||||
const mb_parameter_descriptor_t *desc = NULL;
|
||||
float v[3] = {0}, i[3] = {0}, p_ph[3] = {0};
|
||||
float p_total = 0.0f, pf[3] = {0}, freq = 0.0f, e_total_wh = 0.0f;
|
||||
|
||||
// pequeno settle antes da 1ª leitura
|
||||
vTaskDelay(pdMS_TO_TICKS(200));
|
||||
|
||||
while (1)
|
||||
{
|
||||
for (uint16_t cid = 0; cid < num_device_parameters_dts6619; cid++)
|
||||
{
|
||||
err = mbc_master_get_cid_info(cid, &desc);
|
||||
if (err != ESP_OK || !desc)
|
||||
continue;
|
||||
|
||||
void *data_ptr = get_param_ptr(desc);
|
||||
uint8_t type = 0;
|
||||
|
||||
// 1 retry simples em caso de timeout
|
||||
err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
|
||||
if (err == ESP_ERR_TIMEOUT)
|
||||
{
|
||||
vTaskDelay(pdMS_TO_TICKS(60));
|
||||
err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
|
||||
}
|
||||
|
||||
if (err == ESP_OK && data_ptr)
|
||||
{
|
||||
float raw = *(float *)data_ptr;
|
||||
float val = maybe_swap_float(raw);
|
||||
|
||||
// logging enxuto
|
||||
ESP_LOGI(TAG, "%s: %.3f %s", desc->param_key, val, desc->param_units);
|
||||
|
||||
switch (cid)
|
||||
{
|
||||
case CID_L1_VOLTAGE:
|
||||
v[0] = val;
|
||||
break;
|
||||
case CID_L2_VOLTAGE:
|
||||
v[1] = val;
|
||||
break;
|
||||
case CID_L3_VOLTAGE:
|
||||
v[2] = val;
|
||||
break;
|
||||
|
||||
case CID_L1_CURRENT:
|
||||
i[0] = val;
|
||||
break;
|
||||
case CID_L2_CURRENT:
|
||||
i[1] = val;
|
||||
break;
|
||||
case CID_L3_CURRENT:
|
||||
i[2] = val;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGE(TAG, "CID %u (%s) read failed: %s",
|
||||
cid, desc->param_key, esp_err_to_name(err));
|
||||
}
|
||||
|
||||
vTaskDelay(POLL_INTERVAL);
|
||||
}
|
||||
|
||||
// prepara payload do evento
|
||||
int p_int[3] = {
|
||||
(int)(p_ph[0]),
|
||||
(int)(p_ph[1]),
|
||||
(int)(p_ph[2])};
|
||||
// PF médio simples (ignora zeros)
|
||||
float pf_sum = 0.0f;
|
||||
int pf_cnt = 0;
|
||||
for (int k = 0; k < 3; ++k)
|
||||
{
|
||||
if (pf[k] != 0.0f)
|
||||
{
|
||||
pf_sum += pf[k];
|
||||
pf_cnt++;
|
||||
}
|
||||
}
|
||||
float pf_avg = (pf_cnt ? pf_sum / pf_cnt : 0.0f);
|
||||
|
||||
// energia em kWh se veio em Wh
|
||||
float total_kwh = e_total_wh / 1000.0f;
|
||||
|
||||
meter_dts6619_post_event(v, i, p_int, freq, pf_avg, total_kwh);
|
||||
vTaskDelay(UPDATE_INTERVAL);
|
||||
}
|
||||
}
|
||||
|
||||
// ============ Init / Start / Stop ============
|
||||
esp_err_t meter_dts6619_init(void)
|
||||
{
|
||||
if (is_initialized)
|
||||
{
|
||||
ESP_LOGW(TAG, "Already initialized");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
|
||||
// limpa UART se já houver driver
|
||||
if (uart_is_driver_installed(MB_PORT_NUM))
|
||||
{
|
||||
uart_driver_delete(MB_PORT_NUM);
|
||||
ESP_LOGI(TAG, "UART driver deleted");
|
||||
}
|
||||
|
||||
// destruir master anterior (ignora erro se não estiver init)
|
||||
(void)mbc_master_destroy();
|
||||
|
||||
mb_communication_info_t comm = {
|
||||
.port = MB_PORT_NUM,
|
||||
.mode = MB_MODE_RTU,
|
||||
.baudrate = MB_DEV_SPEED,
|
||||
.parity = UART_PARITY_EVEN};
|
||||
|
||||
void *handler = NULL;
|
||||
ESP_ERROR_CHECK(mbc_master_init(MB_PORT_SERIAL_MASTER, &handler));
|
||||
ESP_ERROR_CHECK(mbc_master_setup(&comm));
|
||||
ESP_ERROR_CHECK(uart_set_pin(MB_PORT_NUM, MB_UART_TXD, MB_UART_RXD, MB_UART_RTS, UART_PIN_NO_CHANGE));
|
||||
ESP_ERROR_CHECK(mbc_master_start());
|
||||
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
|
||||
vTaskDelay(pdMS_TO_TICKS(50));
|
||||
|
||||
ESP_ERROR_CHECK(mbc_master_set_descriptor(device_parameters_dts6619, num_device_parameters_dts6619));
|
||||
|
||||
is_initialized = true;
|
||||
ESP_LOGI(TAG, "DTS6619 Modbus master initialized (9600 8E1, Input Reg 0x04)");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t meter_dts6619_start(void)
|
||||
{
|
||||
if (!is_initialized)
|
||||
{
|
||||
ESP_LOGE(TAG, "Not initialized");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
if (meter_task == NULL)
|
||||
{
|
||||
xTaskCreate(serial_mdb_task, "meter_dts6619_task", 4096, NULL, 3, &meter_task);
|
||||
ESP_LOGI(TAG, "Task started");
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
void meter_dts6619_stop(void)
|
||||
{
|
||||
if (!is_initialized)
|
||||
{
|
||||
ESP_LOGW(TAG, "Not initialized, skipping stop");
|
||||
return;
|
||||
}
|
||||
|
||||
if (meter_task)
|
||||
{
|
||||
vTaskDelete(meter_task);
|
||||
meter_task = NULL;
|
||||
ESP_LOGI(TAG, "Task stopped");
|
||||
}
|
||||
|
||||
(void)mbc_master_destroy();
|
||||
|
||||
if (uart_is_driver_installed(MB_PORT_NUM))
|
||||
{
|
||||
uart_driver_delete(MB_PORT_NUM);
|
||||
ESP_LOGI(TAG, "UART driver deleted");
|
||||
}
|
||||
|
||||
is_initialized = false;
|
||||
ESP_LOGI(TAG, "Meter DTS6619 cleaned up");
|
||||
}
|
||||
35
components/meter_manager/driver/meter_orno/meter_dts6619.h
Executable file
35
components/meter_manager/driver/meter_orno/meter_dts6619.h
Executable file
@@ -0,0 +1,35 @@
|
||||
#ifndef METER_EA777_H_
|
||||
#define METER_EA777_H_
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Inicializa o driver do medidor EA777 (UART RS485, Modbus, registradores).
|
||||
*
|
||||
* @return esp_err_t Retorna ESP_OK se a inicialização for bem-sucedida, caso contrário retorna um erro.
|
||||
*/
|
||||
esp_err_t meter_ea777_init(void);
|
||||
|
||||
/**
|
||||
* @brief Inicia a tarefa de leitura de dados do medidor EA777.
|
||||
*
|
||||
* @return esp_err_t Retorna ESP_OK se a tarefa for iniciada com sucesso, caso contrário retorna um erro.
|
||||
*/
|
||||
esp_err_t meter_ea777_start(void);
|
||||
|
||||
/**
|
||||
* @brief Para a tarefa de leitura e limpa os dados internos do medidor EA777.
|
||||
*/
|
||||
void meter_ea777_stop(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* METER_EA777_H_ */
|
||||
379
components/meter_manager/driver/meter_orno/meter_ea777.c
Executable file
379
components/meter_manager/driver/meter_orno/meter_ea777.c
Executable file
@@ -0,0 +1,379 @@
|
||||
// meter_ea777.c — Driver Modbus RTU para EARU EA777 (ESP-IDF)
|
||||
|
||||
#include "meter_events.h"
|
||||
#include "modbus_params.h"
|
||||
#include "mbcontroller.h"
|
||||
#include "esp_log.h"
|
||||
#include "driver/uart.h"
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
|
||||
#define TAG "serial_mdb_ea777"
|
||||
|
||||
// ===== UART / RS-485 =====
|
||||
#define MB_PORT_NUM 2
|
||||
#define MB_DEV_SPEED 9600
|
||||
|
||||
// Ajuste os pinos conforme seu hardware
|
||||
#define MB_UART_TXD 17
|
||||
#define MB_UART_RXD 16
|
||||
#define MB_UART_RTS 2 // pino DE/RE do transceiver RS-485
|
||||
|
||||
// ===== Timings =====
|
||||
#define UPDATE_INTERVAL (5000 / portTICK_PERIOD_MS)
|
||||
#define POLL_INTERVAL (200 / portTICK_PERIOD_MS)
|
||||
|
||||
// ===== Helpers =====
|
||||
#define STR(fieldname) ((const char *)(fieldname))
|
||||
#define OPTS(min_val, max_val, step_val) {.opt1 = min_val, .opt2 = max_val, .opt3 = step_val}
|
||||
|
||||
// ===== Estado =====
|
||||
static bool is_initialized = false;
|
||||
static TaskHandle_t meter_task = NULL;
|
||||
|
||||
// ============================================================================
|
||||
// ============ MAPA DE REGISTROS EA777 (Holding 0x03) ========================
|
||||
// Endereços zero-based. Tipos reais (engenharia) via fator de escala.
|
||||
// Tensões (0.1 V)
|
||||
#define EA777_L1VOLTAGE 0x0000
|
||||
#define EA777_L2VOLTAGE 0x0001
|
||||
#define EA777_L3VOLTAGE 0x0002
|
||||
// Correntes (0.01 A)
|
||||
#define EA777_L1CURRENT 0x0003
|
||||
#define EA777_L2CURRENT 0x0004
|
||||
#define EA777_L3CURRENT 0x0005
|
||||
// Potência ativa total (W)
|
||||
#define EA777_TOTAL_ACTIVE_P 0x0007
|
||||
// (se quiser por fase, pode usar 0x0008/0x0009/0x000A)
|
||||
// Fator de potência por fase (0.001)
|
||||
#define EA777_PF_L1 0x0014
|
||||
#define EA777_PF_L2 0x0015
|
||||
#define EA777_PF_L3 0x0016
|
||||
// Frequência (0.01 Hz)
|
||||
#define EA777_FREQUENCY 0x001A
|
||||
// Energia ativa total (U32 * 0.01 kWh, 2 registradores)
|
||||
#define EA777_TOTAL_ACTIVE_E 0x001D
|
||||
// ============================================================================
|
||||
|
||||
// ============ CIDs ============
|
||||
enum
|
||||
{
|
||||
CID_EA777_L1_VOLTAGE = 0,
|
||||
CID_EA777_L2_VOLTAGE,
|
||||
CID_EA777_L3_VOLTAGE,
|
||||
CID_EA777_L1_CURRENT,
|
||||
CID_EA777_L2_CURRENT,
|
||||
CID_EA777_L3_CURRENT,
|
||||
CID_EA777_TOTAL_ACTIVE_P,
|
||||
CID_EA777_PF_L1,
|
||||
CID_EA777_PF_L2,
|
||||
CID_EA777_PF_L3,
|
||||
CID_EA777_FREQUENCY,
|
||||
CID_EA777_TOTAL_ACTIVE_E,
|
||||
};
|
||||
|
||||
// ======= Descritores (Holding registers) =======
|
||||
// Nota: param_offset = 0 -> não usamos holding_reg_params_t aqui.
|
||||
const mb_parameter_descriptor_t device_parameters_ea777[] = {
|
||||
// Tensões (0.1 V)
|
||||
{CID_EA777_L1_VOLTAGE, STR("L1 Voltage"), STR("V"), 1,
|
||||
MB_PARAM_HOLDING, EA777_L1VOLTAGE, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 4000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_EA777_L2_VOLTAGE, STR("L2 Voltage"), STR("V"), 1,
|
||||
MB_PARAM_HOLDING, EA777_L2VOLTAGE, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 4000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_EA777_L3_VOLTAGE, STR("L3 Voltage"), STR("V"), 1,
|
||||
MB_PARAM_HOLDING, EA777_L3VOLTAGE, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 4000, 1), PAR_PERMS_READ},
|
||||
|
||||
// Correntes (0.01 A)
|
||||
{CID_EA777_L1_CURRENT, STR("L1 Current"), STR("A"), 1,
|
||||
MB_PARAM_HOLDING, EA777_L1CURRENT, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_EA777_L2_CURRENT, STR("L2 Current"), STR("A"), 1,
|
||||
MB_PARAM_HOLDING, EA777_L2CURRENT, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_EA777_L3_CURRENT, STR("L3 Current"), STR("A"), 1,
|
||||
MB_PARAM_HOLDING, EA777_L3CURRENT, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
|
||||
|
||||
// Potência ativa total (W)
|
||||
{CID_EA777_TOTAL_ACTIVE_P, STR("Total Active Power"), STR("W"), 1,
|
||||
MB_PARAM_HOLDING, EA777_TOTAL_ACTIVE_P, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 60000, 1), PAR_PERMS_READ},
|
||||
|
||||
// Fator de potência (0.001)
|
||||
{CID_EA777_PF_L1, STR("L1 PF"), STR(""), 1,
|
||||
MB_PARAM_HOLDING, EA777_PF_L1, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 1000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_EA777_PF_L2, STR("L2 PF"), STR(""), 1,
|
||||
MB_PARAM_HOLDING, EA777_PF_L2, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 1000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_EA777_PF_L3, STR("L3 PF"), STR(""), 1,
|
||||
MB_PARAM_HOLDING, EA777_PF_L3, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 1000, 1), PAR_PERMS_READ},
|
||||
|
||||
// Frequência (0.01 Hz)
|
||||
{CID_EA777_FREQUENCY, STR("Frequency"), STR("Hz"), 1,
|
||||
MB_PARAM_HOLDING, EA777_FREQUENCY, 1,
|
||||
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
|
||||
|
||||
// Energia ativa total (U32 * 0.01 kWh, 2 regs)
|
||||
{CID_EA777_TOTAL_ACTIVE_E, STR("Total Active Energy"), STR("kWh"), 1,
|
||||
MB_PARAM_HOLDING, EA777_TOTAL_ACTIVE_E, 2,
|
||||
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
|
||||
};
|
||||
|
||||
const uint16_t num_device_parameters_ea777 =
|
||||
sizeof(device_parameters_ea777) / sizeof(device_parameters_ea777[0]);
|
||||
|
||||
// ===== Post do evento de medição =====
|
||||
static void meter_ea777_post_event(float *voltage, float *current, int *power_w,
|
||||
float freq_hz, float pf_avg, float total_kwh)
|
||||
{
|
||||
meter_event_data_t evt = {
|
||||
.source = "GRID",
|
||||
.frequency = freq_hz,
|
||||
.power_factor = pf_avg,
|
||||
.total_energy = total_kwh};
|
||||
|
||||
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
|
||||
memcpy(evt.irms, current, sizeof(evt.irms));
|
||||
memcpy(evt.watt, power_w, sizeof(evt.watt));
|
||||
|
||||
esp_err_t err = esp_event_post(METER_EVENT, METER_EVENT_DATA_READY,
|
||||
&evt, sizeof(evt), pdMS_TO_TICKS(10));
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGW(TAG, "Falha ao emitir evento: %s", esp_err_to_name(err));
|
||||
}
|
||||
}
|
||||
|
||||
// ===== Task de polling =====
|
||||
static void serial_mdb_ea777_task(void *param)
|
||||
{
|
||||
esp_err_t err;
|
||||
const mb_parameter_descriptor_t *desc = NULL;
|
||||
|
||||
float v[3] = {0};
|
||||
float i[3] = {0};
|
||||
float pf[3] = {0};
|
||||
float freq = 0.0f;
|
||||
float total_kwh = 0.0f;
|
||||
|
||||
// pequeno settle antes da 1ª leitura
|
||||
vTaskDelay(pdMS_TO_TICKS(200));
|
||||
|
||||
while (1)
|
||||
{
|
||||
for (uint16_t cid = 0; cid < num_device_parameters_ea777; cid++)
|
||||
{
|
||||
err = mbc_master_get_cid_info(cid, &desc);
|
||||
if (err != ESP_OK || !desc)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
uint8_t type = 0;
|
||||
uint16_t raw16 = 0;
|
||||
uint32_t raw32 = 0;
|
||||
|
||||
void *value_ptr = (cid == CID_EA777_TOTAL_ACTIVE_E) ? (void *)&raw32 : (void *)&raw16;
|
||||
|
||||
// 1 retry simples em caso de timeout
|
||||
err = mbc_master_get_parameter(cid,
|
||||
(char *)desc->param_key,
|
||||
(uint8_t *)value_ptr,
|
||||
&type);
|
||||
if (err == ESP_ERR_TIMEOUT)
|
||||
{
|
||||
vTaskDelay(pdMS_TO_TICKS(60));
|
||||
err = mbc_master_get_parameter(cid,
|
||||
(char *)desc->param_key,
|
||||
(uint8_t *)value_ptr,
|
||||
&type);
|
||||
}
|
||||
|
||||
if (err == ESP_OK)
|
||||
{
|
||||
switch (cid)
|
||||
{
|
||||
case CID_EA777_L1_VOLTAGE:
|
||||
v[0] = ((float)raw16) * 0.1f;
|
||||
break;
|
||||
case CID_EA777_L2_VOLTAGE:
|
||||
v[1] = ((float)raw16) * 0.1f;
|
||||
break;
|
||||
case CID_EA777_L3_VOLTAGE:
|
||||
v[2] = ((float)raw16) * 0.1f;
|
||||
break;
|
||||
|
||||
case CID_EA777_L1_CURRENT:
|
||||
i[0] = ((float)raw16) * 0.01f;
|
||||
break;
|
||||
case CID_EA777_L2_CURRENT:
|
||||
i[1] = ((float)raw16) * 0.01f;
|
||||
break;
|
||||
case CID_EA777_L3_CURRENT:
|
||||
i[2] = ((float)raw16) * 0.01f;
|
||||
break;
|
||||
|
||||
case CID_EA777_TOTAL_ACTIVE_P:
|
||||
// guarda se quiser usar em debug; para o evento usamos
|
||||
// aproximação por fase abaixo
|
||||
// (poderia ser passado direto em power_w[0..2] também)
|
||||
break;
|
||||
|
||||
case CID_EA777_PF_L1:
|
||||
pf[0] = ((float)raw16) * 0.001f;
|
||||
break;
|
||||
case CID_EA777_PF_L2:
|
||||
pf[1] = ((float)raw16) * 0.001f;
|
||||
break;
|
||||
case CID_EA777_PF_L3:
|
||||
pf[2] = ((float)raw16) * 0.001f;
|
||||
break;
|
||||
|
||||
case CID_EA777_FREQUENCY:
|
||||
freq = ((float)raw16) * 0.01f;
|
||||
break;
|
||||
|
||||
case CID_EA777_TOTAL_ACTIVE_E:
|
||||
total_kwh = ((float)raw32) * 0.01f;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
ESP_LOGD(TAG, "%s (cid=%u) -> raw16=%u raw32=%u",
|
||||
desc->param_key, cid,
|
||||
(unsigned int)raw16,
|
||||
(unsigned int)raw32);
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGE(TAG, "CID %u (%s) read failed: %s",
|
||||
cid, desc->param_key, esp_err_to_name(err));
|
||||
}
|
||||
|
||||
vTaskDelay(POLL_INTERVAL);
|
||||
}
|
||||
|
||||
// Potência por fase aproximada: P = V * I * PF
|
||||
int p_int[3] = {
|
||||
(int)(v[0] * i[0] * pf[0]),
|
||||
(int)(v[1] * i[1] * pf[1]),
|
||||
(int)(v[2] * i[2] * pf[2]),
|
||||
};
|
||||
|
||||
// PF médio simples (ignora zeros)
|
||||
float pf_sum = 0.0f;
|
||||
int pf_cnt = 0;
|
||||
for (int k = 0; k < 3; ++k)
|
||||
{
|
||||
if (pf[k] != 0.0f)
|
||||
{
|
||||
pf_sum += pf[k];
|
||||
pf_cnt++;
|
||||
}
|
||||
}
|
||||
float pf_avg = (pf_cnt ? pf_sum / pf_cnt : 0.0f);
|
||||
|
||||
meter_ea777_post_event(v, i, p_int, freq, pf_avg, total_kwh);
|
||||
vTaskDelay(UPDATE_INTERVAL);
|
||||
}
|
||||
}
|
||||
|
||||
// ============ Init / Start / Stop ============
|
||||
esp_err_t meter_ea777_init(void)
|
||||
{
|
||||
if (is_initialized)
|
||||
{
|
||||
ESP_LOGW(TAG, "Already initialized");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
|
||||
// limpa UART se já houver driver
|
||||
if (uart_is_driver_installed(MB_PORT_NUM))
|
||||
{
|
||||
uart_driver_delete(MB_PORT_NUM);
|
||||
ESP_LOGI(TAG, "UART driver deleted");
|
||||
}
|
||||
|
||||
// destruir master anterior (ignora erro se não estiver init)
|
||||
(void)mbc_master_destroy();
|
||||
|
||||
mb_communication_info_t comm = {
|
||||
.port = MB_PORT_NUM,
|
||||
.mode = MB_MODE_RTU,
|
||||
.baudrate = MB_DEV_SPEED,
|
||||
.parity = UART_PARITY_EVEN};
|
||||
|
||||
void *handler = NULL;
|
||||
ESP_ERROR_CHECK(mbc_master_init(MB_PORT_SERIAL_MASTER, &handler));
|
||||
ESP_ERROR_CHECK(mbc_master_setup(&comm));
|
||||
ESP_ERROR_CHECK(uart_set_pin(MB_PORT_NUM,
|
||||
MB_UART_TXD, MB_UART_RXD,
|
||||
MB_UART_RTS, UART_PIN_NO_CHANGE));
|
||||
ESP_ERROR_CHECK(mbc_master_start());
|
||||
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
|
||||
vTaskDelay(pdMS_TO_TICKS(50));
|
||||
|
||||
ESP_ERROR_CHECK(mbc_master_set_descriptor(device_parameters_ea777,
|
||||
num_device_parameters_ea777));
|
||||
|
||||
is_initialized = true;
|
||||
ESP_LOGI(TAG, "EA777 Modbus master initialized (9600 8E1, Holding Reg 0x03)");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t meter_ea777_start(void)
|
||||
{
|
||||
if (!is_initialized)
|
||||
{
|
||||
ESP_LOGE(TAG, "Not initialized");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
if (meter_task == NULL)
|
||||
{
|
||||
xTaskCreate(serial_mdb_ea777_task,
|
||||
"meter_ea777_task",
|
||||
4096, NULL, 3, &meter_task);
|
||||
ESP_LOGI(TAG, "EA777 task started");
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
void meter_ea777_stop(void)
|
||||
{
|
||||
if (!is_initialized)
|
||||
{
|
||||
ESP_LOGW(TAG, "Not initialized, skipping stop");
|
||||
return;
|
||||
}
|
||||
|
||||
if (meter_task)
|
||||
{
|
||||
vTaskDelete(meter_task);
|
||||
meter_task = NULL;
|
||||
ESP_LOGI(TAG, "EA777 task stopped");
|
||||
}
|
||||
|
||||
(void)mbc_master_destroy();
|
||||
|
||||
if (uart_is_driver_installed(MB_PORT_NUM))
|
||||
{
|
||||
uart_driver_delete(MB_PORT_NUM);
|
||||
ESP_LOGI(TAG, "UART driver deleted");
|
||||
}
|
||||
|
||||
is_initialized = false;
|
||||
ESP_LOGI(TAG, "Meter EA777 cleaned up");
|
||||
}
|
||||
32
components/meter_manager/driver/meter_orno/meter_ea777.h
Executable file
32
components/meter_manager/driver/meter_orno/meter_ea777.h
Executable file
@@ -0,0 +1,32 @@
|
||||
#ifndef METER_DTS6619_H_
|
||||
#define METER_DTS6619_H_
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
/**
|
||||
* @brief Inicializa o driver do medidor dts6619 (SPI, mutex, registradores).
|
||||
*
|
||||
* @return esp_err_t Retorna ESP_OK se a inicialização for bem-sucedida, caso contrário retorna um erro.
|
||||
*/
|
||||
esp_err_t meter_dts6619_init(void);
|
||||
|
||||
/**
|
||||
* @brief Inicia a tarefa de leitura de dados do medidor DTS6619.
|
||||
*
|
||||
* @return esp_err_t Retorna ESP_OK se a tarefa for iniciada com sucesso, caso contrário retorna um erro.
|
||||
*/
|
||||
esp_err_t meter_dts6619_start(void);
|
||||
|
||||
/**
|
||||
* @brief Para a tarefa de leitura e limpa os dados internos do medidor DTS6619.
|
||||
*/
|
||||
void meter_dts6619_stop(void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* METER_DTS6619_H_ */
|
||||
@@ -46,10 +46,10 @@ enum {
|
||||
|
||||
const mb_parameter_descriptor_t device_parameters_orno513[] = {
|
||||
{CID_TOTAL_ACTIVE_ENERGY, STR("Total Active Energy"), STR("kWh"), 1, MB_PARAM_HOLDING, TOTALFACTIVE, 2,
|
||||
HOLD_OFFSET(total_active_power), PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
|
||||
HOLD_OFFSET(active_power), PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_TOTAL_REACTIVE_ENERGY, STR("Total Reactive Energy"), STR("kWh"), 1, MB_PARAM_HOLDING, TOTALRACTIVE, 2,
|
||||
HOLD_OFFSET(total_reactive_power), PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
|
||||
HOLD_OFFSET(reactive_power), PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_ACTIVE_POWER, STR("Active Power"), STR("W"), 1, MB_PARAM_HOLDING, ACTIVEPOWER, 2,
|
||||
HOLD_OFFSET(active_power), PARAM_TYPE_I32_CDAB, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},
|
||||
|
||||
@@ -12,7 +12,7 @@
|
||||
#define MB_DEV_SPEED 9600
|
||||
#define MB_UART_TXD 17
|
||||
#define MB_UART_RXD 16
|
||||
#define MB_UART_RTS 5
|
||||
#define MB_UART_RTS 2
|
||||
|
||||
#define UPDATE_INTERVAL (5000 / portTICK_PERIOD_MS)
|
||||
#define POLL_INTERVAL (100 / portTICK_PERIOD_MS)
|
||||
@@ -40,7 +40,7 @@ enum {
|
||||
CID_L1_VOLTAGE,
|
||||
CID_L2_VOLTAGE,
|
||||
CID_L3_VOLTAGE,
|
||||
CID_TOTAL_ACTIVE_POWER
|
||||
CID_ACTIVE_POWER
|
||||
};
|
||||
|
||||
const mb_parameter_descriptor_t device_parameters_orno516[] = {
|
||||
@@ -56,8 +56,8 @@ const mb_parameter_descriptor_t device_parameters_orno516[] = {
|
||||
HOLD_OFFSET(l2_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
|
||||
{CID_L3_VOLTAGE, STR("L3 Voltage"), STR("V"), 1, MB_PARAM_HOLDING, L3VOLTAGE, 2,
|
||||
HOLD_OFFSET(l3_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
|
||||
{CID_TOTAL_ACTIVE_POWER, STR("Total Active Power"), STR("W"), 1, MB_PARAM_HOLDING, TOTALACTIVEPOWER, 2,
|
||||
HOLD_OFFSET(total_active_power), PARAM_TYPE_FLOAT, 4, OPTS(0, 100000, 1), PAR_PERMS_READ}
|
||||
{CID_ACTIVE_POWER, STR("Active Power"), STR("W"), 1, MB_PARAM_HOLDING, TOTALACTIVEPOWER, 2,
|
||||
HOLD_OFFSET(active_power), PARAM_TYPE_FLOAT, 4, OPTS(0, 100000, 1), PAR_PERMS_READ}
|
||||
};
|
||||
|
||||
const uint16_t num_device_parameters_orno516 = sizeof(device_parameters_orno516) / sizeof(device_parameters_orno516[0]);
|
||||
@@ -124,7 +124,7 @@ static void serial_mdb_task(void *param) {
|
||||
case CID_L1_CURRENT: current[0] = val; break;
|
||||
case CID_L2_CURRENT: current[1] = val; break;
|
||||
case CID_L3_CURRENT: current[2] = val; break;
|
||||
case CID_TOTAL_ACTIVE_POWER:
|
||||
case CID_ACTIVE_POWER:
|
||||
power[0] = (int)(val / 3);
|
||||
power[1] = (int)(val / 3);
|
||||
power[2] = (int)(val / 3);
|
||||
|
||||
310
components/meter_manager/driver/meter_orno/meter_orno526.c
Executable file
310
components/meter_manager/driver/meter_orno/meter_orno526.c
Executable file
@@ -0,0 +1,310 @@
|
||||
#include "meter_orno526.h"
|
||||
#include "modbus_params.h"
|
||||
#include "mbcontroller.h"
|
||||
#include "meter_events.h"
|
||||
#include "esp_log.h"
|
||||
#include "driver/uart.h"
|
||||
#include <stddef.h>
|
||||
#include <math.h>
|
||||
|
||||
#define TAG "serial_mdb_orno526"
|
||||
|
||||
#define MB_PORT_NUM 2
|
||||
#define MB_DEV_SPEED 9600
|
||||
#define MB_UART_TXD 17
|
||||
#define MB_UART_RXD 16
|
||||
#define MB_UART_RTS 2
|
||||
#define UPDATE_INTERVAL (3000 / portTICK_PERIOD_MS)
|
||||
#define POLL_INTERVAL (100 / portTICK_PERIOD_MS)
|
||||
|
||||
#define HOLD_OFFSET(field) ((uint16_t)(offsetof(holding_reg_params_t, field) + 1))
|
||||
#define STR(x) ((const char *)(x))
|
||||
#define OPTS(min, max, step) {.opt1 = min, .opt2 = max, .opt3 = step}
|
||||
|
||||
// State flag
|
||||
static bool is_initialized = false;
|
||||
static TaskHandle_t meter_task = NULL;
|
||||
|
||||
// CID enums
|
||||
enum
|
||||
{
|
||||
CID_ACTIVE_ENERGY = 0,
|
||||
CID_REACTIVE_ENERGY,
|
||||
CID_ACTIVE_POWER,
|
||||
CID_APPARENT_POWER,
|
||||
CID_REACTIVE_POWER,
|
||||
CID_L1_CURRENT,
|
||||
CID_L1_VOLTAGE,
|
||||
CID_FREQUENCY
|
||||
};
|
||||
|
||||
// Register addresses
|
||||
#define TOTALFACTIVE 0x010E
|
||||
#define TOTALRACTIVE 0x0118
|
||||
#define ACTIVEPOWER 0x0104
|
||||
#define APPARENTPOWER 0x0106
|
||||
#define REACTIVEPOWER 0x0108
|
||||
#define L1CURRENT 0x0102
|
||||
#define L1VOLTAGE 0x0100
|
||||
#define FREQUENCY 0x010A
|
||||
|
||||
const mb_parameter_descriptor_t device_parameters_orno526[] = {
|
||||
|
||||
{CID_ACTIVE_ENERGY, "Active Energy", "kWh", 1,
|
||||
MB_PARAM_INPUT, TOTALFACTIVE, 2, HOLD_OFFSET(active_energy),
|
||||
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_REACTIVE_ENERGY, "Reactive Energy", "kWh", 1,
|
||||
MB_PARAM_INPUT, TOTALRACTIVE, 2, HOLD_OFFSET(reactive_energy),
|
||||
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_ACTIVE_POWER, "Active Power", "W", 1,
|
||||
MB_PARAM_INPUT, ACTIVEPOWER, 2, HOLD_OFFSET(active_power),
|
||||
PARAM_TYPE_I32_CDAB, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_APPARENT_POWER, "Apparent Power", "VA", 1,
|
||||
MB_PARAM_INPUT, APPARENTPOWER, 2, HOLD_OFFSET(apparent_power),
|
||||
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_REACTIVE_POWER, "Reactive Power", "VAR", 1,
|
||||
MB_PARAM_INPUT, REACTIVEPOWER, 2, HOLD_OFFSET(reactive_power),
|
||||
PARAM_TYPE_I32_CDAB, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},
|
||||
|
||||
{CID_L1_CURRENT, "L1 Current", "A", 1,
|
||||
MB_PARAM_INPUT, L1CURRENT, 2, HOLD_OFFSET(l1_current),
|
||||
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100, 0.1), PAR_PERMS_READ},
|
||||
|
||||
{CID_L1_VOLTAGE, "L1 Voltage", "V", 1,
|
||||
MB_PARAM_INPUT, L1VOLTAGE, 2, HOLD_OFFSET(l1_voltage),
|
||||
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
|
||||
|
||||
{CID_FREQUENCY, "Frequency", "Hz", 1,
|
||||
MB_PARAM_INPUT, FREQUENCY, 1, HOLD_OFFSET(frequency),
|
||||
PARAM_TYPE_I32_CDAB, 2, OPTS(0, 1000, 0.1), PAR_PERMS_READ}
|
||||
|
||||
};
|
||||
|
||||
const uint16_t num_device_parameters_orno526 = sizeof(device_parameters_orno526) / sizeof(device_parameters_orno526[0]);
|
||||
|
||||
static void *get_param_ptr(const mb_parameter_descriptor_t *param)
|
||||
{
|
||||
if (!param || param->param_offset == 0)
|
||||
return NULL;
|
||||
return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
|
||||
}
|
||||
|
||||
static inline float scale_for_cid(uint16_t cid)
|
||||
{
|
||||
switch (cid)
|
||||
{
|
||||
case CID_L1_VOLTAGE:
|
||||
case CID_L1_CURRENT:
|
||||
return 1000.0f; // V/A = raw / 1000
|
||||
case CID_ACTIVE_POWER:
|
||||
case CID_APPARENT_POWER:
|
||||
case CID_REACTIVE_POWER:
|
||||
return 1.0f; // W/VA/var = raw
|
||||
case CID_ACTIVE_ENERGY:
|
||||
case CID_REACTIVE_ENERGY:
|
||||
return 100.0f; // kWh = raw / 100
|
||||
case CID_FREQUENCY:
|
||||
return 10.0f; // Hz = raw / 10
|
||||
default:
|
||||
return 1.0f;
|
||||
}
|
||||
}
|
||||
static void serial_mdb_task(void *param)
|
||||
{
|
||||
esp_err_t err;
|
||||
const mb_parameter_descriptor_t *desc = NULL;
|
||||
|
||||
float voltage[3] = {0};
|
||||
float current[3] = {0};
|
||||
int watt[3] = {0};
|
||||
float energy = 0.0f;
|
||||
float frequency_hz = 0.0f; // <- armazenar frequência lida (0x010A)
|
||||
|
||||
while (1)
|
||||
{
|
||||
for (uint16_t cid = 0; cid < num_device_parameters_orno526; cid++)
|
||||
{
|
||||
err = mbc_master_get_cid_info(cid, &desc);
|
||||
if (err != ESP_OK || !desc)
|
||||
{
|
||||
ESP_LOGE(TAG, "mbc_master_get_cid_info(%u) failed: %s", cid, esp_err_to_name(err));
|
||||
continue;
|
||||
}
|
||||
|
||||
void *data_ptr = get_param_ptr(desc);
|
||||
if (!data_ptr)
|
||||
{
|
||||
ESP_LOGE(TAG, "CID %u (%s): null data_ptr", cid, desc->param_key);
|
||||
continue;
|
||||
}
|
||||
|
||||
uint8_t type = 0;
|
||||
err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
|
||||
if (err == ESP_OK)
|
||||
{
|
||||
float val = 0.0f;
|
||||
|
||||
if (cid == CID_FREQUENCY)
|
||||
{
|
||||
// Frequência é U16 (1 registo), escala = /10.0
|
||||
uint16_t raw16 = *(uint16_t *)data_ptr;
|
||||
val = raw16 / 10.0f;
|
||||
frequency_hz = val;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Demais CIDs são I32_CDAB (2 registos)
|
||||
int32_t raw32 = *(int32_t *)data_ptr;
|
||||
float scale = scale_for_cid(cid);
|
||||
val = raw32 / scale;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "%s: %.3f %s", desc->param_key, val, desc->param_units);
|
||||
|
||||
switch (cid)
|
||||
{
|
||||
case CID_L1_VOLTAGE:
|
||||
voltage[0] = val;
|
||||
break;
|
||||
case CID_L1_CURRENT:
|
||||
current[0] = val;
|
||||
break;
|
||||
|
||||
case CID_ACTIVE_POWER:
|
||||
watt[0] = (int)lrintf(val);
|
||||
watt[1] = watt[2] = watt[0];
|
||||
break;
|
||||
|
||||
case CID_ACTIVE_ENERGY:
|
||||
energy = val; // já em kWh (raw/100)
|
||||
break;
|
||||
|
||||
// CID_FREQUENCY já atualiza 'frequency_hz' acima
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGE(TAG, "CID %u (%s) read failed: %s", cid, desc->param_key, esp_err_to_name(err));
|
||||
}
|
||||
|
||||
vTaskDelay(POLL_INTERVAL);
|
||||
}
|
||||
|
||||
meter_event_data_t evt = {
|
||||
.frequency = frequency_hz, // agora preenchido
|
||||
.power_factor = 0.0f, // (adicione PF se quiser ler 0x010B)
|
||||
.total_energy = energy,
|
||||
.source = "GRID",
|
||||
};
|
||||
|
||||
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
|
||||
memcpy(evt.irms, current, sizeof(evt.irms));
|
||||
memcpy(evt.watt, watt, sizeof(evt.watt));
|
||||
|
||||
esp_event_post(METER_EVENT, METER_EVENT_DATA_READY, &evt, sizeof(evt), pdMS_TO_TICKS(10));
|
||||
vTaskDelay(UPDATE_INTERVAL);
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t meter_orno526_init(void)
|
||||
{
|
||||
if (is_initialized)
|
||||
{
|
||||
ESP_LOGW(TAG, "meter_orno526 already initialized");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "meter_orno526_init");
|
||||
|
||||
// ORNO costuma vir 9600, 8E1. Se o teu estiver 8E2, troca os stop bits mais abaixo.
|
||||
mb_communication_info_t comm = {
|
||||
.port = MB_PORT_NUM,
|
||||
.mode = MB_MODE_RTU,
|
||||
.baudrate = MB_DEV_SPEED, // 9600
|
||||
.parity = UART_PARITY_DISABLE, // 8E1 por padrão
|
||||
};
|
||||
|
||||
void *handler = NULL;
|
||||
esp_err_t err = mbc_master_init(MB_PORT_SERIAL_MASTER, &handler);
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGE(TAG, "mbc_master_init failed");
|
||||
return err;
|
||||
}
|
||||
|
||||
ESP_ERROR_CHECK(mbc_master_setup(&comm));
|
||||
|
||||
// Pinos RS-485 (TX, RX, RTS=DE/RE). CTS não usado.
|
||||
ESP_ERROR_CHECK(uart_set_pin(MB_PORT_NUM, MB_UART_TXD, MB_UART_RXD, MB_UART_RTS, UART_PIN_NO_CHANGE));
|
||||
|
||||
// Garanta 8 bits de dados e sem flow-control.
|
||||
ESP_ERROR_CHECK(uart_set_word_length(MB_PORT_NUM, UART_DATA_8_BITS));
|
||||
ESP_ERROR_CHECK(uart_set_hw_flow_ctrl(MB_PORT_NUM, UART_HW_FLOWCTRL_DISABLE, 0));
|
||||
|
||||
// Stop bits: a maioria usa 1. Se continuar a dar INVALID_RESPONSE, teste 2.
|
||||
ESP_ERROR_CHECK(uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_1));
|
||||
// Alternativa, se o medidor estiver configurado p/ 2 stop bits:
|
||||
// ESP_ERROR_CHECK(uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_2));
|
||||
|
||||
ESP_ERROR_CHECK(mbc_master_start());
|
||||
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
|
||||
|
||||
// (Opcional) Logs detalhados para ver TX/RX/frames durante debug:
|
||||
esp_log_level_set("MB_CONTROLLER_MASTER", ESP_LOG_DEBUG);
|
||||
esp_log_level_set("MB_PORT_COMMON", ESP_LOG_DEBUG);
|
||||
esp_log_level_set("MB_SERIAL_MASTER", ESP_LOG_DEBUG);
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(5));
|
||||
|
||||
ESP_ERROR_CHECK(mbc_master_set_descriptor(device_parameters_orno526, num_device_parameters_orno526));
|
||||
|
||||
is_initialized = true;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t meter_orno526_start(void)
|
||||
{
|
||||
|
||||
ESP_LOGI(TAG, "meter_orno526_start");
|
||||
|
||||
if (!is_initialized)
|
||||
{
|
||||
ESP_LOGE(TAG, "meter_orno526 not initialized");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
|
||||
if (meter_task == NULL)
|
||||
{
|
||||
xTaskCreate(serial_mdb_task, "meter_orno526_task", 4096, NULL, 3, &meter_task);
|
||||
ESP_LOGI(TAG, "meter_orno526 task started");
|
||||
}
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
void meter_orno526_stop(void)
|
||||
{
|
||||
if (!is_initialized)
|
||||
{
|
||||
ESP_LOGW(TAG, "meter_orno526 not initialized");
|
||||
return;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Stopping meter_orno526");
|
||||
|
||||
uart_driver_delete(MB_PORT_NUM);
|
||||
|
||||
esp_err_t err = mbc_master_destroy();
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGW(TAG, "mbc_master_destroy() returned %s", esp_err_to_name(err));
|
||||
}
|
||||
|
||||
is_initialized = false;
|
||||
}
|
||||
29
components/meter_manager/driver/meter_orno/meter_orno526.h
Executable file
29
components/meter_manager/driver/meter_orno/meter_orno526.h
Executable file
@@ -0,0 +1,29 @@
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
/**
|
||||
* @brief Inicializa o driver do medidor ORNO 526 (SPI, mutex, registradores).
|
||||
*/
|
||||
esp_err_t meter_orno526_init(void);
|
||||
|
||||
/**
|
||||
* @brief Inicia a tarefa de leitura de dados do medidor ORNO 526.
|
||||
*/
|
||||
esp_err_t meter_orno526_start(void);
|
||||
|
||||
/**
|
||||
* @brief Para a tarefa de leitura e limpa os dados internos do medidor ORNO 526.
|
||||
*/
|
||||
void meter_orno526_stop(void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -46,24 +46,30 @@ typedef struct {
|
||||
uint16_t data_block1[150];
|
||||
} input_reg_params_t;
|
||||
|
||||
|
||||
// Holding Registers (ajustado para os campos usados no ORNO 516)
|
||||
typedef struct {
|
||||
float l1_current; // 0x0016
|
||||
float l2_current; // 0x0018
|
||||
float l3_current; // 0x001A
|
||||
float l1_current;
|
||||
float l2_current;
|
||||
float l3_current;
|
||||
|
||||
float l1_voltage; // 0x000E
|
||||
float l2_voltage; // 0x0010
|
||||
float l3_voltage; // 0x0012
|
||||
float l1_voltage;
|
||||
float l2_voltage;
|
||||
float l3_voltage;
|
||||
|
||||
float active_energy;
|
||||
float reactive_energy;
|
||||
|
||||
float total_active_power; // 0x001C
|
||||
float total_reactive_power;
|
||||
float active_power;
|
||||
float apparent_power;
|
||||
float reactive_power;
|
||||
|
||||
float frequency;
|
||||
float power_factor;
|
||||
} holding_reg_params_t;
|
||||
|
||||
|
||||
|
||||
#pragma pack(pop)
|
||||
|
||||
// Instâncias globais das estruturas
|
||||
|
||||
@@ -64,9 +64,9 @@ bool meter_zigbee_is_running(void) {
|
||||
}
|
||||
|
||||
void send_stop_command(void) {
|
||||
const char *cmd = "stop\n"; // Comando enviado para o outro lado interpretar e dormir
|
||||
uart_write_bytes(UART_PORT, cmd, strlen(cmd));
|
||||
uart_wait_tx_done(UART_PORT, pdMS_TO_TICKS(100)); // Aguarda envio terminar
|
||||
//const char *cmd = "stop\n"; // Comando enviado para o outro lado interpretar e dormir
|
||||
//uart_write_bytes(UART_PORT, cmd, strlen(cmd));
|
||||
//uart_wait_tx_done(UART_PORT, pdMS_TO_TICKS(100)); // Aguarda envio terminar
|
||||
}
|
||||
|
||||
static void meter_zigbee_post_event(void) {
|
||||
@@ -115,8 +115,8 @@ static void handle_zigbee_frame(const uint8_t *buf, size_t len) {
|
||||
uint32_t power_raw = (buf[11] << 16) | (buf[12] << 8) | buf[13];
|
||||
|
||||
float volt = volt_raw / 10.0f;
|
||||
float current = current_raw / 100.0f;
|
||||
float power = power_raw / 1000.0f;
|
||||
float current = current_raw / 1000.0f;
|
||||
float power = power_raw;
|
||||
|
||||
ESP_LOGI(TAG, "Parsed Attr 0x%04X: V=%.1fV I=%.2fA P=%.1fW", attr, volt, current, power);
|
||||
|
||||
@@ -144,13 +144,13 @@ static void handle_zigbee_frame(const uint8_t *buf, size_t len) {
|
||||
phase_updated[PHASE_L3] = true;
|
||||
break;
|
||||
case ATTR_POWER_FACTOR:
|
||||
meter_data.power_factor = current;
|
||||
meter_data.power_factor = 0;
|
||||
break;
|
||||
case ATTR_FREQUENCY:
|
||||
meter_data.frequency = current;
|
||||
meter_data.frequency = 0;
|
||||
break;
|
||||
case ATTR_TOTAL_ENERGY:
|
||||
meter_data.total_energy = current;
|
||||
meter_data.total_energy = 0;
|
||||
break;
|
||||
default:
|
||||
ESP_LOGW(TAG, "Unknown attr: 0x%04X", attr);
|
||||
@@ -227,9 +227,9 @@ esp_err_t meter_zigbee_start(void) {
|
||||
|
||||
void meter_zigbee_stop(void) {
|
||||
|
||||
send_stop_command();
|
||||
//send_stop_command();
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(100)); // Aguarda o outro lado processar
|
||||
//vTaskDelay(pdMS_TO_TICKS(100)); // Aguarda o outro lado processar
|
||||
|
||||
if (meter_zigbee_task) {
|
||||
vTaskDelete(meter_zigbee_task);
|
||||
|
||||
@@ -12,8 +12,12 @@ typedef enum {
|
||||
METER_TYPE_ADE7758, // ADE7758 meter
|
||||
METER_TYPE_ORNO513, // ORNO-513
|
||||
METER_TYPE_ORNO516, // ORNO-516
|
||||
METER_TYPE_ORNO526, // ORNO-516
|
||||
METER_TYPE_DDS661, // DDS-661
|
||||
METER_TYPE_DTS6619, // dts6619
|
||||
METER_TYPE_MONO_ZIGBEE, // Zigbee single-phase
|
||||
METER_TYPE_TRIF_ZIGBEE // Zigbee three-phase
|
||||
METER_TYPE_TRIF_ZIGBEE, // Zigbee three-phase
|
||||
METER_TYPE_EA777 // EA777
|
||||
} meter_type_t;
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,15 +1,20 @@
|
||||
#include "meter_manager.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
#include "meter_ade7758.h"
|
||||
#include "meter_orno513.h"
|
||||
#include "meter_orno516.h"
|
||||
#include "meter_orno526.h"
|
||||
#include "meter_dts6619.h"
|
||||
#include "meter_dds661.h"
|
||||
#include "meter_zigbee.h"
|
||||
#include "meter_ea777.h"
|
||||
|
||||
#include "nvs_flash.h"
|
||||
#include "nvs.h"
|
||||
#include <string.h>
|
||||
#include "network_events.h"
|
||||
|
||||
|
||||
static const char *TAG = "meter_manager";
|
||||
|
||||
// Tipos de medidores EVSE e GRID
|
||||
@@ -20,20 +25,21 @@ static meter_type_t meter_grid_type = METER_TYPE_NONE;
|
||||
#define NVS_EVSE_MODEL "evse_model"
|
||||
#define NVS_GRID_MODEL "grid_model"
|
||||
|
||||
static void meter_manager_network_event_handler(void *arg, esp_event_base_t base, int32_t event_id, void *data)
|
||||
{
|
||||
if (base != NETWORK_EVENTS)
|
||||
return;
|
||||
|
||||
static void meter_manager_network_event_handler(void* arg, esp_event_base_t base, int32_t event_id, void* data){
|
||||
|
||||
if (base != NETWORK_EVENTS) return;
|
||||
|
||||
switch (event_id) {
|
||||
switch (event_id)
|
||||
{
|
||||
case NETWORK_EVENT_AP_STARTED:
|
||||
ESP_LOGI(TAG, "Recebido NETWORK_EVENT_AP_STARTED, parando medidor de grid");
|
||||
meter_manager_grid_stop();
|
||||
// meter_manager_grid_stop();
|
||||
break;
|
||||
|
||||
case NETWORK_EVENT_AP_STOP:
|
||||
ESP_LOGI(TAG, "Recebido NETWORK_EVENT_AP_STOP, reiniciando medidor de grid");
|
||||
meter_manager_grid_start();
|
||||
// meter_manager_grid_start();
|
||||
break;
|
||||
|
||||
case NETWORK_EVENT_STA_GOT_IP:
|
||||
@@ -46,22 +52,26 @@ static void meter_manager_network_event_handler(void* arg, esp_event_base_t base
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Função unificada para ler ou inicializar um modelo de medidor
|
||||
static esp_err_t load_or_init_meter_model(const char *key, meter_type_t *type) {
|
||||
static esp_err_t load_or_init_meter_model(const char *key, meter_type_t *type)
|
||||
{
|
||||
nvs_handle_t handle;
|
||||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &handle);
|
||||
if (err != ESP_OK) {
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGE(TAG, "Failed to open NVS handle for %s: %s", key, esp_err_to_name(err));
|
||||
return err;
|
||||
}
|
||||
|
||||
uint8_t value = 0;
|
||||
err = nvs_get_u8(handle, key, &value);
|
||||
if (err == ESP_OK && value <= METER_TYPE_TRIF_ZIGBEE) {
|
||||
if (err == ESP_OK && value < 255)
|
||||
{
|
||||
*type = (meter_type_t)value;
|
||||
ESP_LOGI(TAG, "Loaded meter type %d from NVS key '%s'", value, key);
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
*type = METER_TYPE_NONE;
|
||||
nvs_set_u8(handle, key, *type);
|
||||
nvs_commit(handle);
|
||||
@@ -72,19 +82,24 @@ static esp_err_t load_or_init_meter_model(const char *key, meter_type_t *type) {
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t write_meter_model_to_nvs(const char *key, meter_type_t meter_type) {
|
||||
static esp_err_t write_meter_model_to_nvs(const char *key, meter_type_t meter_type)
|
||||
{
|
||||
nvs_handle_t handle;
|
||||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &handle);
|
||||
if (err != ESP_OK) {
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGE(TAG, "Failed to open NVS handle for writing");
|
||||
return err;
|
||||
}
|
||||
|
||||
err = nvs_set_u8(handle, key, (uint8_t)meter_type);
|
||||
if (err == ESP_OK) {
|
||||
if (err == ESP_OK)
|
||||
{
|
||||
err = nvs_commit(handle);
|
||||
ESP_LOGI(TAG, "Saved meter type %d to NVS key '%s'", meter_type, key);
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGE(TAG, "Failed to write meter type to NVS key '%s'", key);
|
||||
}
|
||||
|
||||
@@ -92,7 +107,6 @@ static esp_err_t write_meter_model_to_nvs(const char *key, meter_type_t meter_ty
|
||||
return err;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Initializes the meter manager system.
|
||||
*
|
||||
@@ -102,16 +116,18 @@ static esp_err_t write_meter_model_to_nvs(const char *key, meter_type_t meter_ty
|
||||
*
|
||||
* @return esp_err_t ESP_OK on success, or an error code.
|
||||
*/
|
||||
esp_err_t meter_manager_init(void) {
|
||||
esp_err_t meter_manager_init(void)
|
||||
{
|
||||
esp_err_t err;
|
||||
|
||||
// Initialize EVSE meter
|
||||
// Initialize EVSE meter (habilite quando quiser)
|
||||
// err = meter_manager_evse_init();
|
||||
// if (err != ESP_OK) return err;
|
||||
|
||||
// Initialize GRID meter
|
||||
err = meter_manager_grid_init();
|
||||
if (err != ESP_OK) return err;
|
||||
if (err != ESP_OK)
|
||||
return err;
|
||||
|
||||
// Register handler for custom network events
|
||||
ESP_LOGI(TAG, "Registering network event handler");
|
||||
@@ -121,7 +137,6 @@ esp_err_t meter_manager_init(void) {
|
||||
NULL);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Starts all configured meters (EVSE and GRID).
|
||||
*
|
||||
@@ -130,21 +145,22 @@ esp_err_t meter_manager_init(void) {
|
||||
*
|
||||
* @return esp_err_t ESP_OK on success, or an error code from one of the start calls.
|
||||
*/
|
||||
esp_err_t meter_manager_start(void) {
|
||||
esp_err_t meter_manager_start(void)
|
||||
{
|
||||
esp_err_t err;
|
||||
|
||||
// Start EVSE meter
|
||||
// Start EVSE meter (habilite quando quiser)
|
||||
// err = meter_manager_evse_start();
|
||||
// if (err != ESP_OK) return err;
|
||||
|
||||
// Start GRID meter
|
||||
err = meter_manager_grid_start();
|
||||
if (err != ESP_OK) return err;
|
||||
if (err != ESP_OK)
|
||||
return err;
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Stops all meters and unregisters event handlers.
|
||||
*
|
||||
@@ -153,7 +169,8 @@ esp_err_t meter_manager_start(void) {
|
||||
*
|
||||
* @return esp_err_t ESP_OK on success, or an error code.
|
||||
*/
|
||||
esp_err_t meter_manager_stop(void) {
|
||||
esp_err_t meter_manager_stop(void)
|
||||
{
|
||||
esp_err_t err;
|
||||
|
||||
// Stop EVSE meter
|
||||
@@ -162,144 +179,297 @@ esp_err_t meter_manager_stop(void) {
|
||||
|
||||
// Stop GRID meter
|
||||
err = meter_manager_grid_stop();
|
||||
if (err != ESP_OK) return err;
|
||||
if (err != ESP_OK)
|
||||
return err;
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
// ---------- EVSE ----------
|
||||
|
||||
|
||||
|
||||
// Função para inicializar o medidor EVSE
|
||||
esp_err_t meter_manager_evse_init() {
|
||||
esp_err_t meter_manager_evse_init()
|
||||
{
|
||||
esp_err_t err = load_or_init_meter_model(NVS_EVSE_MODEL, &meter_evse_type);
|
||||
if (err != ESP_OK) return err;
|
||||
if (err != ESP_OK)
|
||||
return err;
|
||||
|
||||
ESP_LOGI(TAG, "Initializing EVSE meter of type %s", meter_type_to_str(meter_evse_type));
|
||||
|
||||
switch (meter_evse_type) {
|
||||
case METER_TYPE_NONE: return ESP_OK;
|
||||
case METER_TYPE_ADE7758: return meter_ade7758_init();
|
||||
case METER_TYPE_ORNO513: return meter_orno513_init();
|
||||
case METER_TYPE_ORNO516: return meter_orno516_init();
|
||||
switch (meter_evse_type)
|
||||
{
|
||||
case METER_TYPE_NONE:
|
||||
return ESP_OK;
|
||||
case METER_TYPE_ADE7758:
|
||||
return meter_ade7758_init();
|
||||
case METER_TYPE_ORNO513:
|
||||
return meter_orno513_init();
|
||||
case METER_TYPE_ORNO516:
|
||||
return meter_orno516_init();
|
||||
case METER_TYPE_ORNO526:
|
||||
return meter_orno526_init();
|
||||
case METER_TYPE_DTS6619:
|
||||
return meter_dts6619_init();
|
||||
case METER_TYPE_DDS661:
|
||||
return meter_dds661_init();
|
||||
case METER_TYPE_EA777:
|
||||
return meter_ea777_init();
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE: return meter_zigbee_init();
|
||||
default: return ESP_ERR_INVALID_ARG;
|
||||
case METER_TYPE_TRIF_ZIGBEE:
|
||||
return meter_zigbee_init();
|
||||
default:
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t meter_manager_grid_init() {
|
||||
esp_err_t err = load_or_init_meter_model(NVS_GRID_MODEL, &meter_grid_type);
|
||||
if (err != ESP_OK) return err;
|
||||
|
||||
ESP_LOGI(TAG, "Initializing GRID meter of type %s", meter_type_to_str(meter_grid_type));
|
||||
|
||||
switch (meter_grid_type) {
|
||||
case METER_TYPE_NONE: return ESP_OK;
|
||||
case METER_TYPE_ADE7758: return meter_ade7758_init();
|
||||
case METER_TYPE_ORNO513: return meter_orno513_init();
|
||||
case METER_TYPE_ORNO516: return meter_orno516_init();
|
||||
esp_err_t meter_manager_evse_start()
|
||||
{
|
||||
meter_type_t type = meter_manager_evse_get_model();
|
||||
switch (type)
|
||||
{
|
||||
case METER_TYPE_NONE:
|
||||
return ESP_OK;
|
||||
case METER_TYPE_ADE7758:
|
||||
return meter_ade7758_start();
|
||||
case METER_TYPE_ORNO513:
|
||||
return meter_orno513_start();
|
||||
case METER_TYPE_ORNO516:
|
||||
return meter_orno516_start();
|
||||
case METER_TYPE_ORNO526:
|
||||
return meter_orno526_start();
|
||||
case METER_TYPE_DTS6619:
|
||||
return meter_dts6619_start();
|
||||
case METER_TYPE_DDS661:
|
||||
return meter_dds661_start();
|
||||
case METER_TYPE_EA777:
|
||||
return meter_ea777_start();
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE: return meter_zigbee_init();
|
||||
default: return ESP_ERR_INVALID_ARG;
|
||||
case METER_TYPE_TRIF_ZIGBEE:
|
||||
return meter_zigbee_start();
|
||||
default:
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t meter_manager_grid_start() {
|
||||
meter_type_t type = meter_manager_grid_get_model();
|
||||
switch (type) {
|
||||
case METER_TYPE_NONE: return ESP_OK;
|
||||
case METER_TYPE_ADE7758: return meter_ade7758_start();
|
||||
case METER_TYPE_ORNO513: return meter_orno513_start();
|
||||
case METER_TYPE_ORNO516: return meter_orno516_start();
|
||||
esp_err_t meter_manager_evse_stop(void)
|
||||
{
|
||||
meter_type_t type = meter_manager_evse_get_model();
|
||||
switch (type)
|
||||
{
|
||||
case METER_TYPE_NONE:
|
||||
return ESP_OK;
|
||||
case METER_TYPE_ADE7758:
|
||||
meter_ade7758_stop();
|
||||
break;
|
||||
case METER_TYPE_ORNO513:
|
||||
meter_orno513_stop();
|
||||
break;
|
||||
case METER_TYPE_ORNO516:
|
||||
meter_orno516_stop();
|
||||
break;
|
||||
case METER_TYPE_ORNO526:
|
||||
meter_orno526_stop();
|
||||
break;
|
||||
case METER_TYPE_DTS6619:
|
||||
meter_dts6619_stop();
|
||||
break;
|
||||
case METER_TYPE_DDS661:
|
||||
meter_dds661_stop();
|
||||
break;
|
||||
case METER_TYPE_EA777:
|
||||
meter_ea777_stop();
|
||||
break;
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE: return meter_zigbee_start();
|
||||
default: return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t meter_manager_grid_stop(void) {
|
||||
meter_type_t type = meter_manager_grid_get_model();
|
||||
switch (type) {
|
||||
case METER_TYPE_NONE: return ESP_OK;
|
||||
case METER_TYPE_ADE7758: meter_ade7758_stop(); break;
|
||||
case METER_TYPE_ORNO513: meter_orno513_stop(); break;
|
||||
case METER_TYPE_ORNO516: meter_orno516_stop(); break;
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE: meter_zigbee_stop(); break;
|
||||
default: return ESP_ERR_INVALID_ARG;
|
||||
case METER_TYPE_TRIF_ZIGBEE:
|
||||
meter_zigbee_stop();
|
||||
break;
|
||||
default:
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
// ---------- GRID ----------
|
||||
|
||||
esp_err_t meter_manager_evse_set_model(meter_type_t meter_type) {
|
||||
esp_err_t meter_manager_grid_init()
|
||||
{
|
||||
esp_err_t err = load_or_init_meter_model(NVS_GRID_MODEL, &meter_grid_type);
|
||||
if (err != ESP_OK)
|
||||
return err;
|
||||
|
||||
ESP_LOGI(TAG, "Initializing GRID meter of type %s", meter_type_to_str(meter_grid_type));
|
||||
|
||||
switch (meter_grid_type) // corrigido: ORNO-513 -> driver orno513
|
||||
{
|
||||
case METER_TYPE_NONE:
|
||||
return ESP_OK;
|
||||
case METER_TYPE_ADE7758:
|
||||
return meter_ade7758_init();
|
||||
case METER_TYPE_ORNO513:
|
||||
return meter_orno513_init();
|
||||
case METER_TYPE_ORNO516:
|
||||
return meter_orno516_init();
|
||||
case METER_TYPE_ORNO526:
|
||||
return meter_orno526_init();
|
||||
case METER_TYPE_DTS6619:
|
||||
return meter_dts6619_init();
|
||||
case METER_TYPE_DDS661:
|
||||
return meter_dds661_init();
|
||||
case METER_TYPE_EA777:
|
||||
return meter_ea777_init();
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE:
|
||||
return meter_zigbee_init();
|
||||
default:
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t meter_manager_grid_start()
|
||||
{
|
||||
meter_type_t type = meter_manager_grid_get_model();
|
||||
switch (type)
|
||||
{
|
||||
case METER_TYPE_NONE:
|
||||
return ESP_OK;
|
||||
case METER_TYPE_ADE7758:
|
||||
return meter_ade7758_start();
|
||||
case METER_TYPE_ORNO513:
|
||||
return meter_orno513_start(); // corrigido
|
||||
case METER_TYPE_ORNO516:
|
||||
return meter_orno516_start();
|
||||
case METER_TYPE_ORNO526:
|
||||
return meter_orno526_start();
|
||||
case METER_TYPE_DTS6619:
|
||||
return meter_dts6619_start();
|
||||
case METER_TYPE_DDS661:
|
||||
return meter_dds661_start();
|
||||
case METER_TYPE_EA777:
|
||||
return meter_ea777_start();
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE:
|
||||
return meter_zigbee_start();
|
||||
default:
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t meter_manager_grid_stop(void)
|
||||
{
|
||||
meter_type_t type = meter_manager_grid_get_model();
|
||||
switch (type)
|
||||
{
|
||||
case METER_TYPE_NONE:
|
||||
return ESP_OK;
|
||||
case METER_TYPE_ADE7758:
|
||||
meter_ade7758_stop();
|
||||
break;
|
||||
case METER_TYPE_ORNO513:
|
||||
meter_orno513_stop(); // corrigido
|
||||
break;
|
||||
case METER_TYPE_ORNO516:
|
||||
meter_orno516_stop();
|
||||
break;
|
||||
case METER_TYPE_ORNO526:
|
||||
meter_orno526_stop();
|
||||
break;
|
||||
case METER_TYPE_DTS6619:
|
||||
meter_dts6619_stop();
|
||||
break;
|
||||
case METER_TYPE_DDS661:
|
||||
meter_dds661_stop();
|
||||
break;
|
||||
case METER_TYPE_EA777:
|
||||
meter_ea777_stop();
|
||||
break;
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE:
|
||||
meter_zigbee_stop();
|
||||
break;
|
||||
default:
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
// ---------- Utilidades ----------
|
||||
|
||||
esp_err_t meter_manager_evse_set_model(meter_type_t meter_type)
|
||||
{
|
||||
meter_evse_type = meter_type;
|
||||
return write_meter_model_to_nvs(NVS_EVSE_MODEL, meter_evse_type);
|
||||
}
|
||||
|
||||
esp_err_t meter_manager_grid_set_model(meter_type_t meter_type) {
|
||||
esp_err_t meter_manager_grid_set_model(meter_type_t meter_type)
|
||||
{
|
||||
meter_grid_type = meter_type;
|
||||
return write_meter_model_to_nvs(NVS_GRID_MODEL, meter_grid_type);
|
||||
}
|
||||
|
||||
esp_err_t meter_manager_evse_start() {
|
||||
meter_type_t type = meter_manager_evse_get_model();
|
||||
switch (type) {
|
||||
case METER_TYPE_NONE: return ESP_OK;
|
||||
case METER_TYPE_ADE7758: return meter_ade7758_start();
|
||||
case METER_TYPE_ORNO513: return meter_orno513_start();
|
||||
case METER_TYPE_ORNO516: return meter_orno516_start();
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE: return meter_zigbee_start();
|
||||
default: return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t meter_manager_evse_stop(void) {
|
||||
meter_type_t type = meter_manager_evse_get_model();
|
||||
switch (type) {
|
||||
case METER_TYPE_NONE: return ESP_OK;
|
||||
case METER_TYPE_ADE7758: meter_ade7758_stop(); break;
|
||||
case METER_TYPE_ORNO513: meter_orno513_stop(); break;
|
||||
case METER_TYPE_ORNO516: meter_orno516_stop(); break;
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
case METER_TYPE_TRIF_ZIGBEE: meter_zigbee_stop(); break;
|
||||
default: return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
bool meter_manager_evse_is_enabled(void) {
|
||||
bool meter_manager_evse_is_enabled(void)
|
||||
{
|
||||
return meter_manager_evse_get_model() != METER_TYPE_NONE;
|
||||
}
|
||||
|
||||
meter_type_t meter_manager_evse_get_model(void) {
|
||||
meter_type_t meter_manager_evse_get_model(void)
|
||||
{
|
||||
return meter_evse_type;
|
||||
}
|
||||
|
||||
meter_type_t meter_manager_grid_get_model(void) {
|
||||
meter_type_t meter_manager_grid_get_model(void)
|
||||
{
|
||||
return meter_grid_type;
|
||||
}
|
||||
|
||||
const char* meter_type_to_str(meter_type_t type) {
|
||||
switch (type) {
|
||||
case METER_TYPE_NONE: return "NENHUM";
|
||||
case METER_TYPE_ADE7758: return "IC ADE";
|
||||
case METER_TYPE_ORNO513: return "ORNO-513";
|
||||
case METER_TYPE_ORNO516: return "ORNO-516";
|
||||
case METER_TYPE_MONO_ZIGBEE: return "MONO-ZIGBEE";
|
||||
case METER_TYPE_TRIF_ZIGBEE: return "TRIF-ZIGBEE";
|
||||
default: return "NENHUM";
|
||||
const char *meter_type_to_str(meter_type_t type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case METER_TYPE_NONE:
|
||||
return "NENHUM";
|
||||
case METER_TYPE_ADE7758:
|
||||
return "IC ADE";
|
||||
case METER_TYPE_ORNO513:
|
||||
return "ORNO-513";
|
||||
case METER_TYPE_ORNO516:
|
||||
return "ORNO-516";
|
||||
case METER_TYPE_ORNO526:
|
||||
return "ORNO-526";
|
||||
case METER_TYPE_DTS6619:
|
||||
return "DTS-6619";
|
||||
case METER_TYPE_DDS661:
|
||||
return "DDS-661";
|
||||
case METER_TYPE_MONO_ZIGBEE:
|
||||
return "MONO-ZIGBEE";
|
||||
case METER_TYPE_TRIF_ZIGBEE:
|
||||
return "TRIF-ZIGBEE";
|
||||
case METER_TYPE_EA777:
|
||||
return "EA-777";
|
||||
default:
|
||||
return "NENHUM";
|
||||
}
|
||||
}
|
||||
|
||||
meter_type_t string_to_meter_type(const char *str) {
|
||||
if (!str) return METER_TYPE_NONE;
|
||||
if (strcmp(str, "IC ADE") == 0) return METER_TYPE_ADE7758;
|
||||
if (strcmp(str, "ORNO-513") == 0) return METER_TYPE_ORNO513;
|
||||
if (strcmp(str, "ORNO-516") == 0) return METER_TYPE_ORNO516;
|
||||
if (strcmp(str, "MONO-ZIGBEE") == 0) return METER_TYPE_MONO_ZIGBEE;
|
||||
if (strcmp(str, "TRIF-ZIGBEE") == 0) return METER_TYPE_TRIF_ZIGBEE;
|
||||
meter_type_t string_to_meter_type(const char *str)
|
||||
{
|
||||
if (!str)
|
||||
return METER_TYPE_NONE;
|
||||
if (strcmp(str, "IC ADE") == 0)
|
||||
return METER_TYPE_ADE7758;
|
||||
if (strcmp(str, "ORNO-513") == 0)
|
||||
return METER_TYPE_ORNO513;
|
||||
if (strcmp(str, "ORNO-516") == 0)
|
||||
return METER_TYPE_ORNO516;
|
||||
if (strcmp(str, "ORNO-526") == 0)
|
||||
return METER_TYPE_ORNO526;
|
||||
if (strcmp(str, "DTS-6619") == 0)
|
||||
return METER_TYPE_DTS6619;
|
||||
if (strcmp(str, "DDS-661") == 0)
|
||||
return METER_TYPE_DDS661;
|
||||
if (strcmp(str, "MONO-ZIGBEE") == 0)
|
||||
return METER_TYPE_MONO_ZIGBEE;
|
||||
if (strcmp(str, "TRIF-ZIGBEE") == 0)
|
||||
return METER_TYPE_TRIF_ZIGBEE;
|
||||
if (strcmp(str, "EA-777") == 0)
|
||||
return METER_TYPE_EA777;
|
||||
return METER_TYPE_NONE;
|
||||
}
|
||||
|
||||
@@ -1,155 +1,267 @@
|
||||
// =========================
|
||||
// wifi.c (ESP-IDF v5.4.2)
|
||||
// =========================
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "freertos/event_groups.h"
|
||||
|
||||
#include "esp_log.h"
|
||||
#include "esp_wifi.h"
|
||||
#include "esp_event.h"
|
||||
#include "esp_netif.h"
|
||||
#include "esp_mac.h"
|
||||
#include "nvs.h"
|
||||
#include "nvs_flash.h"
|
||||
#include "mdns.h"
|
||||
|
||||
#include "network_events.h"
|
||||
#include "network.h"
|
||||
|
||||
|
||||
#define AP_SSID "plx-%02x%02x%02x"
|
||||
|
||||
#define MDNS_SSID "plx%02x"
|
||||
// -----------------------------------------------------------------------------
|
||||
// Config
|
||||
// -----------------------------------------------------------------------------
|
||||
#define AP_SSID "plx-%02x%02x%02x" // SSID do AP (usa 3 bytes do MAC)
|
||||
#define MDNS_SSID "plx%02x" // hostname mDNS (usa 2 bytes do MAC)
|
||||
|
||||
#define NVS_NAMESPACE "wifi"
|
||||
#define NVS_ENABLED "enabled"
|
||||
#define NVS_SSID "ssid"
|
||||
#define NVS_PASSWORD "password"
|
||||
|
||||
// Comprimentos com terminador
|
||||
#define SSID_MAX_LEN 32
|
||||
#define PASS_MAX_LEN 64 // 63 chars + '\0'
|
||||
#define SSID_BUF_SZ (SSID_MAX_LEN + 1) // 33
|
||||
#define PASS_BUF_SZ (PASS_MAX_LEN + 1) // 65
|
||||
|
||||
static const char *TAG = "wifi";
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Estado global
|
||||
// -----------------------------------------------------------------------------
|
||||
static nvs_handle_t nvs;
|
||||
|
||||
static esp_netif_t *sta_netif;
|
||||
|
||||
static esp_netif_t *ap_netif;
|
||||
|
||||
EventGroupHandle_t wifi_event_group;
|
||||
|
||||
// Backoff simples para reconexão STA (agora sem delay no event handler)
|
||||
static int s_retry_count = 0;
|
||||
static const int s_retry_max = 7;
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
// Lê string do NVS com segurança (trunca se necessário)
|
||||
static esp_err_t nvs_get_str_safe(nvs_handle_t h, const char *key, char *out, size_t out_sz)
|
||||
{
|
||||
if (!out || out_sz == 0)
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
out[0] = '\0';
|
||||
|
||||
size_t need = 0;
|
||||
esp_err_t err = nvs_get_str(h, key, NULL, &need);
|
||||
if (err == ESP_ERR_NVS_NOT_FOUND)
|
||||
return ESP_OK;
|
||||
if (err != ESP_OK)
|
||||
return err;
|
||||
|
||||
if (need == 0)
|
||||
return ESP_OK; // vazio
|
||||
|
||||
if (need > out_sz)
|
||||
{
|
||||
// Truncar de forma segura
|
||||
char *tmp = (char *)malloc(need);
|
||||
if (!tmp)
|
||||
return ESP_ERR_NO_MEM;
|
||||
err = nvs_get_str(h, key, tmp, &need);
|
||||
if (err == ESP_OK)
|
||||
{
|
||||
snprintf(out, out_sz, "%s", tmp);
|
||||
}
|
||||
free(tmp);
|
||||
return err;
|
||||
}
|
||||
return nvs_get_str(h, key, out, &need);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Eventos
|
||||
// -----------------------------------------------------------------------------
|
||||
static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
|
||||
{
|
||||
ESP_LOGI(TAG, "event_handler");
|
||||
|
||||
if (event_base == WIFI_EVENT)
|
||||
{
|
||||
if (event_id == WIFI_EVENT_AP_STACONNECTED)
|
||||
switch (event_id)
|
||||
{
|
||||
ESP_LOGI(TAG, "STA connected");
|
||||
case WIFI_EVENT_AP_STACONNECTED:
|
||||
{
|
||||
ESP_LOGI(TAG, "AP: STA connected");
|
||||
wifi_event_ap_staconnected_t *event = (wifi_event_ap_staconnected_t *)event_data;
|
||||
ESP_LOGI(TAG, "WiFi AP " MACSTR " join, AID=%d", MAC2STR(event->mac), event->aid);
|
||||
xEventGroupClearBits(wifi_event_group, WIFI_AP_DISCONNECTED_BIT);
|
||||
xEventGroupSetBits(wifi_event_group, WIFI_AP_CONNECTED_BIT);
|
||||
break;
|
||||
}
|
||||
if (event_id == WIFI_EVENT_AP_STADISCONNECTED)
|
||||
case WIFI_EVENT_AP_STADISCONNECTED:
|
||||
{
|
||||
ESP_LOGI(TAG, "AP STA disconnected");
|
||||
ESP_LOGI(TAG, "AP: STA disconnected");
|
||||
wifi_event_ap_stadisconnected_t *event = (wifi_event_ap_stadisconnected_t *)event_data;
|
||||
ESP_LOGI(TAG, "WiFi AP " MACSTR " leave, AID=%d", MAC2STR(event->mac), event->aid);
|
||||
xEventGroupClearBits(wifi_event_group, WIFI_AP_CONNECTED_BIT);
|
||||
xEventGroupSetBits(wifi_event_group, WIFI_AP_DISCONNECTED_BIT);
|
||||
break;
|
||||
}
|
||||
if (event_id == WIFI_EVENT_STA_DISCONNECTED)
|
||||
{
|
||||
ESP_LOGI(TAG, "STA disconnected");
|
||||
xEventGroupClearBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
|
||||
xEventGroupSetBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);
|
||||
esp_wifi_connect();
|
||||
}
|
||||
if (event_id == WIFI_EVENT_STA_START)
|
||||
case WIFI_EVENT_STA_START:
|
||||
{
|
||||
ESP_LOGI(TAG, "STA start");
|
||||
s_retry_count = 0;
|
||||
esp_wifi_connect();
|
||||
break;
|
||||
}
|
||||
case WIFI_EVENT_STA_DISCONNECTED:
|
||||
{
|
||||
xEventGroupClearBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
|
||||
xEventGroupSetBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);
|
||||
|
||||
wifi_event_sta_disconnected_t *ev = (wifi_event_sta_disconnected_t *)event_data;
|
||||
ESP_LOGW(TAG, "STA disconnected, reason=%d", ev ? ev->reason : -1);
|
||||
|
||||
// NÃO bloquear o event loop com vTaskDelay
|
||||
if (s_retry_count < s_retry_max)
|
||||
{
|
||||
esp_err_t err = esp_wifi_connect();
|
||||
if (err == ESP_OK)
|
||||
{
|
||||
s_retry_count++;
|
||||
ESP_LOGI(TAG, "Retrying connection (%d/%d)", s_retry_count, s_retry_max);
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGW(TAG, "esp_wifi_connect failed (%d)", err);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGE(TAG, "Max retries reached");
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (event_base == IP_EVENT)
|
||||
{
|
||||
ESP_LOGI(TAG, "event_base == IP_EVENT");
|
||||
|
||||
if (event_id == IP_EVENT_STA_GOT_IP || event_id == IP_EVENT_GOT_IP6)
|
||||
{
|
||||
if (event_id == IP_EVENT_STA_GOT_IP)
|
||||
{
|
||||
ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
|
||||
ESP_LOGI(TAG, "WiFi STA got ip: " IPSTR, IP2STR(&event->ip_info.ip));
|
||||
xEventGroupClearBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);
|
||||
xEventGroupSetBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
|
||||
s_retry_count = 0;
|
||||
}
|
||||
else
|
||||
else if (event_id == IP_EVENT_GOT_IP6)
|
||||
{
|
||||
ip_event_got_ip6_t *event = (ip_event_got_ip6_t *)event_data;
|
||||
ESP_LOGI(TAG, "WiFi STA got ip6: " IPV6STR, IPV62STR(event->ip6_info.ip));
|
||||
}
|
||||
xEventGroupClearBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);
|
||||
xEventGroupSetBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
|
||||
s_retry_count = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Config STA/AP
|
||||
// -----------------------------------------------------------------------------
|
||||
static void sta_set_config(void)
|
||||
{
|
||||
|
||||
ESP_LOGI(TAG, "sta_set_config");
|
||||
|
||||
if (wifi_get_enabled())
|
||||
{
|
||||
wifi_config_t wifi_config = {
|
||||
.sta = {
|
||||
.pmf_cfg = {
|
||||
.capable = true,
|
||||
.required = false}}};
|
||||
wifi_get_ssid((char *)wifi_config.sta.ssid);
|
||||
wifi_get_password((char *)wifi_config.sta.password);
|
||||
if (!wifi_get_enabled())
|
||||
return;
|
||||
|
||||
esp_wifi_set_mode(WIFI_MODE_STA);
|
||||
esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config);
|
||||
wifi_config_t wifi_config = {0};
|
||||
wifi_config.sta.pmf_cfg.capable = true;
|
||||
wifi_config.sta.pmf_cfg.required = false;
|
||||
|
||||
// buffers "seguros" vindos da NVS (estes sim têm terminador)
|
||||
char ssid_buf[SSID_BUF_SZ] = {0}; // 33 (32 + '\0')
|
||||
char pass_buf[PASS_BUF_SZ] = {0}; // 65 (64 + '\0')
|
||||
wifi_get_ssid(ssid_buf);
|
||||
wifi_get_password(pass_buf);
|
||||
|
||||
// Copiar **sem** terminador para os campos do esp_wifi (32/64 bytes)
|
||||
// SSID: max 32
|
||||
size_t ssid_len = strnlen(ssid_buf, SSID_MAX_LEN); // até 32
|
||||
memcpy(wifi_config.sta.ssid, ssid_buf, ssid_len);
|
||||
|
||||
// Password WPA/WPA2: 8..63 chars (campo tem 64 bytes)
|
||||
// (se usares rede aberta, pass_len pode ser 0)
|
||||
size_t pass_len = strnlen(pass_buf, 63); // até 63
|
||||
memcpy(wifi_config.sta.password, pass_buf, pass_len);
|
||||
if (pass_len <= 63)
|
||||
{
|
||||
wifi_config.sta.password[pass_len] = '\0';
|
||||
}
|
||||
|
||||
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
|
||||
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config)); // v5.x
|
||||
}
|
||||
|
||||
static void ap_set_config(void)
|
||||
{
|
||||
|
||||
ESP_LOGI(TAG, "ap_set_config");
|
||||
|
||||
wifi_config_t wifi_ap_config = {
|
||||
.ap = {
|
||||
.max_connection = 1,
|
||||
.authmode = WIFI_AUTH_OPEN}};
|
||||
wifi_config_t wifi_ap_config = {0};
|
||||
wifi_ap_config.ap.max_connection = 1;
|
||||
wifi_ap_config.ap.authmode = WIFI_AUTH_OPEN; // para portal cativo, por exemplo
|
||||
|
||||
uint8_t mac[6];
|
||||
esp_wifi_get_mac(ESP_IF_WIFI_AP, mac);
|
||||
sprintf((char *)wifi_ap_config.ap.ssid, AP_SSID, mac[3], mac[4], mac[5]);
|
||||
esp_wifi_get_mac(WIFI_IF_AP, mac);
|
||||
snprintf((char *)wifi_ap_config.ap.ssid, sizeof(wifi_ap_config.ap.ssid),
|
||||
AP_SSID, mac[3], mac[4], mac[5]); // "plx-XXXXXX"
|
||||
|
||||
wifi_config_t wifi_sta_config = {0};
|
||||
|
||||
esp_wifi_set_mode(WIFI_MODE_APSTA);
|
||||
esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_ap_config);
|
||||
esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_sta_config);
|
||||
// Só AP (não mexer na config STA aqui para não a limpar)
|
||||
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
|
||||
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_ap_config));
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Arranque STA
|
||||
// -----------------------------------------------------------------------------
|
||||
static void sta_try_start(void)
|
||||
{
|
||||
|
||||
ESP_LOGI(TAG, "sta_try_start");
|
||||
|
||||
sta_set_config();
|
||||
if (wifi_get_enabled())
|
||||
{
|
||||
ESP_LOGI(TAG, "Starting STA");
|
||||
esp_wifi_start();
|
||||
esp_err_t e = esp_wifi_start();
|
||||
if (e != ESP_OK && e != ESP_ERR_WIFI_CONN)
|
||||
{
|
||||
ESP_LOGW(TAG, "esp_wifi_start returned %d", e);
|
||||
}
|
||||
xEventGroupSetBits(wifi_event_group, WIFI_STA_MODE_BIT);
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// API pública
|
||||
// -----------------------------------------------------------------------------
|
||||
void wifi_ini(void)
|
||||
{
|
||||
|
||||
|
||||
ESP_LOGI(TAG, "Wifi init");
|
||||
|
||||
// Abre NVS (assume que nvs_flash_init() já foi chamado no boot geral)
|
||||
ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs));
|
||||
|
||||
wifi_event_group = xEventGroupCreate();
|
||||
@@ -160,108 +272,125 @@ void wifi_ini(void)
|
||||
sta_netif = esp_netif_create_default_wifi_sta();
|
||||
|
||||
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
|
||||
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
|
||||
|
||||
char chargeid[6];
|
||||
// mDNS: usa dois bytes do MAC para identificar
|
||||
uint8_t mac[6];
|
||||
esp_wifi_get_mac(ESP_IF_WIFI_AP, mac);
|
||||
sprintf((char *)chargeid, MDNS_SSID, 0);
|
||||
esp_wifi_get_mac(WIFI_IF_STA, mac);
|
||||
char chargeid[16];
|
||||
// ex.: "plx00"
|
||||
snprintf(chargeid, sizeof(chargeid), MDNS_SSID, 0);
|
||||
|
||||
// Hostname das interfaces alinhado com o mDNS
|
||||
ESP_ERROR_CHECK(esp_netif_set_hostname(sta_netif, chargeid));
|
||||
ESP_ERROR_CHECK(esp_netif_set_hostname(ap_netif, chargeid));
|
||||
|
||||
ESP_ERROR_CHECK(mdns_init());
|
||||
ESP_ERROR_CHECK(mdns_hostname_set(chargeid));
|
||||
ESP_ERROR_CHECK(mdns_instance_name_set("EVSE controller"));
|
||||
|
||||
sta_try_start();
|
||||
|
||||
}
|
||||
|
||||
esp_netif_t *wifi_get_sta_netif(void)
|
||||
{
|
||||
return sta_netif;
|
||||
}
|
||||
|
||||
esp_netif_t *wifi_get_ap_netif(void)
|
||||
{
|
||||
return ap_netif;
|
||||
}
|
||||
esp_netif_t *wifi_get_sta_netif(void) { return sta_netif; }
|
||||
esp_netif_t *wifi_get_ap_netif(void) { return ap_netif; }
|
||||
|
||||
esp_err_t wifi_set_config(bool enabled, const char *ssid, const char *password)
|
||||
{
|
||||
ESP_LOGI(TAG, "wifi_set_config(enabled=%d)", enabled);
|
||||
|
||||
|
||||
ESP_LOGI(TAG, "wifi_set_config(enabled=%d, ssid=\"%s\")", enabled, ssid?:"<nil>");
|
||||
|
||||
|
||||
// Validação (quando habilitar STA)
|
||||
if (enabled)
|
||||
{
|
||||
if (ssid == NULL || strlen(ssid) == 0)
|
||||
// SSID 1..32
|
||||
if (ssid && (strlen(ssid) == 0 || strlen(ssid) > SSID_MAX_LEN))
|
||||
{
|
||||
ESP_LOGE(TAG, "SSID out of range");
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
if (!ssid)
|
||||
{
|
||||
size_t len = 0;
|
||||
nvs_get_str(nvs, NVS_SSID, NULL, &len);
|
||||
if (len <= 1)
|
||||
esp_err_t e = nvs_get_str(nvs, NVS_SSID, NULL, &len);
|
||||
if (e != ESP_OK || len <= 1)
|
||||
{
|
||||
ESP_LOGE(TAG, "Required SSID");
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ssid != NULL && strlen(ssid) > 32)
|
||||
// Password: 8..63 (se não for vazia). Aceita "" para rede open (caso uses).
|
||||
if (password)
|
||||
{
|
||||
ESP_LOGE(TAG, "SSID out of range");
|
||||
size_t lp = strlen(password);
|
||||
if (lp != 0 && (lp < 8 || lp > 63))
|
||||
{
|
||||
ESP_LOGE(TAG, "Password length must be 8..63");
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
|
||||
if (password != NULL && strlen(password) > 32)
|
||||
{
|
||||
ESP_LOGE(TAG, "Password out of range");
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
|
||||
nvs_set_u8(nvs, NVS_ENABLED, enabled);
|
||||
if (ssid != NULL)
|
||||
{
|
||||
nvs_set_str(nvs, NVS_SSID, ssid);
|
||||
}
|
||||
if (password != NULL)
|
||||
{
|
||||
nvs_set_str(nvs, NVS_PASSWORD, password);
|
||||
}
|
||||
nvs_commit(nvs);
|
||||
// Persiste no NVS
|
||||
ESP_ERROR_CHECK(nvs_set_u8(nvs, NVS_ENABLED, enabled));
|
||||
if (ssid)
|
||||
ESP_ERROR_CHECK(nvs_set_str(nvs, NVS_SSID, ssid));
|
||||
if (password)
|
||||
ESP_ERROR_CHECK(nvs_set_str(nvs, NVS_PASSWORD, password));
|
||||
ESP_ERROR_CHECK(nvs_commit(nvs));
|
||||
|
||||
// Reinicia modo
|
||||
ESP_LOGI(TAG, "Stopping AP/STA");
|
||||
xEventGroupClearBits(wifi_event_group, WIFI_AP_MODE_BIT | WIFI_STA_MODE_BIT);
|
||||
esp_wifi_stop();
|
||||
esp_err_t e = esp_wifi_stop();
|
||||
if (e != ESP_OK && e != ESP_ERR_WIFI_NOT_INIT && e != ESP_ERR_WIFI_STOP_STATE)
|
||||
{
|
||||
ESP_LOGW(TAG, "esp_wifi_stop returned %d", e);
|
||||
}
|
||||
|
||||
sta_try_start();
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
uint16_t wifi_scan(wifi_scan_ap_t *scan_aps)
|
||||
{
|
||||
|
||||
ESP_LOGI(TAG, "wifi_scan");
|
||||
|
||||
if (!scan_aps)
|
||||
return 0;
|
||||
|
||||
uint16_t number = WIFI_SCAN_SCAN_LIST_SIZE;
|
||||
wifi_ap_record_t ap_info[WIFI_SCAN_SCAN_LIST_SIZE];
|
||||
uint16_t ap_count = 0;
|
||||
memset(ap_info, 0, sizeof(ap_info));
|
||||
|
||||
esp_wifi_scan_start(NULL, true);
|
||||
esp_wifi_scan_get_ap_records(&number, ap_info);
|
||||
esp_wifi_scan_get_ap_num(&ap_count);
|
||||
esp_err_t err = esp_wifi_scan_start(NULL, true);
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGW(TAG, "esp_wifi_scan_start failed (%d)", err);
|
||||
return 0;
|
||||
}
|
||||
|
||||
err = esp_wifi_scan_get_ap_records(&number, ap_info);
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGW(TAG, "esp_wifi_scan_get_ap_records failed (%d)", err);
|
||||
return 0;
|
||||
}
|
||||
|
||||
err = esp_wifi_scan_get_ap_num(&ap_count);
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGW(TAG, "esp_wifi_scan_get_ap_num failed (%d)", err);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "wifi_scan --- %d", ap_count);
|
||||
|
||||
for (int i = 0; (i < WIFI_SCAN_SCAN_LIST_SIZE) && (i < ap_count); i++)
|
||||
{
|
||||
|
||||
ESP_LOGI(TAG, "wifi_scan ---");
|
||||
|
||||
strcpy(scan_aps[i].ssid, (const char *)ap_info[i].ssid);
|
||||
// garante que scan_aps[i].ssid tenha pelo menos 33 bytes
|
||||
snprintf(scan_aps[i].ssid, SSID_BUF_SZ, "%s", (const char *)ap_info[i].ssid);
|
||||
scan_aps[i].rssi = ap_info[i].rssi;
|
||||
scan_aps[i].auth = ap_info[i].authmode != WIFI_AUTH_OPEN;
|
||||
}
|
||||
@@ -271,23 +400,30 @@ uint16_t wifi_scan(wifi_scan_ap_t *scan_aps)
|
||||
|
||||
bool wifi_get_enabled(void)
|
||||
{
|
||||
uint8_t value = false;
|
||||
nvs_get_u8(nvs, NVS_ENABLED, &value);
|
||||
uint8_t value = 0;
|
||||
esp_err_t e = nvs_get_u8(nvs, NVS_ENABLED, &value);
|
||||
if (e == ESP_ERR_NVS_NOT_FOUND)
|
||||
return false;
|
||||
if (e != ESP_OK)
|
||||
{
|
||||
ESP_LOGW(TAG, "nvs_get_u8(NVS_ENABLED) failed (%d), assuming disabled", e);
|
||||
return false;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
void wifi_get_ssid(char *value)
|
||||
{
|
||||
size_t len = 32;
|
||||
value[0] = '\0';
|
||||
nvs_get_str(nvs, NVS_SSID, value, &len);
|
||||
if (!value)
|
||||
return;
|
||||
nvs_get_str_safe(nvs, NVS_SSID, value, SSID_BUF_SZ); // 33
|
||||
}
|
||||
|
||||
void wifi_get_password(char *value)
|
||||
{
|
||||
size_t len = 64;
|
||||
value[0] = '\0';
|
||||
nvs_get_str(nvs, NVS_PASSWORD, value, &len);
|
||||
if (!value)
|
||||
return;
|
||||
nvs_get_str_safe(nvs, NVS_PASSWORD, value, PASS_BUF_SZ); // 65
|
||||
}
|
||||
|
||||
void wifi_ap_start(void)
|
||||
@@ -300,7 +436,11 @@ void wifi_ap_start(void)
|
||||
esp_wifi_stop();
|
||||
|
||||
ap_set_config();
|
||||
esp_wifi_start();
|
||||
esp_err_t e = esp_wifi_start();
|
||||
if (e != ESP_OK && e != ESP_ERR_WIFI_CONN)
|
||||
{
|
||||
ESP_LOGW(TAG, "esp_wifi_start (AP) returned %d", e);
|
||||
}
|
||||
|
||||
xEventGroupSetBits(wifi_event_group, WIFI_AP_MODE_BIT);
|
||||
}
|
||||
@@ -319,7 +459,9 @@ void wifi_ap_stop(void)
|
||||
|
||||
bool wifi_is_ap(void)
|
||||
{
|
||||
wifi_mode_t mode;
|
||||
esp_wifi_get_mode(&mode);
|
||||
return mode == WIFI_MODE_APSTA;
|
||||
if (!wifi_event_group)
|
||||
return false;
|
||||
|
||||
EventBits_t bits = xEventGroupGetBits(wifi_event_group);
|
||||
return (bits & WIFI_AP_MODE_BIT) != 0;
|
||||
}
|
||||
|
||||
@@ -66,7 +66,7 @@ typedef struct
|
||||
float frequency;
|
||||
float power_factor;
|
||||
// acumulados
|
||||
float total_energy_kWh;
|
||||
float total_energy_Wh;
|
||||
// derivados práticos
|
||||
int32_t sum_watt; // soma das 3 fases
|
||||
float avg_voltage; // média das 3 fases
|
||||
@@ -79,6 +79,15 @@ static ocpp_meter_cache_t s_meter = {0};
|
||||
static portMUX_TYPE s_meter_mux = portMUX_INITIALIZER_UNLOCKED;
|
||||
static esp_event_handler_instance_t s_meter_inst = NULL;
|
||||
|
||||
// valor de oferta (A por conector)
|
||||
static float s_current_offered_A = 16.0f;
|
||||
|
||||
// novo input apropriado
|
||||
static float getCurrentOffered(void)
|
||||
{
|
||||
return s_current_offered_A;
|
||||
}
|
||||
|
||||
/* =========================
|
||||
* Task / Main Loop
|
||||
* ========================= *
|
||||
@@ -391,7 +400,7 @@ static void on_meter_event(void *arg, esp_event_base_t base, int32_t id, void *d
|
||||
s_meter.watt[2] = evt->watt[2];
|
||||
s_meter.frequency = evt->frequency;
|
||||
s_meter.power_factor = evt->power_factor;
|
||||
s_meter.total_energy_kWh = evt->total_energy; // já vem em kWh segundo o teu .h
|
||||
s_meter.total_energy_Wh = evt->total_energy;
|
||||
s_meter.sum_watt = sum_w;
|
||||
s_meter.avg_voltage = avg_v;
|
||||
s_meter.sum_current = sum_i;
|
||||
@@ -442,34 +451,32 @@ float setPowerMeterInput(void)
|
||||
|
||||
float setEnergyMeterInput(void)
|
||||
{
|
||||
float kwh = 0.0f;
|
||||
float wh = 0.0f;
|
||||
bool have = false;
|
||||
|
||||
portENTER_CRITICAL(&s_meter_mux);
|
||||
have = s_meter.have_data;
|
||||
if (have)
|
||||
kwh = s_meter.total_energy_kWh;
|
||||
wh = s_meter.total_energy_Wh;
|
||||
portEXIT_CRITICAL(&s_meter_mux);
|
||||
|
||||
float wh = kwh * 1000.0f;
|
||||
|
||||
if (!have)
|
||||
{
|
||||
ESP_LOGW(TAG, "[METER] EnergyMeterInput: no data (return 0)");
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGD(TAG, "[METER] EnergyMeterInput: %.3f kWh (%.1f Wh)", kwh, wh);
|
||||
ESP_LOGD(TAG, "[METER] EnergyMeterInput: (%.1f Wh)", wh);
|
||||
}
|
||||
return wh; // agora devolve Wh
|
||||
}
|
||||
|
||||
int setEnergyInput(void)
|
||||
{
|
||||
float energy_kWh = setEnergyMeterInput(); // kWh
|
||||
int wh = (int)lrintf((double)energy_kWh * 1000.0); // Wh arredondado
|
||||
ESP_LOGD(TAG, "[METER] EnergyInput: %.3f kWh -> %d Wh", energy_kWh, wh);
|
||||
return wh;
|
||||
float wh = setEnergyMeterInput();
|
||||
int wh_i = (int)lrintf((double)wh);
|
||||
ESP_LOGD(TAG, "[METER] EnergyInput: %.1f Wh", wh);
|
||||
return wh_i;
|
||||
}
|
||||
|
||||
float setCurrentInput(void)
|
||||
@@ -795,7 +802,7 @@ void ocpp_start(void)
|
||||
|
||||
/* Metering */
|
||||
ocpp_addMeterValueInputFloat(&setCurrentInput, "Current.Import", "A", NULL, NULL);
|
||||
ocpp_addMeterValueInputFloat(&setCurrentInput, "Current.Offered", "A", NULL, NULL);
|
||||
ocpp_addMeterValueInputFloat(&getCurrentOffered, "Current.Offered", "A", NULL, NULL);
|
||||
ocpp_addMeterValueInputFloat(&setVoltageInput, "Voltage", "V", NULL, NULL);
|
||||
ocpp_addMeterValueInputFloat(&setTemperatureInput, "Temperature", "Celsius", NULL, NULL);
|
||||
ocpp_addMeterValueInputFloat(&setPowerMeterInput, "Power.Active.Import", "W", NULL, NULL);
|
||||
|
||||
@@ -17,4 +17,4 @@ set(srcs
|
||||
idf_component_register(SRCS "${srcs}"
|
||||
INCLUDE_DIRS "include"
|
||||
PRIV_REQUIRES nvs_flash driver esp_adc esp_timer
|
||||
REQUIRES config evse api ntc_driver spi_bus_manager)
|
||||
REQUIRES config evse ntc_driver spi_bus_manager)
|
||||
|
||||
@@ -4,23 +4,23 @@
|
||||
#include "esp_log.h"
|
||||
#include "ntc_sensor.h"
|
||||
#include "ntc_driver.h"
|
||||
|
||||
#include "adc.h"
|
||||
|
||||
static const char *TAG = "temp_sensor";
|
||||
|
||||
#define MEASURE_PERIOD 15000 // 10s
|
||||
|
||||
static float temp = 0.0;
|
||||
#define MEASURE_PERIOD 15000 // 15s
|
||||
|
||||
static float temp = 0.0f;
|
||||
static ntc_device_handle_t ntc = NULL;
|
||||
|
||||
static portMUX_TYPE temp_mux = portMUX_INITIALIZER_UNLOCKED;
|
||||
|
||||
static void ntc_sensor_task_func(void *param) {
|
||||
static void ntc_sensor_task_func(void *param)
|
||||
{
|
||||
float t;
|
||||
while (true) {
|
||||
if (ntc_dev_get_temperature(ntc, &t) == ESP_OK) {
|
||||
while (true)
|
||||
{
|
||||
if (ntc_dev_get_temperature(ntc, &t) == ESP_OK)
|
||||
{
|
||||
portENTER_CRITICAL(&temp_mux);
|
||||
temp = t;
|
||||
portEXIT_CRITICAL(&temp_mux);
|
||||
@@ -29,7 +29,8 @@ static void ntc_sensor_task_func(void *param) {
|
||||
}
|
||||
}
|
||||
|
||||
float ntc_temp_sensor(void) {
|
||||
float ntc_temp_sensor(void)
|
||||
{
|
||||
float t;
|
||||
portENTER_CRITICAL(&temp_mux);
|
||||
t = temp;
|
||||
@@ -39,10 +40,8 @@ float ntc_temp_sensor(void) {
|
||||
|
||||
void ntc_sensor_init(void)
|
||||
{
|
||||
|
||||
ESP_LOGI(TAG, "ntc_sensor_init");
|
||||
|
||||
// Select the NTC sensor and initialize the hardware parameters
|
||||
ntc_config_t ntc_config = {
|
||||
.b_value = 3950,
|
||||
.r25_ohm = 10000,
|
||||
@@ -53,11 +52,26 @@ void ntc_sensor_init(void)
|
||||
.channel = ADC_CHANNEL_0,
|
||||
.unit = ADC_UNIT_1};
|
||||
|
||||
// Create the NTC Driver and Init ADC
|
||||
// ntc_device_handle_t ntc = NULL;
|
||||
// Criar driver e inicializar ADC
|
||||
// adc_oneshot_unit_handle_t adc_handle = NULL;
|
||||
ESP_ERROR_CHECK(ntc_dev_create(&ntc_config, &ntc, &adc_handle));
|
||||
ESP_ERROR_CHECK(ntc_dev_get_adc_handle(ntc, &adc_handle));
|
||||
|
||||
// Leitura inicial para log
|
||||
float t0 = 0.0f;
|
||||
esp_err_t err = ntc_dev_get_temperature(ntc, &t0);
|
||||
if (err == ESP_OK)
|
||||
{
|
||||
portENTER_CRITICAL(&temp_mux);
|
||||
temp = t0;
|
||||
portEXIT_CRITICAL(&temp_mux);
|
||||
ESP_LOGI(TAG, "Temperatura inicial: %.2f °C", t0);
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGW(TAG, "Falha na leitura inicial: %s", esp_err_to_name(err));
|
||||
}
|
||||
|
||||
// Tarefa periódica
|
||||
xTaskCreate(ntc_sensor_task_func, "ntc_sensor_task", 5 * 1024, NULL, 3, NULL);
|
||||
}
|
||||
|
||||
@@ -1,14 +1,24 @@
|
||||
set(srcs
|
||||
idf_component_register(
|
||||
SRCS
|
||||
"src/protocols.c"
|
||||
"src/json.c"
|
||||
"src/mqtt.c"
|
||||
"src/date_time.c"
|
||||
INCLUDE_DIRS
|
||||
"include"
|
||||
PRIV_INCLUDE_DIRS
|
||||
"src"
|
||||
PRIV_REQUIRES
|
||||
nvs_flash
|
||||
mqtt
|
||||
cjson
|
||||
vfs
|
||||
spiffs
|
||||
REQUIRES
|
||||
logger
|
||||
network
|
||||
config
|
||||
evse
|
||||
peripherals
|
||||
ocpp
|
||||
auth
|
||||
)
|
||||
|
||||
idf_component_register(SRCS "${srcs}"
|
||||
INCLUDE_DIRS "include"
|
||||
PRIV_INCLUDE_DIRS "src"
|
||||
PRIV_REQUIRES nvs_flash esp_http_server esp_netif esp_https_ota app_update json mqtt vfs spiffs
|
||||
REQUIRES config api logger)
|
||||
|
||||
|
||||
|
||||
@@ -1,371 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import sys
|
||||
|
||||
ZONES_DIR = "/usr/share/zoneinfo/"
|
||||
ZONES = [
|
||||
"Africa/Abidjan",
|
||||
"Africa/Algiers",
|
||||
"Africa/Bissau",
|
||||
"Africa/Cairo",
|
||||
"Africa/Casablanca",
|
||||
"Africa/Ceuta",
|
||||
"Africa/El_Aaiun",
|
||||
"Africa/Johannesburg",
|
||||
"Africa/Juba",
|
||||
"Africa/Khartoum",
|
||||
"Africa/Lagos",
|
||||
"Africa/Maputo",
|
||||
"Africa/Monrovia",
|
||||
"Africa/Nairobi",
|
||||
"Africa/Ndjamena",
|
||||
"Africa/Sao_Tome",
|
||||
"Africa/Tripoli",
|
||||
"Africa/Tunis",
|
||||
"Africa/Windhoek",
|
||||
"America/Adak",
|
||||
"America/Anchorage",
|
||||
"America/Araguaina",
|
||||
"America/Argentina/Buenos_Aires",
|
||||
"America/Argentina/Catamarca",
|
||||
"America/Argentina/Cordoba",
|
||||
"America/Argentina/Jujuy",
|
||||
"America/Argentina/La_Rioja",
|
||||
"America/Argentina/Mendoza",
|
||||
"America/Argentina/Rio_Gallegos",
|
||||
"America/Argentina/Salta",
|
||||
"America/Argentina/San_Juan",
|
||||
"America/Argentina/San_Luis",
|
||||
"America/Argentina/Tucuman",
|
||||
"America/Argentina/Ushuaia",
|
||||
"America/Asuncion",
|
||||
"America/Bahia",
|
||||
"America/Bahia_Banderas",
|
||||
"America/Barbados",
|
||||
"America/Belem",
|
||||
"America/Belize",
|
||||
"America/Boa_Vista",
|
||||
"America/Bogota",
|
||||
"America/Boise",
|
||||
"America/Cambridge_Bay",
|
||||
"America/Campo_Grande",
|
||||
"America/Cancun",
|
||||
"America/Caracas",
|
||||
"America/Cayenne",
|
||||
"America/Cayman",
|
||||
"America/Chicago",
|
||||
"America/Chihuahua",
|
||||
"America/Costa_Rica",
|
||||
"America/Creston",
|
||||
"America/Cuiaba",
|
||||
"America/Curacao",
|
||||
"America/Danmarkshavn",
|
||||
"America/Dawson",
|
||||
"America/Dawson_Creek",
|
||||
"America/Denver",
|
||||
"America/Detroit",
|
||||
"America/Dominica",
|
||||
"America/Edmonton",
|
||||
"America/Eirunepe",
|
||||
"America/El_Salvador",
|
||||
"America/Fortaleza",
|
||||
"America/Fort_Nelson",
|
||||
"America/Glace_Bay",
|
||||
"America/Godthab",
|
||||
"America/Goose_Bay",
|
||||
"America/Grand_Turk",
|
||||
"America/Grenada",
|
||||
"America/Guadeloupe",
|
||||
"America/Guatemala",
|
||||
"America/Guayaquil",
|
||||
"America/Guyana",
|
||||
"America/Halifax",
|
||||
"America/Havana",
|
||||
"America/Hermosillo",
|
||||
"America/Indiana/Indianapolis",
|
||||
"America/Indiana/Knox",
|
||||
"America/Indiana/Marengo",
|
||||
"America/Indiana/Petersburg",
|
||||
"America/Indiana/Tell_City",
|
||||
"America/Indiana/Vevay",
|
||||
"America/Indiana/Vincennes",
|
||||
"America/Indiana/Winamac",
|
||||
"America/Inuvik",
|
||||
"America/Iqaluit",
|
||||
"America/Jamaica",
|
||||
"America/Juneau",
|
||||
"America/Kentucky/Louisville",
|
||||
"America/Kentucky/Monticello",
|
||||
"America/La_Paz",
|
||||
"America/Lima",
|
||||
"America/Los_Angeles",
|
||||
"America/Maceio",
|
||||
"America/Managua",
|
||||
"America/Manaus",
|
||||
"America/Marigot",
|
||||
"America/Martinique",
|
||||
"America/Matamoros",
|
||||
"America/Mazatlan",
|
||||
"America/Menominee",
|
||||
"America/Merida",
|
||||
"America/Metlakatla",
|
||||
"America/Mexico_City",
|
||||
"America/Miquelon",
|
||||
"America/Moncton",
|
||||
"America/Monterrey",
|
||||
"America/Montevideo",
|
||||
"America/New_York",
|
||||
"America/Nome",
|
||||
"America/Noronha",
|
||||
"America/North_Dakota/Beulah",
|
||||
"America/North_Dakota/Center",
|
||||
"America/North_Dakota/New_Salem",
|
||||
"America/Nuuk",
|
||||
"America/Ojinaga",
|
||||
"America/Panama",
|
||||
"America/Paramaribo",
|
||||
"America/Phoenix",
|
||||
"America/Port-au-Prince",
|
||||
"America/Porto_Velho",
|
||||
"America/Puerto_Rico",
|
||||
"America/Punta_Arenas",
|
||||
"America/Rankin_Inlet",
|
||||
"America/Recife",
|
||||
"America/Regina",
|
||||
"America/Resolute",
|
||||
"America/Rio_Branco",
|
||||
"America/Santarem",
|
||||
"America/Santiago",
|
||||
"America/Santo_Domingo",
|
||||
"America/Sao_Paulo",
|
||||
"America/Scoresbysund",
|
||||
"America/Sitka",
|
||||
"America/St_Johns",
|
||||
"America/Swift_Current",
|
||||
"America/Tegucigalpa",
|
||||
"America/Thule",
|
||||
"America/Tijuana",
|
||||
"America/Toronto",
|
||||
"America/Vancouver",
|
||||
"America/Whitehorse",
|
||||
"America/Winnipeg",
|
||||
"America/Yakutat",
|
||||
"Antarctica/Casey",
|
||||
"Antarctica/Davis",
|
||||
"Antarctica/Macquarie",
|
||||
"Antarctica/Mawson",
|
||||
"Antarctica/Palmer",
|
||||
"Antarctica/Rothera",
|
||||
"Antarctica/Troll",
|
||||
"Asia/Almaty",
|
||||
"Asia/Amman",
|
||||
"Asia/Anadyr",
|
||||
"Asia/Aqtau",
|
||||
"Asia/Aqtobe",
|
||||
"Asia/Ashgabat",
|
||||
"Asia/Atyrau",
|
||||
"Asia/Baghdad",
|
||||
"Asia/Bahrain",
|
||||
"Asia/Baku",
|
||||
"Asia/Bangkok",
|
||||
"Asia/Barnaul",
|
||||
"Asia/Beirut",
|
||||
"Asia/Bishkek",
|
||||
"Asia/Brunei",
|
||||
"Asia/Chita",
|
||||
"Asia/Choibalsan",
|
||||
"Asia/Colombo",
|
||||
"Asia/Damascus",
|
||||
"Asia/Dhaka",
|
||||
"Asia/Dili",
|
||||
"Asia/Dubai",
|
||||
"Asia/Dushanbe",
|
||||
"Asia/Famagusta",
|
||||
"Asia/Gaza",
|
||||
"Asia/Hebron",
|
||||
"Asia/Ho_Chi_Minh",
|
||||
"Asia/Hong_Kong",
|
||||
"Asia/Hovd",
|
||||
"Asia/Irkutsk",
|
||||
"Asia/Jakarta",
|
||||
"Asia/Jayapura",
|
||||
"Asia/Jerusalem",
|
||||
"Asia/Kabul",
|
||||
"Asia/Kamchatka",
|
||||
"Asia/Karachi",
|
||||
"Asia/Kathmandu",
|
||||
"Asia/Khandyga",
|
||||
"Asia/Kolkata",
|
||||
"Asia/Krasnoyarsk",
|
||||
"Asia/Kuala_Lumpur",
|
||||
"Asia/Kuching",
|
||||
"Asia/Kuwait",
|
||||
"Asia/Macau",
|
||||
"Asia/Magadan",
|
||||
"Asia/Makassar",
|
||||
"Asia/Manila",
|
||||
"Asia/Nicosia",
|
||||
"Asia/Novokuznetsk",
|
||||
"Asia/Novosibirsk",
|
||||
"Asia/Omsk",
|
||||
"Asia/Oral",
|
||||
"Asia/Pontianak",
|
||||
"Asia/Pyongyang",
|
||||
"Asia/Qatar",
|
||||
"Asia/Qyzylorda",
|
||||
"Asia/Riyadh",
|
||||
"Asia/Sakhalin",
|
||||
"Asia/Samarkand",
|
||||
"Asia/Seoul",
|
||||
"Asia/Shanghai",
|
||||
"Asia/Singapore",
|
||||
"Asia/Srednekolymsk",
|
||||
"Asia/Taipei",
|
||||
"Asia/Tashkent",
|
||||
"Asia/Tbilisi",
|
||||
"Asia/Tehran",
|
||||
"Asia/Thimphu",
|
||||
"Asia/Tokyo",
|
||||
"Asia/Tomsk",
|
||||
"Asia/Ulaanbaatar",
|
||||
"Asia/Urumqi",
|
||||
"Asia/Ust-Nera",
|
||||
"Asia/Vientiane",
|
||||
"Asia/Vladivostok",
|
||||
"Asia/Yakutsk",
|
||||
"Asia/Yangon",
|
||||
"Asia/Yekaterinburg",
|
||||
"Asia/Yerevan",
|
||||
"Atlantic/Azores",
|
||||
"Atlantic/Bermuda",
|
||||
"Atlantic/Canary",
|
||||
"Atlantic/Cape_Verde",
|
||||
"Atlantic/Faroe",
|
||||
"Atlantic/Madeira",
|
||||
"Atlantic/South_Georgia",
|
||||
"Atlantic/Stanley",
|
||||
"Australia/Adelaide",
|
||||
"Australia/Brisbane",
|
||||
"Australia/Broken_Hill",
|
||||
"Australia/Darwin",
|
||||
"Australia/Eucla",
|
||||
"Australia/Hobart",
|
||||
"Australia/Lindeman",
|
||||
"Australia/Lord_Howe",
|
||||
"Australia/Melbourne",
|
||||
"Australia/Perth",
|
||||
"Australia/Sydney",
|
||||
"Europe/Andorra",
|
||||
"Europe/Astrakhan",
|
||||
"Europe/Athens",
|
||||
"Europe/Belgrade",
|
||||
"Europe/Berlin",
|
||||
"Europe/Brussels",
|
||||
"Europe/Bucharest",
|
||||
"Europe/Budapest",
|
||||
"Europe/Chisinau",
|
||||
"Europe/Dublin",
|
||||
"Europe/Gibraltar",
|
||||
"Europe/Helsinki",
|
||||
"Europe/Istanbul",
|
||||
"Europe/Kaliningrad",
|
||||
"Europe/Kyiv",
|
||||
"Europe/Kirov",
|
||||
"Europe/Lisbon",
|
||||
"Europe/London",
|
||||
"Europe/Madrid",
|
||||
"Europe/Malta",
|
||||
"Europe/Minsk",
|
||||
"Europe/Moscow",
|
||||
"Europe/Paris",
|
||||
"Europe/Prague",
|
||||
"Europe/Riga",
|
||||
"Europe/Rome",
|
||||
"Europe/Samara",
|
||||
"Europe/Saratov",
|
||||
"Europe/Simferopol",
|
||||
"Europe/Sofia",
|
||||
"Europe/Tallinn",
|
||||
"Europe/Tirane",
|
||||
"Europe/Ulyanovsk",
|
||||
"Europe/Vienna",
|
||||
"Europe/Vilnius",
|
||||
"Europe/Volgograd",
|
||||
"Europe/Warsaw",
|
||||
"Europe/Zurich",
|
||||
"Indian/Chagos",
|
||||
"Indian/Maldives",
|
||||
"Indian/Mauritius",
|
||||
"Pacific/Apia",
|
||||
"Pacific/Auckland",
|
||||
"Pacific/Bougainville",
|
||||
"Pacific/Chatham",
|
||||
"Pacific/Chuuk",
|
||||
"Pacific/Easter",
|
||||
"Pacific/Efate",
|
||||
"Pacific/Enderbury",
|
||||
"Pacific/Fakaofo",
|
||||
"Pacific/Fiji",
|
||||
"Pacific/Funafuti",
|
||||
"Pacific/Galapagos",
|
||||
"Pacific/Gambier",
|
||||
"Pacific/Guadalcanal",
|
||||
"Pacific/Guam",
|
||||
"Pacific/Honolulu",
|
||||
"Pacific/Kiritimati",
|
||||
"Pacific/Kosrae",
|
||||
"Pacific/Kwajalein",
|
||||
"Pacific/Majuro",
|
||||
"Pacific/Marquesas",
|
||||
"Pacific/Midway",
|
||||
"Pacific/Nauru",
|
||||
"Pacific/Niue",
|
||||
"Pacific/Norfolk",
|
||||
"Pacific/Noumea",
|
||||
"Pacific/Pago_Pago",
|
||||
"Pacific/Palau",
|
||||
"Pacific/Pitcairn",
|
||||
"Pacific/Port_Moresby",
|
||||
"Pacific/Rarotonga",
|
||||
"Pacific/Tahiti",
|
||||
"Pacific/Tarawa",
|
||||
"Pacific/Tongatapu",
|
||||
"Etc/GMT",
|
||||
"Etc/GMT-1",
|
||||
"Etc/GMT-2",
|
||||
"Etc/GMT-3",
|
||||
"Etc/GMT-4",
|
||||
"Etc/GMT-5",
|
||||
"Etc/GMT-6",
|
||||
"Etc/GMT-7",
|
||||
"Etc/GMT-8",
|
||||
"Etc/GMT-9",
|
||||
"Etc/GMT-10",
|
||||
"Etc/GMT-11",
|
||||
"Etc/GMT-12",
|
||||
"Etc/GMT-13",
|
||||
"Etc/GMT-14",
|
||||
"Etc/GMT+1",
|
||||
"Etc/GMT+2",
|
||||
"Etc/GMT+3",
|
||||
"Etc/GMT+4",
|
||||
"Etc/GMT+5",
|
||||
"Etc/GMT+6",
|
||||
"Etc/GMT+7",
|
||||
"Etc/GMT+8",
|
||||
"Etc/GMT+9",
|
||||
"Etc/GMT+10",
|
||||
"Etc/GMT+11",
|
||||
"Etc/GMT+12",
|
||||
"Etc/UTC"
|
||||
]
|
||||
|
||||
def get_tz_string(timezone):
|
||||
data = open(ZONES_DIR + timezone, "rb").read().split(b"\n")[-2]
|
||||
return data.decode("utf-8")
|
||||
|
||||
if __name__ == "__main__":
|
||||
f = open("./src/tz_data.h", "w")
|
||||
for timezone in ZONES:
|
||||
f.write('\t{{"{}", "{}"}},\n'.format(timezone, get_tz_string(timezone)))
|
||||
f.close()
|
||||
@@ -1,61 +0,0 @@
|
||||
#ifndef DATE_TIME_H
|
||||
#define DATE_TIME_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
/**
|
||||
* @brief Initialize timezone and NTP
|
||||
*
|
||||
*/
|
||||
void date_time_init(void);
|
||||
|
||||
/**
|
||||
* @brief Return true if NTP is enabled, stored in NVS
|
||||
*
|
||||
* @return true
|
||||
* @return false
|
||||
*/
|
||||
bool date_time_is_ntp_enabled(void);
|
||||
|
||||
/**
|
||||
* @brief Get NTP server, string length 64, stored in NVS
|
||||
*
|
||||
* @param value
|
||||
*/
|
||||
void date_time_get_ntp_server(char* value);
|
||||
|
||||
/**
|
||||
* @brief Return true if NTP server from DHCP fetch is enabled, stored in NVS
|
||||
*
|
||||
* @return true
|
||||
* @return false
|
||||
*/
|
||||
bool date_time_is_ntp_from_dhcp(void);
|
||||
|
||||
/**
|
||||
* @brief Set timezone and NTP config
|
||||
*
|
||||
* @param enabled
|
||||
* @param server
|
||||
* @param from_dhcp
|
||||
* @return esp_err_t
|
||||
*/
|
||||
esp_err_t date_time_set_ntp_config(bool enabled, const char* server, bool from_dhcp);
|
||||
|
||||
/**
|
||||
* @brief Get timezone, string length 64, stored in NVS
|
||||
*
|
||||
* @param value
|
||||
*/
|
||||
void date_time_get_timezone(char* value);
|
||||
|
||||
/**
|
||||
* @brief Set timezone, string length 64, stored in NVS
|
||||
*
|
||||
* @param value
|
||||
*/
|
||||
esp_err_t date_time_set_timezone(const char* value);
|
||||
|
||||
|
||||
#endif /* DATE_TIME_H */
|
||||
38
components/protocols/include/json.h
Executable file
38
components/protocols/include/json.h
Executable file
@@ -0,0 +1,38 @@
|
||||
#ifndef JSON_H_
|
||||
#define JSON_H_
|
||||
|
||||
#include <stdbool.h>
|
||||
#include "esp_err.h"
|
||||
#include "cJSON.h"
|
||||
|
||||
/**
|
||||
* @brief Gera um objeto JSON com a configuração atual do EVSE.
|
||||
*
|
||||
* Contém parâmetros como corrente máxima, limites de tempo,
|
||||
* trava do conector, temperatura e configuração do OCPP.
|
||||
*
|
||||
* @return Ponteiro para cJSON (deve ser liberado com cJSON_Delete()).
|
||||
*/
|
||||
cJSON* json_get_evse_config(void);
|
||||
|
||||
/**
|
||||
* @brief Define a configuração do EVSE a partir de um objeto JSON.
|
||||
*
|
||||
* Aplica valores recebidos de protocolos como MQTT ou REST.
|
||||
*
|
||||
* @param root Objeto JSON com os campos válidos.
|
||||
* @return ESP_OK se todos os parâmetros foram aplicados com sucesso.
|
||||
*/
|
||||
esp_err_t json_set_evse_config(cJSON* root);
|
||||
|
||||
/**
|
||||
* @brief Retorna o estado atual do EVSE em formato JSON.
|
||||
*
|
||||
* Inclui estado de operação, erros, limites, sessão atual e medições elétricas.
|
||||
*
|
||||
* @return Ponteiro para cJSON (deve ser liberado com cJSON_Delete()).
|
||||
*/
|
||||
cJSON* json_get_state(void);
|
||||
|
||||
|
||||
#endif /* JSON_H_ */
|
||||
@@ -1,27 +0,0 @@
|
||||
#ifndef MODBUS_TCP_H
|
||||
#define MODBUS_TCP_H
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
/**
|
||||
* @brief Init modbus tcp
|
||||
*
|
||||
*/
|
||||
void modbus_tcp_init(void);
|
||||
|
||||
/**
|
||||
* @brief Set enabled, stored in NVS
|
||||
*
|
||||
* @param enabled
|
||||
*/
|
||||
void modbus_tcp_set_enabled(bool enabled);
|
||||
|
||||
/**
|
||||
* @brief Get enabled, stored in NVS
|
||||
*
|
||||
* @return true
|
||||
* @return false
|
||||
*/
|
||||
bool modbus_tcp_is_enabled(void);
|
||||
|
||||
#endif /* MODBUS_TCP_H */
|
||||
@@ -6,63 +6,108 @@
|
||||
#include "esp_err.h"
|
||||
|
||||
/**
|
||||
* @brief Initializes MQTT client and starts background task if enabled in NVS
|
||||
* @file mqtt.h
|
||||
* @brief MQTT configuration and control interface.
|
||||
*
|
||||
* This module provides initialization, configuration,
|
||||
* and runtime access functions for the MQTT client.
|
||||
*
|
||||
* Configuration is persisted in NVS under namespace "mqtt".
|
||||
*/
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
/* Definitions */
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
#define MQTT_MAX_SERVER_LEN 64 /**< Max length for MQTT server URI */
|
||||
#define MQTT_MAX_USER_LEN 32 /**< Max length for MQTT username */
|
||||
#define MQTT_MAX_PASSWORD_LEN 64 /**< Max length for MQTT password */
|
||||
#define MQTT_MAX_BASE_TOPIC_LEN 64 /**< Max length for MQTT base topic */
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
/* Public Functions */
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
* @brief Initialize MQTT subsystem.
|
||||
*
|
||||
* Loads configuration from NVS and starts background publish task
|
||||
* if MQTT is enabled. Must be called once during system startup.
|
||||
*/
|
||||
void mqtt_init(void);
|
||||
|
||||
/**
|
||||
* @brief Set MQTT config
|
||||
* @brief Restart the MQTT client safely.
|
||||
*
|
||||
* @param enabled
|
||||
* @param server NULL value will be skiped
|
||||
* @param base_topic NULL value will be skiped
|
||||
* @param user NULL value will be skiped
|
||||
* @param password NULL value will be skiped
|
||||
* @param periodicity 0 value will be skiped
|
||||
* @return esp_err_t
|
||||
* Stops the current MQTT client (if running) and starts a new one
|
||||
* with the configuration currently stored in NVS.
|
||||
*
|
||||
* Useful when changing Wi-Fi networks, credentials, or broker settings.
|
||||
*
|
||||
* @return ESP_OK on success, or an ESP_ERR_* code otherwise.
|
||||
*/
|
||||
esp_err_t mqtt_set_config(bool enabled, const char* server, const char* base_topic, const char* user, const char* password, uint16_t periodicity);
|
||||
esp_err_t mqtt_restart(void);
|
||||
|
||||
/**
|
||||
* @brief Get MQTT enabled, stored in NVS
|
||||
* @brief Set and persist MQTT configuration parameters in NVS.
|
||||
*
|
||||
* @return true
|
||||
* @return false
|
||||
* Any NULL parameter will be skipped (the previous value remains stored).
|
||||
*
|
||||
* @param enabled Whether MQTT should be enabled (true/false).
|
||||
* @param server Broker URI (e.g. "mqtt://192.168.1.10").
|
||||
* @param base_topic Base topic prefix for publish/subscribe.
|
||||
* @param user MQTT username (optional).
|
||||
* @param password MQTT password (optional).
|
||||
* @param periodicity Publish interval (in seconds). Must be >0 when enabled.
|
||||
*
|
||||
* @return ESP_OK on success, or an ESP_ERR_* code otherwise.
|
||||
*/
|
||||
esp_err_t mqtt_set_config(bool enabled,
|
||||
const char *server,
|
||||
const char *base_topic,
|
||||
const char *user,
|
||||
const char *password,
|
||||
uint16_t periodicity);
|
||||
|
||||
/**
|
||||
* @brief Get whether MQTT is enabled.
|
||||
*
|
||||
* @return true if enabled, false otherwise.
|
||||
*/
|
||||
bool mqtt_get_enabled(void);
|
||||
|
||||
/**
|
||||
* @brief Get MQTT server, string length 64, stored in NVS
|
||||
* @brief Get MQTT broker URI stored in NVS.
|
||||
*
|
||||
* @param value
|
||||
* @param[out] value Buffer to receive the URI (min length: MQTT_MAX_SERVER_LEN).
|
||||
*/
|
||||
void mqtt_get_server(char *value);
|
||||
|
||||
/**
|
||||
* @brief Get MQTT password, string length 64, stored in NVS
|
||||
* @brief Get MQTT base topic stored in NVS.
|
||||
*
|
||||
* @param value
|
||||
*/
|
||||
void mqtt_get_password(char* value);
|
||||
|
||||
/**
|
||||
* @brief Get MQTT base topic, string length 32, stored in NVS
|
||||
*
|
||||
* @param value
|
||||
* @param[out] value Buffer to receive the base topic (min length: MQTT_MAX_BASE_TOPIC_LEN).
|
||||
*/
|
||||
void mqtt_get_base_topic(char *value);
|
||||
|
||||
/**
|
||||
* @brief Get MQTT user, string length 32, stored in NVS
|
||||
* @brief Get MQTT username stored in NVS.
|
||||
*
|
||||
* @param value
|
||||
* @param[out] value Buffer to receive the username (min length: MQTT_MAX_USER_LEN).
|
||||
*/
|
||||
void mqtt_get_user(char *value);
|
||||
|
||||
/**
|
||||
* @brief Get MQTT periodicity in second, stored in NVS
|
||||
* @brief Get MQTT password stored in NVS.
|
||||
*
|
||||
* @return uint16_t
|
||||
* @param[out] value Buffer to receive the password (min length: MQTT_MAX_PASSWORD_LEN).
|
||||
*/
|
||||
void mqtt_get_password(char *value);
|
||||
|
||||
/**
|
||||
* @brief Get MQTT publish periodicity in seconds.
|
||||
*
|
||||
* @return Publish interval in seconds (default: 30).
|
||||
*/
|
||||
uint16_t mqtt_get_periodicity(void);
|
||||
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
|
||||
MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
|
||||
d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
|
||||
QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
|
||||
MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
|
||||
b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
|
||||
9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
|
||||
CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
|
||||
nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
|
||||
43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
|
||||
T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
|
||||
gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
|
||||
BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
|
||||
TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
|
||||
DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
|
||||
hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
|
||||
06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
|
||||
PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
|
||||
YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
|
||||
CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -1,136 +0,0 @@
|
||||
|
||||
#include <time.h>
|
||||
#include "esp_log.h"
|
||||
#include "esp_sntp.h"
|
||||
#include "esp_netif_sntp.h"
|
||||
#include "nvs.h"
|
||||
|
||||
#include "date_time.h"
|
||||
|
||||
#define NVS_NAMESPACE "date_time"
|
||||
#define NVS_NTP_ENABLED "ntp_en"
|
||||
#define NVS_NTP_SERVER "ntp_server"
|
||||
#define NVS_NTP_FROM_DHCP "ntp_from_dhcp"
|
||||
#define NVS_TIMEZONE "timezone"
|
||||
|
||||
static const char* TAG = "date_time";
|
||||
|
||||
static nvs_handle nvs;
|
||||
|
||||
static char ntp_server[64]; // if renew_servers_after_new_IP = false, will be used static string reference
|
||||
|
||||
static const char* tz_data[][2] = {
|
||||
#include "tz_data.h"
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
static const char* find_tz(const char* name)
|
||||
{
|
||||
if (name != NULL) {
|
||||
int index = 0;
|
||||
while (true) {
|
||||
if (tz_data[index][0] == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (strcmp(tz_data[index][0], name) == 0) {
|
||||
return tz_data[index][1];
|
||||
}
|
||||
index++;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void date_time_init(void)
|
||||
{
|
||||
ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs));
|
||||
|
||||
if (date_time_is_ntp_enabled()) {
|
||||
date_time_get_ntp_server(ntp_server);
|
||||
|
||||
esp_sntp_config_t config = ESP_NETIF_SNTP_DEFAULT_CONFIG(ntp_server);
|
||||
|
||||
esp_err_t ret = esp_netif_sntp_init(&config);
|
||||
if (ret != ESP_OK) {
|
||||
ESP_LOGE(TAG, "SNTP init return %s", esp_err_to_name(ret));
|
||||
}
|
||||
}
|
||||
|
||||
char str[64];
|
||||
date_time_get_timezone(str);
|
||||
const char *tz = find_tz(str);
|
||||
if (tz) {
|
||||
setenv("TZ", tz, 1);
|
||||
tzset();
|
||||
} else {
|
||||
ESP_LOGW(TAG, "Unknown timezone %s", str);
|
||||
}
|
||||
}
|
||||
|
||||
bool date_time_is_ntp_enabled(void)
|
||||
{
|
||||
uint8_t value = false;
|
||||
nvs_get_u8(nvs, NVS_NTP_ENABLED, &value);
|
||||
return value;
|
||||
}
|
||||
|
||||
void date_time_get_ntp_server(char* value)
|
||||
{
|
||||
size_t len = 64;
|
||||
value[0] = '\0';
|
||||
nvs_get_str(nvs, NVS_NTP_SERVER, value, &len);
|
||||
}
|
||||
|
||||
bool date_time_is_ntp_from_dhcp(void)
|
||||
{
|
||||
uint8_t value = false;
|
||||
nvs_get_u8(nvs, NVS_NTP_FROM_DHCP, &value);
|
||||
return value;
|
||||
}
|
||||
|
||||
esp_err_t date_time_set_ntp_config(bool enabled, const char* server, bool from_dhcp)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
|
||||
esp_netif_sntp_deinit();
|
||||
if (enabled) {
|
||||
strcpy(ntp_server, server);
|
||||
esp_sntp_config_t config = ESP_NETIF_SNTP_DEFAULT_CONFIG(ntp_server);
|
||||
config.renew_servers_after_new_IP = from_dhcp;
|
||||
ret = esp_netif_sntp_init(&config);
|
||||
}
|
||||
|
||||
if (ret == ESP_OK) {
|
||||
nvs_set_u8(nvs, NVS_NTP_ENABLED, enabled);
|
||||
nvs_set_str(nvs, NVS_NTP_SERVER, server);
|
||||
nvs_set_u8(nvs, NVS_NTP_FROM_DHCP, from_dhcp);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void date_time_get_timezone(char* value)
|
||||
{
|
||||
size_t len = 64;
|
||||
value[0] = '\0';
|
||||
strcpy(value, "Etc/UTC");
|
||||
nvs_get_str(nvs, NVS_TIMEZONE, value, &len);
|
||||
}
|
||||
|
||||
esp_err_t date_time_set_timezone(const char* value)
|
||||
{
|
||||
const char* tz = find_tz(value);
|
||||
|
||||
if (tz) {
|
||||
setenv("TZ", tz, 1);
|
||||
tzset();
|
||||
|
||||
nvs_set_str(nvs, NVS_TIMEZONE, value);
|
||||
|
||||
return ESP_OK;
|
||||
} else {
|
||||
ESP_LOGW(TAG, "Unknown timezone %s", value);
|
||||
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
204
components/protocols/src/json.c
Executable file
204
components/protocols/src/json.c
Executable file
@@ -0,0 +1,204 @@
|
||||
// === Início de: components/protocols/src/json.c ===
|
||||
#include <string.h>
|
||||
#include "sdkconfig.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "esp_wifi.h"
|
||||
#include "esp_timer.h"
|
||||
#include "esp_chip_info.h"
|
||||
#include "esp_mac.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
#include "json.h"
|
||||
#include "mqtt.h"
|
||||
#include "network.h"
|
||||
#include "evse_error.h"
|
||||
#include "evse_api.h"
|
||||
#include "auth.h"
|
||||
#include "evse_limits.h"
|
||||
#include "evse_state.h"
|
||||
#include "evse_config.h"
|
||||
#include "ocpp.h"
|
||||
#include "board_config.h"
|
||||
#include "socket_lock.h"
|
||||
#include "proximity.h"
|
||||
#include "temp_sensor.h"
|
||||
#include "evse_meter.h"
|
||||
|
||||
static const char *TAG = "json";
|
||||
|
||||
//
|
||||
// ===== EVSE CONFIG JSON =====
|
||||
//
|
||||
cJSON *json_get_evse_config(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
if (!root)
|
||||
return NULL;
|
||||
|
||||
cJSON_AddNumberToObject(root, "maxChargingCurrent", evse_get_max_charging_current());
|
||||
cJSON_AddNumberToObject(root, "chargingCurrent", evse_get_charging_current());
|
||||
cJSON_AddNumberToObject(root, "defaultChargingCurrent", evse_get_default_charging_current());
|
||||
cJSON_AddBoolToObject(root, "requireAuth", auth_get_mode());
|
||||
cJSON_AddBoolToObject(root, "socketOutlet", evse_get_socket_outlet());
|
||||
cJSON_AddBoolToObject(root, "rcm", evse_is_rcm());
|
||||
cJSON_AddNumberToObject(root, "temperatureThreshold", evse_get_temp_threshold());
|
||||
cJSON_AddNumberToObject(root, "consumptionLimit", evse_get_consumption_limit());
|
||||
cJSON_AddNumberToObject(root, "defaultConsumptionLimit", evse_get_default_consumption_limit());
|
||||
cJSON_AddNumberToObject(root, "chargingTimeLimit", evse_get_charging_time_limit());
|
||||
cJSON_AddNumberToObject(root, "defaultChargingTimeLimit", evse_get_default_charging_time_limit());
|
||||
cJSON_AddNumberToObject(root, "underPowerLimit", evse_get_under_power_limit());
|
||||
cJSON_AddNumberToObject(root, "defaultUnderPowerLimit", evse_get_default_under_power_limit());
|
||||
|
||||
cJSON_AddNumberToObject(root, "socketLockOperatingTime", socket_lock_get_operating_time());
|
||||
cJSON_AddNumberToObject(root, "socketLockBreakTime", socket_lock_get_break_time());
|
||||
cJSON_AddBoolToObject(root, "socketLockDetectionHigh", socket_lock_is_detection_high());
|
||||
cJSON_AddNumberToObject(root, "socketLockRetryCount", socket_lock_get_retry_count());
|
||||
|
||||
char str[64];
|
||||
cJSON_AddBoolToObject(root, "enabledocpp", ocpp_get_enabled());
|
||||
ocpp_get_server(str);
|
||||
cJSON_AddStringToObject(root, "serverocpp", str);
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
//
|
||||
// ===== SET EVSE CONFIG (from MQTT or REST) =====
|
||||
//
|
||||
esp_err_t json_set_evse_config(cJSON *root)
|
||||
{
|
||||
if (!root)
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
|
||||
// Alguns setters retornam esp_err_t, outros void. Para manter compatibilidade,
|
||||
// chamamos sem propagar erro (se existir, será tratado internamente).
|
||||
#define SET_NUM(key, fn) \
|
||||
do \
|
||||
{ \
|
||||
const cJSON *item = cJSON_GetObjectItem(root, key); \
|
||||
if (cJSON_IsNumber(item)) \
|
||||
{ \
|
||||
fn(item->valuedouble); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define SET_BOOL(key, fn) \
|
||||
do \
|
||||
{ \
|
||||
const cJSON *item = cJSON_GetObjectItem(root, key); \
|
||||
if (cJSON_IsBool(item)) \
|
||||
{ \
|
||||
fn(cJSON_IsTrue(item)); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
SET_NUM("maxChargingCurrent", evse_set_max_charging_current);
|
||||
SET_NUM("chargingCurrent", evse_set_charging_current);
|
||||
SET_NUM("defaultChargingCurrent", evse_set_default_charging_current);
|
||||
SET_BOOL("socketOutlet", evse_set_socket_outlet);
|
||||
SET_BOOL("rcm", evse_set_rcm);
|
||||
SET_NUM("temperatureThreshold", evse_set_temp_threshold);
|
||||
SET_NUM("consumptionLimit", evse_set_consumption_limit);
|
||||
SET_NUM("defaultConsumptionLimit", evse_set_default_consumption_limit);
|
||||
SET_NUM("chargingTimeLimit", evse_set_charging_time_limit);
|
||||
SET_NUM("defaultChargingTimeLimit", evse_set_default_charging_time_limit);
|
||||
SET_NUM("underPowerLimit", evse_set_under_power_limit);
|
||||
SET_NUM("defaultUnderPowerLimit", evse_set_default_under_power_limit);
|
||||
SET_NUM("socketLockOperatingTime", socket_lock_set_operating_time);
|
||||
SET_NUM("socketLockBreakTime", socket_lock_set_break_time);
|
||||
|
||||
const cJSON *retry = cJSON_GetObjectItem(root, "socketLockRetryCount");
|
||||
if (cJSON_IsNumber(retry))
|
||||
socket_lock_set_retry_count(retry->valueint);
|
||||
|
||||
const cJSON *detect = cJSON_GetObjectItem(root, "socketLockDetectionHigh");
|
||||
if (cJSON_IsBool(detect))
|
||||
socket_lock_set_detection_high(cJSON_IsTrue(detect));
|
||||
|
||||
const cJSON *ocpp_enabled = cJSON_GetObjectItem(root, "enabledocpp");
|
||||
if (cJSON_IsBool(ocpp_enabled))
|
||||
ocpp_set_enabled(cJSON_IsTrue(ocpp_enabled));
|
||||
|
||||
const cJSON *ocpp_server = cJSON_GetObjectItem(root, "serverocpp");
|
||||
if (cJSON_IsString(ocpp_server))
|
||||
ocpp_set_server(cJSON_GetStringValue(ocpp_server));
|
||||
|
||||
ESP_LOGI(TAG, "EVSE configuration updated successfully");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
//
|
||||
// ===== EVSE STATE JSON =====
|
||||
//
|
||||
cJSON *json_get_state(void)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
if (!root)
|
||||
return NULL;
|
||||
|
||||
cJSON_AddStringToObject(root, "state", evse_state_to_str(evse_get_state()));
|
||||
cJSON_AddBoolToObject(root, "available", evse_config_is_available());
|
||||
cJSON_AddBoolToObject(root, "enabled", evse_config_is_enabled());
|
||||
cJSON_AddBoolToObject(root, "pendingAuth", auth_get_mode());
|
||||
cJSON_AddBoolToObject(root, "limitReached", evse_is_limit_reached());
|
||||
|
||||
// Add error list
|
||||
uint32_t error = evse_error_get_bits();
|
||||
if (error == 0)
|
||||
{
|
||||
cJSON_AddNullToObject(root, "errors");
|
||||
}
|
||||
else
|
||||
{
|
||||
cJSON *errors = cJSON_CreateArray();
|
||||
if (error & EVSE_ERR_PILOT_FAULT_BIT)
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("pilot_fault"));
|
||||
if (error & EVSE_ERR_DIODE_SHORT_BIT)
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("diode_short"));
|
||||
if (error & EVSE_ERR_LOCK_FAULT_BIT)
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("lock_fault"));
|
||||
if (error & EVSE_ERR_UNLOCK_FAULT_BIT)
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("unlock_fault"));
|
||||
if (error & EVSE_ERR_RCM_TRIGGERED_BIT)
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("rcm_triggered"));
|
||||
if (error & EVSE_ERR_RCM_SELFTEST_FAULT_BIT)
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("rcm_selftest_fault"));
|
||||
if (error & EVSE_ERR_TEMPERATURE_HIGH_BIT)
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("temperature_high"));
|
||||
if (error & EVSE_ERR_TEMPERATURE_FAULT_BIT)
|
||||
cJSON_AddItemToArray(errors, cJSON_CreateString("temperature_fault"));
|
||||
cJSON_AddItemToObject(root, "errors", errors);
|
||||
}
|
||||
|
||||
// Session info
|
||||
evse_session_t sess;
|
||||
if (evse_get_session(&sess))
|
||||
{
|
||||
cJSON_AddNumberToObject(root, "sessionTime", (double)sess.start_tick);
|
||||
cJSON_AddNumberToObject(root, "chargingTime", (double)sess.duration_s);
|
||||
cJSON_AddNumberToObject(root, "consumption", (double)sess.energy_wh);
|
||||
}
|
||||
else
|
||||
{
|
||||
cJSON_AddNullToObject(root, "sessionTime");
|
||||
cJSON_AddNumberToObject(root, "chargingTime", 0);
|
||||
cJSON_AddNumberToObject(root, "consumption", 0);
|
||||
}
|
||||
|
||||
// Meter readings
|
||||
float voltage[EVSE_METER_PHASE_COUNT];
|
||||
float current[EVSE_METER_PHASE_COUNT];
|
||||
int power[EVSE_METER_PHASE_COUNT];
|
||||
|
||||
evse_meter_get_voltage(voltage);
|
||||
evse_meter_get_current(current);
|
||||
evse_meter_get_power(power);
|
||||
|
||||
cJSON_AddItemToObject(root, "power", cJSON_CreateIntArray(power, EVSE_METER_PHASE_COUNT));
|
||||
cJSON_AddItemToObject(root, "voltage", cJSON_CreateFloatArray(voltage, EVSE_METER_PHASE_COUNT));
|
||||
cJSON_AddItemToObject(root, "current", cJSON_CreateFloatArray(current, EVSE_METER_PHASE_COUNT));
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
// === Fim de: components/protocols/src/json.c ===
|
||||
@@ -1,16 +1,20 @@
|
||||
// === Início de: components/protocols/src/mqtt.c ===
|
||||
#include <string.h>
|
||||
#include <sys/param.h>
|
||||
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "freertos/semphr.h"
|
||||
|
||||
#include "esp_log.h"
|
||||
#include "esp_event.h"
|
||||
#include "mqtt_client.h"
|
||||
#include "nvs.h"
|
||||
|
||||
#include "mqtt.h"
|
||||
#include "json.h"
|
||||
#include "board_config.h"
|
||||
#include "timeout_utils.h"
|
||||
#include "mqtt_client.h"
|
||||
|
||||
#define NVS_NAMESPACE "mqtt"
|
||||
#define NVS_ENABLED "enabled"
|
||||
@@ -21,284 +25,413 @@
|
||||
#define NVS_PERIODICITY "periodicity"
|
||||
|
||||
static const char *TAG = "mqtt";
|
||||
|
||||
static TaskHandle_t client_task = NULL;
|
||||
static esp_mqtt_client_handle_t client = NULL;
|
||||
static uint16_t periodicity = 30;
|
||||
static SemaphoreHandle_t mqtt_mutex = NULL;
|
||||
static uint16_t periodicity = 30; // seconds
|
||||
// Nem todas as versões do IDF têm esp_mqtt_client_is_connected(); usamos um flag.
|
||||
static volatile bool mqtt_connected = false;
|
||||
|
||||
static esp_err_t open_mqtt_nvs(nvs_handle_t *handle) {
|
||||
static esp_err_t open_mqtt_nvs(nvs_handle_t *handle)
|
||||
{
|
||||
return nvs_open(NVS_NAMESPACE, NVS_READWRITE, handle);
|
||||
}
|
||||
|
||||
static void subcribe_topics(void)
|
||||
//
|
||||
// Helper: safely publish JSON message
|
||||
//
|
||||
static void publish_message(const char *topic_suffix, cJSON *root)
|
||||
{
|
||||
ESP_LOGI(TAG, "[MQTT] Subscribing to topics");
|
||||
if (!root) return;
|
||||
|
||||
char base[32];
|
||||
if (xSemaphoreTake(mqtt_mutex, pdMS_TO_TICKS(500)) == pdTRUE)
|
||||
{
|
||||
if (client && mqtt_connected)
|
||||
{
|
||||
char base[MQTT_MAX_BASE_TOPIC_LEN] = {0};
|
||||
mqtt_get_base_topic(base);
|
||||
|
||||
char topic[64];
|
||||
char topic[128];
|
||||
snprintf(topic, sizeof(topic), "%s%s", base, topic_suffix);
|
||||
|
||||
snprintf(topic, sizeof(topic), "%s/request/#", base);
|
||||
esp_mqtt_client_subscribe(client, topic, 0);
|
||||
ESP_LOGI(TAG, " subscribed: %s", topic);
|
||||
|
||||
snprintf(topic, sizeof(topic), "%s/set/config/#", base);
|
||||
esp_mqtt_client_subscribe(client, topic, 0);
|
||||
ESP_LOGI(TAG, " subscribed: %s", topic);
|
||||
|
||||
snprintf(topic, sizeof(topic), "%s/enable", base);
|
||||
esp_mqtt_client_subscribe(client, topic, 0);
|
||||
ESP_LOGI(TAG, " subscribed: %s", topic);
|
||||
}
|
||||
|
||||
static void publish_message(const char* topic, cJSON* root)
|
||||
char *json = cJSON_PrintUnformatted(root);
|
||||
if (json)
|
||||
{
|
||||
char target_topic[64];
|
||||
mqtt_get_base_topic(target_topic);
|
||||
strncat(target_topic, topic, sizeof(target_topic) - strlen(target_topic) - 1);
|
||||
|
||||
const char* json = cJSON_PrintUnformatted(root);
|
||||
esp_mqtt_client_publish(client, target_topic, json, 0, 1, 0);
|
||||
free((void*)json);
|
||||
esp_mqtt_client_publish(client, topic, json, 0, 1, 0);
|
||||
ESP_LOGI(TAG, "Published to %s", topic);
|
||||
free(json);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGW(TAG, "MQTT client not connected — skipping publish");
|
||||
}
|
||||
xSemaphoreGive(mqtt_mutex);
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGW(TAG, "MQTT mutex timeout during publish");
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Subscriptions
|
||||
//
|
||||
static void subscribe_topics(void)
|
||||
{
|
||||
if (!client) return;
|
||||
|
||||
char base[MQTT_MAX_BASE_TOPIC_LEN] = {0};
|
||||
mqtt_get_base_topic(base);
|
||||
|
||||
const char *subs[] = {
|
||||
"/request/#",
|
||||
"/set/config/#",
|
||||
"/enable",
|
||||
"/request/restart",
|
||||
"/request/config/evse",
|
||||
"/request/boardConfig"
|
||||
};
|
||||
|
||||
for (size_t i = 0; i < sizeof(subs) / sizeof(subs[0]); i++)
|
||||
{
|
||||
char topic[MQTT_MAX_BASE_TOPIC_LEN + 32];
|
||||
snprintf(topic, sizeof(topic), "%s%s", base, subs[i]);
|
||||
esp_mqtt_client_subscribe(client, topic, 0);
|
||||
ESP_LOGI(TAG, "[MQTT] Subscribed: %s", topic);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Message handler
|
||||
//
|
||||
static void handle_message(const char *topic, const char *data)
|
||||
{
|
||||
char base_topic[32];
|
||||
mqtt_get_base_topic(base_topic);
|
||||
if (!topic || !data) return;
|
||||
|
||||
ESP_LOGI(TAG, "Topic: %s", topic);
|
||||
ESP_LOGI(TAG, "data: %s", data);
|
||||
ESP_LOGI(TAG, "base_topic: %s", base_topic);
|
||||
char base[MQTT_MAX_BASE_TOPIC_LEN] = {0};
|
||||
mqtt_get_base_topic(base);
|
||||
|
||||
if (strncmp(topic, base_topic, strlen(base_topic)) == 0) {
|
||||
const char* sub_topic = &topic[strlen(base_topic)];
|
||||
if (strncmp(topic, base, strlen(base)) != 0) return;
|
||||
|
||||
ESP_LOGI(TAG, "Sub_topic: %s", sub_topic);
|
||||
const char *sub_topic = &topic[strlen(base)];
|
||||
ESP_LOGI(TAG, "[MQTT] Received on %s: %s", sub_topic, data);
|
||||
|
||||
if (strcmp(sub_topic, "/request/config/evse") == 0) {
|
||||
if (strcmp(sub_topic, "/request/config/evse") == 0)
|
||||
{
|
||||
cJSON *root = json_get_evse_config();
|
||||
publish_message("/response/config/evse", root);
|
||||
cJSON_Delete(root);
|
||||
} else if (strcmp(sub_topic, "/request/config/wifi") == 0) {
|
||||
//cJSON* root = json_get_wifi_config();
|
||||
//publish_message("/response/config/wifi", root);
|
||||
//cJSON_Delete(root);
|
||||
} else if (strcmp(sub_topic, "/request/config/mqtt") == 0) {
|
||||
cJSON* root = json_get_mqtt_config();
|
||||
publish_message("/response/config/mqtt", root);
|
||||
cJSON_Delete(root);
|
||||
} else if (strcmp(sub_topic, "/request/boardConfig") == 0) {
|
||||
cJSON* root = json_get_board_config();
|
||||
publish_message("/response/boardConfig", root);
|
||||
cJSON_Delete(root);
|
||||
} else if (strcmp(sub_topic, "/request/info") == 0) {
|
||||
cJSON* root = json_get_info();
|
||||
publish_message("/response/info", root);
|
||||
cJSON_Delete(root);
|
||||
} else if (strcmp(sub_topic, "/request/restart") == 0) {
|
||||
timeout_restart();
|
||||
} else if (strcmp(sub_topic, "/set/config/evse") == 0) {
|
||||
}
|
||||
else if (strcmp(sub_topic, "/set/config/evse") == 0)
|
||||
{
|
||||
cJSON *root = cJSON_Parse(data);
|
||||
if (!root)
|
||||
{
|
||||
ESP_LOGE(TAG, "Invalid JSON payload on topic %s", topic);
|
||||
return;
|
||||
}
|
||||
json_set_evse_config(root);
|
||||
cJSON_Delete(root);
|
||||
} else if (strcmp(sub_topic, "/set/config/wifi") == 0) {
|
||||
//cJSON* root = cJSON_Parse(data);
|
||||
//json_set_wifi_config(root, true);
|
||||
//cJSON_Delete(root);
|
||||
} else if (strcmp(sub_topic, "/set/config/mqtt") == 0) {
|
||||
cJSON* root = cJSON_Parse(data);
|
||||
json_set_mqtt_config(root);
|
||||
cJSON_Delete(root);
|
||||
}
|
||||
else if (strcmp(sub_topic, "/request/restart") == 0)
|
||||
{
|
||||
ESP_LOGW(TAG, "Restart request received (TODO: add auth check)");
|
||||
// esp_restart();
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// MQTT event handler
|
||||
//
|
||||
static void event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
|
||||
{
|
||||
esp_mqtt_event_handle_t event = event_data;
|
||||
|
||||
switch (event_id) {
|
||||
switch (event_id)
|
||||
{
|
||||
case MQTT_EVENT_CONNECTED:
|
||||
ESP_LOGI(TAG, "[MQTT] Connected to broker");
|
||||
mqtt_connected = true;
|
||||
if (client_task) vTaskResume(client_task);
|
||||
subcribe_topics();
|
||||
subscribe_topics();
|
||||
break;
|
||||
|
||||
case MQTT_EVENT_DATA: {
|
||||
char topic[64] = {0};
|
||||
char data[256] = {0};
|
||||
case MQTT_EVENT_DATA:
|
||||
{
|
||||
char topic[128] = {0};
|
||||
char data_buf[512] = {0};
|
||||
|
||||
int tlen = MIN(event->topic_len, sizeof(topic) - 1);
|
||||
int dlen = MIN(event->data_len, sizeof(data) - 1);
|
||||
int tlen = MIN(event->topic_len, (int)sizeof(topic) - 1);
|
||||
int dlen = MIN(event->data_len, (int)sizeof(data_buf) - 1);
|
||||
|
||||
memcpy(topic, event->topic, tlen);
|
||||
memcpy(data, event->data, dlen);
|
||||
memcpy(data_buf, event->data, dlen);
|
||||
|
||||
handle_message(topic, data);
|
||||
handle_message(topic, data_buf);
|
||||
break;
|
||||
}
|
||||
case MQTT_EVENT_DISCONNECTED:
|
||||
ESP_LOGW(TAG, "[MQTT] Disconnected from broker");
|
||||
mqtt_connected = false;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Background periodic publisher
|
||||
//
|
||||
static void client_task_func(void *param)
|
||||
{
|
||||
while (true) {
|
||||
if (!client) vTaskSuspend(NULL);
|
||||
for (;;)
|
||||
{
|
||||
if (client && mqtt_connected)
|
||||
{
|
||||
cJSON *root = json_get_state();
|
||||
publish_message("/state", root);
|
||||
cJSON_Delete(root);
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGW(TAG, "[MQTT] Not connected — skipping state publish");
|
||||
}
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(periodicity * 1000));
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Start/stop MQTT
|
||||
//
|
||||
static void client_start(void)
|
||||
{
|
||||
char server[64], user[32], password[64];
|
||||
char server[MQTT_MAX_SERVER_LEN] = {0};
|
||||
char user[MQTT_MAX_USER_LEN] = {0};
|
||||
char password[MQTT_MAX_PASSWORD_LEN] = {0};
|
||||
|
||||
mqtt_get_server(server);
|
||||
mqtt_get_user(user);
|
||||
mqtt_get_password(password);
|
||||
|
||||
if (!strlen(server))
|
||||
{
|
||||
ESP_LOGW(TAG, "[MQTT] No server configured");
|
||||
return;
|
||||
}
|
||||
|
||||
esp_mqtt_client_config_t cfg = {
|
||||
.broker.address.uri = server,
|
||||
.credentials.username = user,
|
||||
.credentials.authentication.password = password
|
||||
};
|
||||
|
||||
if (!client) {
|
||||
if (!client)
|
||||
{
|
||||
client = esp_mqtt_client_init(&cfg);
|
||||
esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, event_handler, client);
|
||||
esp_mqtt_client_start(client);
|
||||
ESP_LOGI(TAG, "[MQTT] Client started");
|
||||
}
|
||||
}
|
||||
|
||||
static void client_stop(void)
|
||||
{
|
||||
if (client) {
|
||||
if (client)
|
||||
{
|
||||
esp_mqtt_client_stop(client);
|
||||
esp_mqtt_client_destroy(client);
|
||||
client = NULL;
|
||||
mqtt_connected = false;
|
||||
ESP_LOGI(TAG, "[MQTT] Client stopped");
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t mqtt_restart(void)
|
||||
{
|
||||
ESP_LOGI(TAG, "[MQTT] Restarting client...");
|
||||
|
||||
if (client)
|
||||
{
|
||||
esp_mqtt_client_stop(client);
|
||||
esp_mqtt_client_destroy(client);
|
||||
client = NULL;
|
||||
mqtt_connected = false;
|
||||
ESP_LOGI(TAG, "[MQTT] Existing client stopped");
|
||||
}
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(500));
|
||||
client_start();
|
||||
|
||||
if (client)
|
||||
{
|
||||
ESP_LOGI(TAG, "[MQTT] Restart complete");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
ESP_LOGE(TAG, "[MQTT] Restart failed — no valid configuration");
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
//
|
||||
// Public API
|
||||
//
|
||||
void mqtt_init(void)
|
||||
{
|
||||
if (!mqtt_mutex)
|
||||
mqtt_mutex = xSemaphoreCreateMutex();
|
||||
|
||||
nvs_handle_t handle;
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK) {
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK)
|
||||
{
|
||||
nvs_get_u16(handle, NVS_PERIODICITY, &periodicity);
|
||||
nvs_close(handle);
|
||||
if (periodicity == 0) periodicity = 30;
|
||||
}
|
||||
|
||||
esp_register_shutdown_handler(&client_stop);
|
||||
xTaskCreate(client_task_func, "mqtt_client_task", 3 * 1024, NULL, 5, &client_task);
|
||||
xTaskCreate(client_task_func, "mqtt_client_task", 4 * 1024, NULL, 5, &client_task);
|
||||
|
||||
if (mqtt_get_enabled()) {
|
||||
if (mqtt_get_enabled())
|
||||
{
|
||||
client_start();
|
||||
}
|
||||
}
|
||||
|
||||
esp_err_t mqtt_set_config(bool enabled, const char* server, const char* base_topic, const char* user, const char* password, uint16_t _periodicity)
|
||||
esp_err_t mqtt_set_config(bool enabled, const char *server, const char *base_topic,
|
||||
const char *user, const char *password, uint16_t _periodicity)
|
||||
{
|
||||
nvs_handle_t handle;
|
||||
if (open_mqtt_nvs(&handle) != ESP_OK) return ESP_ERR_INVALID_STATE;
|
||||
if (open_mqtt_nvs(&handle) != ESP_OK)
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
|
||||
char full_server[64];
|
||||
if (server && strncmp(server, "mqtt://", 7) != 0 && strncmp(server, "tcp://", 6) != 0) {
|
||||
char full_server[MQTT_MAX_SERVER_LEN];
|
||||
if (server && strncmp(server, "mqtt://", 7) != 0 && strncmp(server, "tcp://", 6) != 0)
|
||||
{
|
||||
snprintf(full_server, sizeof(full_server), "mqtt://%s", server);
|
||||
server = full_server;
|
||||
}
|
||||
|
||||
if (enabled) {
|
||||
if (!server || !*server) return ESP_ERR_INVALID_ARG;
|
||||
if (!base_topic || !*base_topic) return ESP_ERR_INVALID_ARG;
|
||||
if (_periodicity == 0) return ESP_ERR_INVALID_ARG;
|
||||
if (enabled)
|
||||
{
|
||||
if (!server || !*server || !base_topic || !*base_topic || !_periodicity)
|
||||
{
|
||||
nvs_close(handle);
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
|
||||
if (server) nvs_set_str(handle, NVS_SERVER, server);
|
||||
if (base_topic) nvs_set_str(handle, NVS_BASE_TOPIC, base_topic);
|
||||
if (user) nvs_set_str(handle, NVS_USER, user);
|
||||
if (password) nvs_set_str(handle, NVS_PASSWORD, password);
|
||||
nvs_set_u8(handle, NVS_ENABLED, enabled);
|
||||
nvs_set_u16(handle, NVS_PERIODICITY, _periodicity);
|
||||
|
||||
periodicity = _periodicity;
|
||||
nvs_set_u8(handle, NVS_ENABLED, enabled ? 1 : 0);
|
||||
nvs_set_u16(handle, NVS_PERIODICITY, _periodicity);
|
||||
periodicity = _periodicity ? _periodicity : periodicity;
|
||||
|
||||
esp_err_t err = nvs_commit(handle);
|
||||
nvs_close(handle);
|
||||
|
||||
if (err != ESP_OK) return err;
|
||||
if (err != ESP_OK)
|
||||
return err;
|
||||
|
||||
if (enabled) {
|
||||
if (enabled)
|
||||
client_start();
|
||||
} else {
|
||||
else
|
||||
client_stop();
|
||||
}
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
/* ---------------------- Getters públicos (faltavam) ---------------------- */
|
||||
|
||||
bool mqtt_get_enabled(void)
|
||||
{
|
||||
nvs_handle_t handle;
|
||||
uint8_t val = false;
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK) {
|
||||
nvs_get_u8(handle, NVS_ENABLED, &val);
|
||||
uint8_t en = 0;
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK)
|
||||
{
|
||||
nvs_get_u8(handle, NVS_ENABLED, &en);
|
||||
nvs_close(handle);
|
||||
}
|
||||
return val;
|
||||
return en != 0;
|
||||
}
|
||||
|
||||
static void nvs_get_str_into(nvs_handle_t handle, const char *key, char *out, size_t outlen)
|
||||
{
|
||||
if (!out || outlen == 0) return;
|
||||
out[0] = '\0';
|
||||
size_t len = outlen;
|
||||
esp_err_t err = nvs_get_str(handle, key, out, &len);
|
||||
if (err != ESP_OK) out[0] = '\0';
|
||||
}
|
||||
|
||||
void mqtt_get_server(char *value)
|
||||
{
|
||||
if (!value) return;
|
||||
value[0] = '\0';
|
||||
nvs_handle_t handle;
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK) {
|
||||
size_t len = 64;
|
||||
nvs_get_str(handle, NVS_SERVER, value, &len);
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK)
|
||||
{
|
||||
nvs_get_str_into(handle, NVS_SERVER, value, MQTT_MAX_SERVER_LEN);
|
||||
nvs_close(handle);
|
||||
}
|
||||
else if (value) value[0] = '\0';
|
||||
}
|
||||
|
||||
void mqtt_get_base_topic(char *value)
|
||||
{
|
||||
if (!value) return;
|
||||
value[0] = '\0';
|
||||
nvs_handle_t handle;
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK) {
|
||||
size_t len = 32;
|
||||
nvs_get_str(handle, NVS_BASE_TOPIC, value, &len);
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK)
|
||||
{
|
||||
nvs_get_str_into(handle, NVS_BASE_TOPIC, value, MQTT_MAX_BASE_TOPIC_LEN);
|
||||
nvs_close(handle);
|
||||
}
|
||||
else if (value) value[0] = '\0';
|
||||
}
|
||||
|
||||
void mqtt_get_user(char *value)
|
||||
{
|
||||
if (!value) return;
|
||||
value[0] = '\0';
|
||||
nvs_handle_t handle;
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK) {
|
||||
size_t len = 32;
|
||||
nvs_get_str(handle, NVS_USER, value, &len);
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK)
|
||||
{
|
||||
nvs_get_str_into(handle, NVS_USER, value, MQTT_MAX_USER_LEN);
|
||||
nvs_close(handle);
|
||||
}
|
||||
else if (value) value[0] = '\0';
|
||||
}
|
||||
|
||||
void mqtt_get_password(char *value)
|
||||
{
|
||||
if (!value) return;
|
||||
value[0] = '\0';
|
||||
nvs_handle_t handle;
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK) {
|
||||
size_t len = 64;
|
||||
nvs_get_str(handle, NVS_PASSWORD, value, &len);
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK)
|
||||
{
|
||||
nvs_get_str_into(handle, NVS_PASSWORD, value, MQTT_MAX_PASSWORD_LEN);
|
||||
nvs_close(handle);
|
||||
}
|
||||
else if (value) value[0] = '\0';
|
||||
}
|
||||
|
||||
uint16_t mqtt_get_periodicity(void)
|
||||
{
|
||||
// devolve o cache atual; se não tiver sido carregado, lê NVS
|
||||
if (periodicity == 0)
|
||||
{
|
||||
nvs_handle_t handle;
|
||||
if (open_mqtt_nvs(&handle) == ESP_OK)
|
||||
{
|
||||
nvs_get_u16(handle, NVS_PERIODICITY, &periodicity);
|
||||
nvs_close(handle);
|
||||
if (periodicity == 0) periodicity = 30;
|
||||
}
|
||||
else
|
||||
{
|
||||
periodicity = 30;
|
||||
}
|
||||
}
|
||||
return periodicity;
|
||||
}
|
||||
|
||||
// === Fim de: components/protocols/src/mqtt.c ===
|
||||
|
||||
@@ -1,14 +1,7 @@
|
||||
#include "protocols.h"
|
||||
#include "date_time.h"
|
||||
//#include "rest.h"
|
||||
#include "mqtt.h"
|
||||
//#include "modbus_tcp.h"
|
||||
|
||||
void protocols_init(void)
|
||||
{
|
||||
date_time_init();
|
||||
/* Serve static files from the SPIFFS data partition */
|
||||
// rest_init("/data");
|
||||
mqtt_init();
|
||||
//modbus_tcp_init();
|
||||
}
|
||||
@@ -1,354 +0,0 @@
|
||||
{"Africa/Abidjan", "GMT0"},
|
||||
{"Africa/Algiers", "CET-1"},
|
||||
{"Africa/Bissau", "GMT0"},
|
||||
{"Africa/Cairo", "EET-2EEST,M4.5.5/0,M10.5.4/24"},
|
||||
{"Africa/Casablanca", "<+01>-1"},
|
||||
{"Africa/Ceuta", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Africa/El_Aaiun", "<+01>-1"},
|
||||
{"Africa/Johannesburg", "SAST-2"},
|
||||
{"Africa/Juba", "CAT-2"},
|
||||
{"Africa/Khartoum", "CAT-2"},
|
||||
{"Africa/Lagos", "WAT-1"},
|
||||
{"Africa/Maputo", "CAT-2"},
|
||||
{"Africa/Monrovia", "GMT0"},
|
||||
{"Africa/Nairobi", "EAT-3"},
|
||||
{"Africa/Ndjamena", "WAT-1"},
|
||||
{"Africa/Sao_Tome", "GMT0"},
|
||||
{"Africa/Tripoli", "EET-2"},
|
||||
{"Africa/Tunis", "CET-1"},
|
||||
{"Africa/Windhoek", "CAT-2"},
|
||||
{"America/Adak", "HST10HDT,M3.2.0,M11.1.0"},
|
||||
{"America/Anchorage", "AKST9AKDT,M3.2.0,M11.1.0"},
|
||||
{"America/Araguaina", "<-03>3"},
|
||||
{"America/Argentina/Buenos_Aires", "<-03>3"},
|
||||
{"America/Argentina/Catamarca", "<-03>3"},
|
||||
{"America/Argentina/Cordoba", "<-03>3"},
|
||||
{"America/Argentina/Jujuy", "<-03>3"},
|
||||
{"America/Argentina/La_Rioja", "<-03>3"},
|
||||
{"America/Argentina/Mendoza", "<-03>3"},
|
||||
{"America/Argentina/Rio_Gallegos", "<-03>3"},
|
||||
{"America/Argentina/Salta", "<-03>3"},
|
||||
{"America/Argentina/San_Juan", "<-03>3"},
|
||||
{"America/Argentina/San_Luis", "<-03>3"},
|
||||
{"America/Argentina/Tucuman", "<-03>3"},
|
||||
{"America/Argentina/Ushuaia", "<-03>3"},
|
||||
{"America/Asuncion", "<-04>4<-03>,M10.1.0/0,M3.4.0/0"},
|
||||
{"America/Bahia", "<-03>3"},
|
||||
{"America/Bahia_Banderas", "CST6"},
|
||||
{"America/Barbados", "AST4"},
|
||||
{"America/Belem", "<-03>3"},
|
||||
{"America/Belize", "CST6"},
|
||||
{"America/Boa_Vista", "<-04>4"},
|
||||
{"America/Bogota", "<-05>5"},
|
||||
{"America/Boise", "MST7MDT,M3.2.0,M11.1.0"},
|
||||
{"America/Cambridge_Bay", "MST7MDT,M3.2.0,M11.1.0"},
|
||||
{"America/Campo_Grande", "<-04>4"},
|
||||
{"America/Cancun", "EST5"},
|
||||
{"America/Caracas", "<-04>4"},
|
||||
{"America/Cayenne", "<-03>3"},
|
||||
{"America/Cayman", "EST5"},
|
||||
{"America/Chicago", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Chihuahua", "CST6"},
|
||||
{"America/Costa_Rica", "CST6"},
|
||||
{"America/Creston", "MST7"},
|
||||
{"America/Cuiaba", "<-04>4"},
|
||||
{"America/Curacao", "AST4"},
|
||||
{"America/Danmarkshavn", "GMT0"},
|
||||
{"America/Dawson", "MST7"},
|
||||
{"America/Dawson_Creek", "MST7"},
|
||||
{"America/Denver", "MST7MDT,M3.2.0,M11.1.0"},
|
||||
{"America/Detroit", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Dominica", "AST4"},
|
||||
{"America/Edmonton", "MST7MDT,M3.2.0,M11.1.0"},
|
||||
{"America/Eirunepe", "<-05>5"},
|
||||
{"America/El_Salvador", "CST6"},
|
||||
{"America/Fortaleza", "<-03>3"},
|
||||
{"America/Fort_Nelson", "MST7"},
|
||||
{"America/Glace_Bay", "AST4ADT,M3.2.0,M11.1.0"},
|
||||
{"America/Godthab", "<-02>2<-01>,M3.5.0/-1,M10.5.0/0"},
|
||||
{"America/Goose_Bay", "AST4ADT,M3.2.0,M11.1.0"},
|
||||
{"America/Grand_Turk", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Grenada", "AST4"},
|
||||
{"America/Guadeloupe", "AST4"},
|
||||
{"America/Guatemala", "CST6"},
|
||||
{"America/Guayaquil", "<-05>5"},
|
||||
{"America/Guyana", "<-04>4"},
|
||||
{"America/Halifax", "AST4ADT,M3.2.0,M11.1.0"},
|
||||
{"America/Havana", "CST5CDT,M3.2.0/0,M11.1.0/1"},
|
||||
{"America/Hermosillo", "MST7"},
|
||||
{"America/Indiana/Indianapolis", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Indiana/Knox", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Indiana/Marengo", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Indiana/Petersburg", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Indiana/Tell_City", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Indiana/Vevay", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Indiana/Vincennes", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Indiana/Winamac", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Inuvik", "MST7MDT,M3.2.0,M11.1.0"},
|
||||
{"America/Iqaluit", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Jamaica", "EST5"},
|
||||
{"America/Juneau", "AKST9AKDT,M3.2.0,M11.1.0"},
|
||||
{"America/Kentucky/Louisville", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Kentucky/Monticello", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/La_Paz", "<-04>4"},
|
||||
{"America/Lima", "<-05>5"},
|
||||
{"America/Los_Angeles", "PST8PDT,M3.2.0,M11.1.0"},
|
||||
{"America/Maceio", "<-03>3"},
|
||||
{"America/Managua", "CST6"},
|
||||
{"America/Manaus", "<-04>4"},
|
||||
{"America/Marigot", "AST4"},
|
||||
{"America/Martinique", "AST4"},
|
||||
{"America/Matamoros", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Mazatlan", "MST7"},
|
||||
{"America/Menominee", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Merida", "CST6"},
|
||||
{"America/Metlakatla", "AKST9AKDT,M3.2.0,M11.1.0"},
|
||||
{"America/Mexico_City", "CST6"},
|
||||
{"America/Miquelon", "<-03>3<-02>,M3.2.0,M11.1.0"},
|
||||
{"America/Moncton", "AST4ADT,M3.2.0,M11.1.0"},
|
||||
{"America/Monterrey", "CST6"},
|
||||
{"America/Montevideo", "<-03>3"},
|
||||
{"America/New_York", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Nome", "AKST9AKDT,M3.2.0,M11.1.0"},
|
||||
{"America/Noronha", "<-02>2"},
|
||||
{"America/North_Dakota/Beulah", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/North_Dakota/Center", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/North_Dakota/New_Salem", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Nuuk", "<-02>2<-01>,M3.5.0/-1,M10.5.0/0"},
|
||||
{"America/Ojinaga", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Panama", "EST5"},
|
||||
{"America/Paramaribo", "<-03>3"},
|
||||
{"America/Phoenix", "MST7"},
|
||||
{"America/Port-au-Prince", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Porto_Velho", "<-04>4"},
|
||||
{"America/Puerto_Rico", "AST4"},
|
||||
{"America/Punta_Arenas", "<-03>3"},
|
||||
{"America/Rankin_Inlet", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Recife", "<-03>3"},
|
||||
{"America/Regina", "CST6"},
|
||||
{"America/Resolute", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Rio_Branco", "<-05>5"},
|
||||
{"America/Santarem", "<-03>3"},
|
||||
{"America/Santiago", "<-04>4<-03>,M9.1.6/24,M4.1.6/24"},
|
||||
{"America/Santo_Domingo", "AST4"},
|
||||
{"America/Sao_Paulo", "<-03>3"},
|
||||
{"America/Scoresbysund", "<-01>1<+00>,M3.5.0/0,M10.5.0/1"},
|
||||
{"America/Sitka", "AKST9AKDT,M3.2.0,M11.1.0"},
|
||||
{"America/St_Johns", "NST3:30NDT,M3.2.0,M11.1.0"},
|
||||
{"America/Swift_Current", "CST6"},
|
||||
{"America/Tegucigalpa", "CST6"},
|
||||
{"America/Thule", "AST4ADT,M3.2.0,M11.1.0"},
|
||||
{"America/Tijuana", "PST8PDT,M3.2.0,M11.1.0"},
|
||||
{"America/Toronto", "EST5EDT,M3.2.0,M11.1.0"},
|
||||
{"America/Vancouver", "PST8PDT,M3.2.0,M11.1.0"},
|
||||
{"America/Whitehorse", "MST7"},
|
||||
{"America/Winnipeg", "CST6CDT,M3.2.0,M11.1.0"},
|
||||
{"America/Yakutat", "AKST9AKDT,M3.2.0,M11.1.0"},
|
||||
{"Antarctica/Casey", "<+11>-11"},
|
||||
{"Antarctica/Davis", "<+07>-7"},
|
||||
{"Antarctica/Macquarie", "AEST-10AEDT,M10.1.0,M4.1.0/3"},
|
||||
{"Antarctica/Mawson", "<+05>-5"},
|
||||
{"Antarctica/Palmer", "<-03>3"},
|
||||
{"Antarctica/Rothera", "<-03>3"},
|
||||
{"Antarctica/Troll", "<+00>0<+02>-2,M3.5.0/1,M10.5.0/3"},
|
||||
{"Asia/Almaty", "<+06>-6"},
|
||||
{"Asia/Amman", "<+03>-3"},
|
||||
{"Asia/Anadyr", "<+12>-12"},
|
||||
{"Asia/Aqtau", "<+05>-5"},
|
||||
{"Asia/Aqtobe", "<+05>-5"},
|
||||
{"Asia/Ashgabat", "<+05>-5"},
|
||||
{"Asia/Atyrau", "<+05>-5"},
|
||||
{"Asia/Baghdad", "<+03>-3"},
|
||||
{"Asia/Bahrain", "<+03>-3"},
|
||||
{"Asia/Baku", "<+04>-4"},
|
||||
{"Asia/Bangkok", "<+07>-7"},
|
||||
{"Asia/Barnaul", "<+07>-7"},
|
||||
{"Asia/Beirut", "EET-2EEST,M3.5.0/0,M10.5.0/0"},
|
||||
{"Asia/Bishkek", "<+06>-6"},
|
||||
{"Asia/Brunei", "<+08>-8"},
|
||||
{"Asia/Chita", "<+09>-9"},
|
||||
{"Asia/Choibalsan", "<+08>-8"},
|
||||
{"Asia/Colombo", "<+0530>-5:30"},
|
||||
{"Asia/Damascus", "<+03>-3"},
|
||||
{"Asia/Dhaka", "<+06>-6"},
|
||||
{"Asia/Dili", "<+09>-9"},
|
||||
{"Asia/Dubai", "<+04>-4"},
|
||||
{"Asia/Dushanbe", "<+05>-5"},
|
||||
{"Asia/Famagusta", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Asia/Gaza", "EET-2EEST,M3.4.4/50,M10.4.4/50"},
|
||||
{"Asia/Hebron", "EET-2EEST,M3.4.4/50,M10.4.4/50"},
|
||||
{"Asia/Ho_Chi_Minh", "<+07>-7"},
|
||||
{"Asia/Hong_Kong", "HKT-8"},
|
||||
{"Asia/Hovd", "<+07>-7"},
|
||||
{"Asia/Irkutsk", "<+08>-8"},
|
||||
{"Asia/Jakarta", "WIB-7"},
|
||||
{"Asia/Jayapura", "WIT-9"},
|
||||
{"Asia/Jerusalem", "IST-2IDT,M3.4.4/26,M10.5.0"},
|
||||
{"Asia/Kabul", "<+0430>-4:30"},
|
||||
{"Asia/Kamchatka", "<+12>-12"},
|
||||
{"Asia/Karachi", "PKT-5"},
|
||||
{"Asia/Kathmandu", "<+0545>-5:45"},
|
||||
{"Asia/Khandyga", "<+09>-9"},
|
||||
{"Asia/Kolkata", "IST-5:30"},
|
||||
{"Asia/Krasnoyarsk", "<+07>-7"},
|
||||
{"Asia/Kuala_Lumpur", "<+08>-8"},
|
||||
{"Asia/Kuching", "<+08>-8"},
|
||||
{"Asia/Kuwait", "<+03>-3"},
|
||||
{"Asia/Macau", "CST-8"},
|
||||
{"Asia/Magadan", "<+11>-11"},
|
||||
{"Asia/Makassar", "WITA-8"},
|
||||
{"Asia/Manila", "PST-8"},
|
||||
{"Asia/Nicosia", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Asia/Novokuznetsk", "<+07>-7"},
|
||||
{"Asia/Novosibirsk", "<+07>-7"},
|
||||
{"Asia/Omsk", "<+06>-6"},
|
||||
{"Asia/Oral", "<+05>-5"},
|
||||
{"Asia/Pontianak", "WIB-7"},
|
||||
{"Asia/Pyongyang", "KST-9"},
|
||||
{"Asia/Qatar", "<+03>-3"},
|
||||
{"Asia/Qyzylorda", "<+05>-5"},
|
||||
{"Asia/Riyadh", "<+03>-3"},
|
||||
{"Asia/Sakhalin", "<+11>-11"},
|
||||
{"Asia/Samarkand", "<+05>-5"},
|
||||
{"Asia/Seoul", "KST-9"},
|
||||
{"Asia/Shanghai", "CST-8"},
|
||||
{"Asia/Singapore", "<+08>-8"},
|
||||
{"Asia/Srednekolymsk", "<+11>-11"},
|
||||
{"Asia/Taipei", "CST-8"},
|
||||
{"Asia/Tashkent", "<+05>-5"},
|
||||
{"Asia/Tbilisi", "<+04>-4"},
|
||||
{"Asia/Tehran", "<+0330>-3:30"},
|
||||
{"Asia/Thimphu", "<+06>-6"},
|
||||
{"Asia/Tokyo", "JST-9"},
|
||||
{"Asia/Tomsk", "<+07>-7"},
|
||||
{"Asia/Ulaanbaatar", "<+08>-8"},
|
||||
{"Asia/Urumqi", "<+06>-6"},
|
||||
{"Asia/Ust-Nera", "<+10>-10"},
|
||||
{"Asia/Vientiane", "<+07>-7"},
|
||||
{"Asia/Vladivostok", "<+10>-10"},
|
||||
{"Asia/Yakutsk", "<+09>-9"},
|
||||
{"Asia/Yangon", "<+0630>-6:30"},
|
||||
{"Asia/Yekaterinburg", "<+05>-5"},
|
||||
{"Asia/Yerevan", "<+04>-4"},
|
||||
{"Atlantic/Azores", "<-01>1<+00>,M3.5.0/0,M10.5.0/1"},
|
||||
{"Atlantic/Bermuda", "AST4ADT,M3.2.0,M11.1.0"},
|
||||
{"Atlantic/Canary", "WET0WEST,M3.5.0/1,M10.5.0"},
|
||||
{"Atlantic/Cape_Verde", "<-01>1"},
|
||||
{"Atlantic/Faroe", "WET0WEST,M3.5.0/1,M10.5.0"},
|
||||
{"Atlantic/Madeira", "WET0WEST,M3.5.0/1,M10.5.0"},
|
||||
{"Atlantic/South_Georgia", "<-02>2"},
|
||||
{"Atlantic/Stanley", "<-03>3"},
|
||||
{"Australia/Adelaide", "ACST-9:30ACDT,M10.1.0,M4.1.0/3"},
|
||||
{"Australia/Brisbane", "AEST-10"},
|
||||
{"Australia/Broken_Hill", "ACST-9:30ACDT,M10.1.0,M4.1.0/3"},
|
||||
{"Australia/Darwin", "ACST-9:30"},
|
||||
{"Australia/Eucla", "<+0845>-8:45"},
|
||||
{"Australia/Hobart", "AEST-10AEDT,M10.1.0,M4.1.0/3"},
|
||||
{"Australia/Lindeman", "AEST-10"},
|
||||
{"Australia/Lord_Howe", "<+1030>-10:30<+11>-11,M10.1.0,M4.1.0"},
|
||||
{"Australia/Melbourne", "AEST-10AEDT,M10.1.0,M4.1.0/3"},
|
||||
{"Australia/Perth", "AWST-8"},
|
||||
{"Australia/Sydney", "AEST-10AEDT,M10.1.0,M4.1.0/3"},
|
||||
{"Europe/Andorra", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Astrakhan", "<+04>-4"},
|
||||
{"Europe/Athens", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Europe/Belgrade", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Berlin", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Brussels", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Bucharest", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Europe/Budapest", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Chisinau", "EET-2EEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Dublin", "IST-1GMT0,M10.5.0,M3.5.0/1"},
|
||||
{"Europe/Gibraltar", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Helsinki", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Europe/Istanbul", "<+03>-3"},
|
||||
{"Europe/Kaliningrad", "EET-2"},
|
||||
{"Europe/Kyiv", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Europe/Kirov", "MSK-3"},
|
||||
{"Europe/Lisbon", "WET0WEST,M3.5.0/1,M10.5.0"},
|
||||
{"Europe/London", "GMT0BST,M3.5.0/1,M10.5.0"},
|
||||
{"Europe/Madrid", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Malta", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Minsk", "<+03>-3"},
|
||||
{"Europe/Moscow", "MSK-3"},
|
||||
{"Europe/Paris", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Prague", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Riga", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Europe/Rome", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Samara", "<+04>-4"},
|
||||
{"Europe/Saratov", "<+04>-4"},
|
||||
{"Europe/Simferopol", "MSK-3"},
|
||||
{"Europe/Sofia", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Europe/Tallinn", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Europe/Tirane", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Ulyanovsk", "<+04>-4"},
|
||||
{"Europe/Vienna", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Vilnius", "EET-2EEST,M3.5.0/3,M10.5.0/4"},
|
||||
{"Europe/Volgograd", "MSK-3"},
|
||||
{"Europe/Warsaw", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Europe/Zurich", "CET-1CEST,M3.5.0,M10.5.0/3"},
|
||||
{"Indian/Chagos", "<+06>-6"},
|
||||
{"Indian/Maldives", "<+05>-5"},
|
||||
{"Indian/Mauritius", "<+04>-4"},
|
||||
{"Pacific/Apia", "<+13>-13"},
|
||||
{"Pacific/Auckland", "NZST-12NZDT,M9.5.0,M4.1.0/3"},
|
||||
{"Pacific/Bougainville", "<+11>-11"},
|
||||
{"Pacific/Chatham", "<+1245>-12:45<+1345>,M9.5.0/2:45,M4.1.0/3:45"},
|
||||
{"Pacific/Chuuk", "<+10>-10"},
|
||||
{"Pacific/Easter", "<-06>6<-05>,M9.1.6/22,M4.1.6/22"},
|
||||
{"Pacific/Efate", "<+11>-11"},
|
||||
{"Pacific/Enderbury", "<+13>-13"},
|
||||
{"Pacific/Fakaofo", "<+13>-13"},
|
||||
{"Pacific/Fiji", "<+12>-12"},
|
||||
{"Pacific/Funafuti", "<+12>-12"},
|
||||
{"Pacific/Galapagos", "<-06>6"},
|
||||
{"Pacific/Gambier", "<-09>9"},
|
||||
{"Pacific/Guadalcanal", "<+11>-11"},
|
||||
{"Pacific/Guam", "ChST-10"},
|
||||
{"Pacific/Honolulu", "HST10"},
|
||||
{"Pacific/Kiritimati", "<+14>-14"},
|
||||
{"Pacific/Kosrae", "<+11>-11"},
|
||||
{"Pacific/Kwajalein", "<+12>-12"},
|
||||
{"Pacific/Majuro", "<+12>-12"},
|
||||
{"Pacific/Marquesas", "<-0930>9:30"},
|
||||
{"Pacific/Midway", "SST11"},
|
||||
{"Pacific/Nauru", "<+12>-12"},
|
||||
{"Pacific/Niue", "<-11>11"},
|
||||
{"Pacific/Norfolk", "<+11>-11<+12>,M10.1.0,M4.1.0/3"},
|
||||
{"Pacific/Noumea", "<+11>-11"},
|
||||
{"Pacific/Pago_Pago", "SST11"},
|
||||
{"Pacific/Palau", "<+09>-9"},
|
||||
{"Pacific/Pitcairn", "<-08>8"},
|
||||
{"Pacific/Port_Moresby", "<+10>-10"},
|
||||
{"Pacific/Rarotonga", "<-10>10"},
|
||||
{"Pacific/Tahiti", "<-10>10"},
|
||||
{"Pacific/Tarawa", "<+12>-12"},
|
||||
{"Pacific/Tongatapu", "<+13>-13"},
|
||||
{"Etc/GMT", "GMT0"},
|
||||
{"Etc/GMT-1", "<+01>-1"},
|
||||
{"Etc/GMT-2", "<+02>-2"},
|
||||
{"Etc/GMT-3", "<+03>-3"},
|
||||
{"Etc/GMT-4", "<+04>-4"},
|
||||
{"Etc/GMT-5", "<+05>-5"},
|
||||
{"Etc/GMT-6", "<+06>-6"},
|
||||
{"Etc/GMT-7", "<+07>-7"},
|
||||
{"Etc/GMT-8", "<+08>-8"},
|
||||
{"Etc/GMT-9", "<+09>-9"},
|
||||
{"Etc/GMT-10", "<+10>-10"},
|
||||
{"Etc/GMT-11", "<+11>-11"},
|
||||
{"Etc/GMT-12", "<+12>-12"},
|
||||
{"Etc/GMT-13", "<+13>-13"},
|
||||
{"Etc/GMT-14", "<+14>-14"},
|
||||
{"Etc/GMT+1", "<-01>1"},
|
||||
{"Etc/GMT+2", "<-02>2"},
|
||||
{"Etc/GMT+3", "<-03>3"},
|
||||
{"Etc/GMT+4", "<-04>4"},
|
||||
{"Etc/GMT+5", "<-05>5"},
|
||||
{"Etc/GMT+6", "<-06>6"},
|
||||
{"Etc/GMT+7", "<-07>7"},
|
||||
{"Etc/GMT+8", "<-08>8"},
|
||||
{"Etc/GMT+9", "<-09>9"},
|
||||
{"Etc/GMT+10", "<-10>10"},
|
||||
{"Etc/GMT+11", "<-11>11"},
|
||||
{"Etc/GMT+12", "<-12>12"},
|
||||
{"Etc/UTC", "UTC0"},
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@@ -1,23 +0,0 @@
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<link rel="icon" type="image/svg+xml" href="/vite.svg" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<!-- <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap" rel="stylesheet"> -->
|
||||
<!-- Remover link para tailwind.min.css -->
|
||||
<!-- <link href="/tailwind.min.css" rel="stylesheet"> -->
|
||||
<style>
|
||||
body {
|
||||
font-family: 'Arial', 'Helvetica', 'sans-serif'; /* Usando fontes genéricas do sistema */
|
||||
}
|
||||
</style>
|
||||
<title>Vite + React</title>
|
||||
<script type="module" crossorigin src="/assets/index-C_08vMAY.js"></script>
|
||||
<link rel="stylesheet" crossorigin href="/assets/index-Doq3307m.css">
|
||||
</head>
|
||||
<body>
|
||||
<div id="root"></div>
|
||||
<!-- Adicionar o link para o seu arquivo CSS com o Tailwind configurado -->
|
||||
</body>
|
||||
</html>
|
||||
@@ -1 +0,0 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
|
||||
|
Before Width: | Height: | Size: 1.5 KiB |
@@ -15,7 +15,7 @@ idf_component_register(
|
||||
SRCS ${srcs}
|
||||
INCLUDE_DIRS "include"
|
||||
PRIV_INCLUDE_DIRS "src"
|
||||
PRIV_REQUIRES nvs_flash esp_http_server esp_netif vfs spiffs json evse meter_manager loadbalancer evse_link
|
||||
PRIV_REQUIRES nvs_flash esp_http_server esp_netif vfs spiffs json evse meter_manager protocols loadbalancer evse_link
|
||||
)
|
||||
|
||||
# SPIFFS image (opcional)
|
||||
|
||||
@@ -11,4 +11,12 @@
|
||||
// Função para registrar os manipuladores de URI para as configurações dos contadores
|
||||
void register_meters_settings_handlers(httpd_handle_t server, void *ctx);
|
||||
|
||||
/**
|
||||
* Exponha dados do meter via REST.
|
||||
* Endpoints:
|
||||
* GET /api/v1/meters/live -> dados mais recentes (GRID e/ou EVSE)
|
||||
* GET /api/v1/meters/live?source=GRID|EVSE
|
||||
*/
|
||||
void register_meters_data_handlers(httpd_handle_t server, void *ctx);
|
||||
|
||||
#endif // METERS_SETTINGS_API_H
|
||||
|
||||
@@ -24,11 +24,11 @@ static esp_err_t dashboard_get_handler(httpd_req_t *req) {
|
||||
cJSON *charger1 = cJSON_CreateObject();
|
||||
cJSON_AddNumberToObject(charger1, "id", 1);
|
||||
cJSON_AddStringToObject(charger1, "status", evse_state_to_str(state));
|
||||
cJSON_AddNumberToObject(charger1, "current", evse_get_charging_current());
|
||||
cJSON_AddNumberToObject(charger1, "current", evse_get_runtime_charging_current());
|
||||
cJSON_AddNumberToObject(charger1, "maxCurrent", evse_get_max_charging_current());
|
||||
|
||||
// Calcular a potência com base na corrente (considerando 230V)
|
||||
int power = (evse_get_charging_current()) * 230;
|
||||
int power = (evse_get_runtime_charging_current()) * 230;
|
||||
cJSON_AddNumberToObject(charger1, "power", power);
|
||||
|
||||
cJSON_AddItemToArray(chargers, charger1);
|
||||
|
||||
@@ -1,12 +1,169 @@
|
||||
#include "meters_settings_api.h"
|
||||
#include "meter_manager.h" // Atualizado para usar o novo manager
|
||||
#include "meter_events.h"
|
||||
#include "esp_event.h"
|
||||
#include "esp_log.h"
|
||||
#include "cJSON.h"
|
||||
#include "freertos/semphr.h"
|
||||
#include "esp_timer.h"
|
||||
#include <string.h>
|
||||
|
||||
static const char *TAG = "meters_settings_api";
|
||||
|
||||
typedef struct
|
||||
{
|
||||
meter_event_data_t last_grid;
|
||||
meter_event_data_t last_evse;
|
||||
bool has_grid;
|
||||
bool has_evse;
|
||||
int64_t ts_grid_us;
|
||||
int64_t ts_evse_us;
|
||||
SemaphoreHandle_t mtx;
|
||||
} meters_cache_t;
|
||||
|
||||
static meters_cache_t g_cache = {0};
|
||||
|
||||
static void cache_init_once(void)
|
||||
{
|
||||
if (!g_cache.mtx)
|
||||
{
|
||||
g_cache.mtx = xSemaphoreCreateMutex();
|
||||
}
|
||||
}
|
||||
|
||||
static void copy_event_locked(const meter_event_data_t *src)
|
||||
{
|
||||
if (!src)
|
||||
return;
|
||||
if (strcmp(src->source ? src->source : "", "EVSE") == 0)
|
||||
{
|
||||
g_cache.last_evse = *src;
|
||||
g_cache.has_evse = true;
|
||||
g_cache.ts_evse_us = esp_timer_get_time();
|
||||
}
|
||||
else
|
||||
{
|
||||
// Default trate como GRID
|
||||
g_cache.last_grid = *src;
|
||||
g_cache.has_grid = true;
|
||||
g_cache.ts_grid_us = esp_timer_get_time();
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- Event handler (atualiza cache) ----------
|
||||
static void meters_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data)
|
||||
{
|
||||
if (base != METER_EVENT || id != METER_EVENT_DATA_READY || data == NULL)
|
||||
return;
|
||||
|
||||
cache_init_once();
|
||||
if (xSemaphoreTake(g_cache.mtx, pdMS_TO_TICKS(10)) == pdTRUE)
|
||||
{
|
||||
copy_event_locked((const meter_event_data_t *)data);
|
||||
xSemaphoreGive(g_cache.mtx);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- Helpers JSON ----------
|
||||
static cJSON *meter_event_to_json(const meter_event_data_t *m, int64_t ts_us)
|
||||
{
|
||||
cJSON *root = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(root, "source", m->source ? m->source : "GRID");
|
||||
cJSON_AddNumberToObject(root, "frequency", m->frequency);
|
||||
cJSON_AddNumberToObject(root, "powerFactor", m->power_factor);
|
||||
cJSON_AddNumberToObject(root, "totalEnergy", m->total_energy);
|
||||
|
||||
// timestamp relativo (segundos desde boot) e em micros
|
||||
cJSON_AddNumberToObject(root, "timestampUs", (double)ts_us);
|
||||
|
||||
// arrays
|
||||
cJSON *vr = cJSON_CreateArray();
|
||||
for (int i = 0; i < 3; i++)
|
||||
cJSON_AddItemToArray(vr, cJSON_CreateNumber(m->vrms[i]));
|
||||
cJSON *ir = cJSON_CreateArray();
|
||||
for (int i = 0; i < 3; i++)
|
||||
cJSON_AddItemToArray(ir, cJSON_CreateNumber(m->irms[i]));
|
||||
cJSON *pw = cJSON_CreateArray();
|
||||
for (int i = 0; i < 3; i++)
|
||||
cJSON_AddItemToArray(pw, cJSON_CreateNumber(m->watt[i]));
|
||||
cJSON_AddItemToObject(root, "vrms", vr);
|
||||
cJSON_AddItemToObject(root, "irms", ir);
|
||||
cJSON_AddItemToObject(root, "watt", pw);
|
||||
return root;
|
||||
}
|
||||
|
||||
// ---------- HTTP GET /api/v1/meters/live ----------
|
||||
static esp_err_t meters_live_get_handler(httpd_req_t *req)
|
||||
{
|
||||
cache_init_once();
|
||||
|
||||
char query[64] = {0};
|
||||
char source[16] = {0};
|
||||
bool want_grid = true, want_evse = true;
|
||||
|
||||
if (httpd_req_get_url_query_str(req, query, sizeof(query)) == ESP_OK)
|
||||
{
|
||||
if (httpd_query_key_value(query, "source", source, sizeof(source)) == ESP_OK)
|
||||
{
|
||||
if (strcasecmp(source, "GRID") == 0)
|
||||
{
|
||||
want_grid = true;
|
||||
want_evse = false;
|
||||
}
|
||||
else if (strcasecmp(source, "EVSE") == 0)
|
||||
{
|
||||
want_grid = false;
|
||||
want_evse = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cJSON *out = cJSON_CreateObject();
|
||||
cJSON *arr = cJSON_CreateArray();
|
||||
|
||||
if (xSemaphoreTake(g_cache.mtx, pdMS_TO_TICKS(50)) == pdTRUE)
|
||||
{
|
||||
if (want_grid && g_cache.has_grid)
|
||||
{
|
||||
cJSON_AddItemToArray(arr, meter_event_to_json(&g_cache.last_grid, g_cache.ts_grid_us));
|
||||
}
|
||||
if (want_evse && g_cache.has_evse)
|
||||
{
|
||||
cJSON_AddItemToArray(arr, meter_event_to_json(&g_cache.last_evse, g_cache.ts_evse_us));
|
||||
}
|
||||
xSemaphoreGive(g_cache.mtx);
|
||||
}
|
||||
|
||||
cJSON_AddItemToObject(out, "meters", arr);
|
||||
httpd_resp_set_type(req, "application/json");
|
||||
char *s = cJSON_PrintUnformatted(out);
|
||||
httpd_resp_sendstr(req, s ? s : "{\"meters\":[]}");
|
||||
if (s)
|
||||
free(s);
|
||||
cJSON_Delete(out);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
// ---------- Registro ----------
|
||||
void register_meters_data_handlers(httpd_handle_t server, void *ctx)
|
||||
{
|
||||
// registra event handler para receber amostras
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(METER_EVENT, METER_EVENT_DATA_READY, meters_event_handler, NULL));
|
||||
|
||||
// endpoint GET
|
||||
httpd_uri_t live = {
|
||||
.uri = "/api/v1/meters/live",
|
||||
.method = HTTP_GET,
|
||||
.handler = meters_live_get_handler,
|
||||
.user_ctx = ctx};
|
||||
httpd_register_uri_handler(server, &live);
|
||||
|
||||
ESP_LOGI(TAG, "REST /api/v1/meters/live registrado");
|
||||
}
|
||||
|
||||
// Função para recuperar as configurações dos contadores
|
||||
static esp_err_t meters_config_get_handler(httpd_req_t *req) {
|
||||
static esp_err_t meters_config_get_handler(httpd_req_t *req)
|
||||
{
|
||||
ESP_LOGI(TAG, "Received GET request for /api/v1/config/meters");
|
||||
|
||||
httpd_resp_set_type(req, "application/json");
|
||||
@@ -38,13 +195,15 @@ static esp_err_t meters_config_get_handler(httpd_req_t *req) {
|
||||
}
|
||||
|
||||
// Função para atualizar as configurações dos contadores
|
||||
static esp_err_t meters_config_post_handler(httpd_req_t *req) {
|
||||
static esp_err_t meters_config_post_handler(httpd_req_t *req)
|
||||
{
|
||||
ESP_LOGI(TAG, "Received POST request for /api/v1/config/meters");
|
||||
|
||||
char buf[512];
|
||||
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
||||
|
||||
if (len <= 0) {
|
||||
if (len <= 0)
|
||||
{
|
||||
ESP_LOGE(TAG, "Received empty body in POST request");
|
||||
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Empty body");
|
||||
return ESP_FAIL;
|
||||
@@ -55,7 +214,8 @@ static esp_err_t meters_config_post_handler(httpd_req_t *req) {
|
||||
ESP_LOGI(TAG, "Received POST data: %s", buf);
|
||||
|
||||
cJSON *json = cJSON_Parse(buf);
|
||||
if (!json) {
|
||||
if (!json)
|
||||
{
|
||||
ESP_LOGE(TAG, "Failed to parse JSON data");
|
||||
// Resposta detalhada de erro
|
||||
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON format");
|
||||
@@ -64,14 +224,16 @@ static esp_err_t meters_config_post_handler(httpd_req_t *req) {
|
||||
|
||||
// Atualizando os contadores
|
||||
cJSON *gridmeter = cJSON_GetObjectItem(json, "gridmeter");
|
||||
if (gridmeter) {
|
||||
if (gridmeter)
|
||||
{
|
||||
meter_type_t gridType = string_to_meter_type(gridmeter->valuestring); // Usando a função string_to_meter_type
|
||||
ESP_LOGI(TAG, "Updating grid meter type to: %s", gridmeter->valuestring);
|
||||
meter_manager_grid_set_model(gridType);
|
||||
}
|
||||
|
||||
cJSON *evsemeter = cJSON_GetObjectItem(json, "evsemeter");
|
||||
if (evsemeter) {
|
||||
if (evsemeter)
|
||||
{
|
||||
meter_type_t evseType = string_to_meter_type(evsemeter->valuestring); // Usando a função string_to_meter_type
|
||||
ESP_LOGI(TAG, "Updating EVSE meter type to: %s", evsemeter->valuestring);
|
||||
meter_manager_evse_set_model(evseType);
|
||||
@@ -86,7 +248,8 @@ static esp_err_t meters_config_post_handler(httpd_req_t *req) {
|
||||
}
|
||||
|
||||
// Registrando os manipuladores de URI para os contadores
|
||||
void register_meters_settings_handlers(httpd_handle_t server, void *ctx) {
|
||||
void register_meters_settings_handlers(httpd_handle_t server, void *ctx)
|
||||
{
|
||||
ESP_LOGD(TAG, "Registering URI handlers for meters settings");
|
||||
|
||||
// URI para o método GET
|
||||
@@ -94,8 +257,7 @@ void register_meters_settings_handlers(httpd_handle_t server, void *ctx) {
|
||||
.uri = "/api/v1/config/meters",
|
||||
.method = HTTP_GET,
|
||||
.handler = meters_config_get_handler,
|
||||
.user_ctx = ctx
|
||||
};
|
||||
.user_ctx = ctx};
|
||||
ESP_LOGD(TAG, "Registering GET handler for /api/v1/config/meters");
|
||||
httpd_register_uri_handler(server, &meters_get_uri);
|
||||
|
||||
@@ -104,8 +266,7 @@ void register_meters_settings_handlers(httpd_handle_t server, void *ctx) {
|
||||
.uri = "/api/v1/config/meters",
|
||||
.method = HTTP_POST,
|
||||
.handler = meters_config_post_handler,
|
||||
.user_ctx = ctx
|
||||
};
|
||||
.user_ctx = ctx};
|
||||
ESP_LOGD(TAG, "Registering POST handler for /api/v1/config/meters");
|
||||
httpd_register_uri_handler(server, &meters_post_uri);
|
||||
}
|
||||
|
||||
@@ -10,14 +10,15 @@
|
||||
#include "static_file_api.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
|
||||
static const char *TAG = "rest_main";
|
||||
|
||||
esp_err_t rest_server_init(const char *base_path) {
|
||||
esp_err_t rest_server_init(const char *base_path)
|
||||
{
|
||||
ESP_LOGI(TAG, "Initializing REST API with base path: %s", base_path);
|
||||
|
||||
rest_server_context_t *ctx = calloc(1, sizeof(rest_server_context_t));
|
||||
if (!ctx) {
|
||||
if (!ctx)
|
||||
{
|
||||
ESP_LOGE(TAG, "Failed to allocate memory for REST context");
|
||||
return ESP_ERR_NO_MEM;
|
||||
}
|
||||
@@ -30,7 +31,8 @@ esp_err_t rest_server_init(const char *base_path) {
|
||||
|
||||
httpd_handle_t server = NULL;
|
||||
esp_err_t err = httpd_start(&server, &config);
|
||||
if (err != ESP_OK) {
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGE(TAG, "Failed to start HTTP server: %s", esp_err_to_name(err));
|
||||
free(ctx);
|
||||
return err;
|
||||
@@ -47,8 +49,10 @@ esp_err_t rest_server_init(const char *base_path) {
|
||||
register_meters_settings_handlers(server, ctx); // Apenas chamando a função sem comparação
|
||||
register_loadbalancing_settings_handlers(server, ctx); // Apenas chamando a função sem comparação
|
||||
register_link_config_handlers(server, ctx);
|
||||
register_static_file_handlers(server, ctx); // Apenas chamando a função sem comparação
|
||||
|
||||
register_meters_data_handlers(server, ctx);
|
||||
|
||||
register_static_file_handlers(server, ctx); // Apenas chamando a função sem comparação
|
||||
|
||||
ESP_LOGI(TAG, "All REST API endpoint groups registered successfully");
|
||||
|
||||
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user