tree d551cd03b517eb01709c8c9c4cc11882fb67dab5
parent 8a4c0252054a784b6ed0f46037efc8381b9cf34a
author nxptest <68574485+nxptest@users.noreply.github.com> 1656068689 +0800
committer GitHub <noreply@github.com> 1656068689 +0200
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJitZpRCRBK7hj4Ov3rIwAA38kIADOXmA7mB+IG9qMyWZNVpOMU
 leja4ZVBr2SAPP0f2PzEUvPDyfrwWR+aPz/I5Z9mk+JoqPqCBpGCnRewHcZydkv8
 p/msJUSwgP9lO0VO3lRFObivujeBg4GTwNTXXg9ZOIaQlbbMc8M8ipghgSze06P6
 xj+IVvLhNWDMFff1hl7E95CLCYPGNP+PNbTB8qzxwlKnnWl7WyjCdh9ermQYj5Li
 7O5MFjTWThoJaRLZKunvJCxlRWiwG+DEpAjbRdb365fvn4V/Y4vN+5ZFdoyW3w7c
 wpShnJtB7hpd2QeFCBIVqLwXkkXvZsBeikbZCm8BSEXANck2Uun9yBHXUB0qREE=
 =6luC
 -----END PGP SIGNATURE-----
 

Added MW320 to all-clusters-app. (#19302)

* Added MW320 to all-clusters-app.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Added draft README for MW320 all clusters app.

Removed some unused files.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Update README.md

Added basic and building information.

* Updated MW320 SDK to commit 3d93e61.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Added image file for README.

Image used to show bring up messages of MW320.

* Update README.md

Added flashing information.

* Update README.md

* Update README.md

Added "$" for commands.

* Update README.md

* Add the private emberAfExternalAttributeReadCallback() to fix the read commission_info error in pairing

Signed-off-by: Chin-Ran Lo <chin-ran.lo@nxp.com>

* Update README.md

* Enable Matter console messages on mw320

* Add binding function to mw320

* Update README.md

* Fixed compile error.

Functin prototype is changed.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Fixed misspelling.

Changed default SSID too.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Restyled by whitespace

* Restyled by clang-format

* Restyled by gn

* Restyled by prettier-markdown

* Added platform "mw320" for MW320 SDK submodule.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* - Enhance the parameter checking
    - Change to return the correct value in the exception condition
    - Add the comment for casting the data type

Signed-off-by: Chin-Ran Lo <chin-ran.lo@nxp.com>

* Added mw320 to ALL_PLATFORMS.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Fixed issue on KeyValueStoreManagerImpl::_Get.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Removed unused code.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Fixed remaining issue on KeyValueStoreManagerImpl::_Get.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Restyled by clang-format

* Removed unused image.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Fixed checking error by Lint Action.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Removed unused code.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

* Fixed merge error.

Signed-off-by: David Lin <yu-hao.lin@nxp.com>

Co-authored-by: Chin-Ran Lo <chin-ran.lo@nxp.com>
Co-authored-by: Restyled.io <commits@restyled.io>