Set version to 1.16.0.

+ Reorder code to match the widgets order in the UI.

+ Moved all objects (rows) into a container

+ Use InfintimeTheme Colors instead of hardcoded hex values

+ Added a new InfinitimeTheme color: gray, using it to turn certain
  values gray when they contain no data

+ Implement @vkareh's [variable battery icon](https://github.com/InfiniTimeOrg/InfiniTime/pull/1964)
  color to the battery percentage text.

+ Replaced the 'You have mail.' notification message with the message
  '[1]+ Notify' to better fit the terminal lore.

.clang-format

@@ -0,0 +1,141 @@
+---
+Language: Cpp
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: true
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands: Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortLambdasOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: true
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit: 140
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 2
+ContinuationIndentWidth: 2
+Cpp11BracedListStyle: true
+DeriveLineEnding: false
+DerivePointerAlignment: false
+DisableFormat: false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: true
+FixNamespaceComments: false
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks: Preserve
+IncludeCategories:
+  - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority: 2
+    SortPriority: 0
+  - Regex: '^(<|"(gtest|gmock|isl|json)/)'
+    Priority: 3
+    SortPriority: 0
+  - Regex: '.*'
+    Priority: 1
+    SortPriority: 0
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: true
+IndentGotoLabels: true
+IndentPPDirectives: BeforeHash
+IndentWidth: 2
+IndentWrappedFunctionNames: false
+# Requires Clang >= 15, could also cause incorrect code formatting:
+# InsertBraces: true
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+PackConstructorInitializers: NextLine
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+ReferenceAlignment: Pointer
+ReflowComments: true
+SeparateDefinitionBlocks: Always
+SortIncludes: false
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatementsExceptForEachMacros
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+SpaceAroundPointerQualifiers: Default
+Standard: Latest
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth: 8
+UseCRLF: false
+UseTab: Never
+...

.clang-tidy

@@ -0,0 +1,37 @@
+Checks: 'bugprone-*,
+  cert-*,
+  cppcoreguidelines-*,
+  hicpp-*,
+  misc-*,
+  modernize-*,
+  performance-*,
+  portability-*,
+  readability-*,
+  fuchsia-trailing-return,
+  -cert-err58-cpp,
+  -cert-err60-cpp,
+  -cppcoreguidelines-prefer-member-initializer,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
+  -cppcoreguidelines-pro-type-static-cast-downcast,
+  -cppcoreguidelines-pro-type-union-access,
+  -cppcoreguidelines-pro-type-cstyle-cast,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-special-member-functions,
+  -hicpp-avoid-c-arrays,
+  -hicpp-uppercase-literal-suffix,
+  -hicpp-vararg,
+  -hicpp-no-assembler,
+  -hicpp-no-array-decay,
+  -hicpp-signed-bitwise,
+  -hicpp-special-member-functions,
+  -modernize-use-trailing-return-type,
+  -modernize-avoid-c-arrays,
+  -readability-magic-numbers,
+  -readability-uppercase-literal-suffix'
+CheckOptions:
+  - key: readability-function-cognitive-complexity.Threshold
+    value: 100

.devcontainer.json

@@ -0,0 +1,32 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.154.2/containers/cpp
+{
+	"build": {
+		"dockerfile": "docker/Dockerfile"
+	},
+	"customizations": {
+		"vscode": {
+			"settings": {
+				// Set *default* container specific settings.json values on container create.
+				"terminal.integrated.profiles.linux": {
+					"bash": {
+						"path": "/bin/bash"
+					}
+				},
+				"terminal.integrated.defaultProfile.linux": "bash",
+				"editor.formatOnSave": true,
+				// FIXME: This and the Dockerfile might get out of sync
+				"clang-format.executable": "clang-format-14"
+			},
+			// Add the IDs of extensions you want installed when the container is created.
+			"extensions": [
+				"ms-vscode.cpptools",
+				"ms-vscode.cmake-tools",
+				"marus25.cortex-debug",
+				"notskm.clang-tidy",
+				"mjohns.clang-format"
+			]
+		}
+	},
+	"remoteUser": "infinitime"
+}

.gitattributes

@@ -0,0 +1,19 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+# Prevent build errors on non lf systems (like Windows), we need files with lf as newlines.
+* text=auto eol=lf
+
+# Explicitly declare text files you want to always be normalized and converted
+# to lf line endings on checkout.
+*.c text
+*.cpp text
+*.h text
+*.hpp text
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.bin binary
+*.jpg binary
+*.jpeg binary
+
+# Declare (Unix-style) files that will always have LF line endings on checkout.
+*.sh text eol=lf

.github/FUNDING.yml

@@ -0,0 +1 @@
+liberapay: JF002

.github/ISSUE_TEMPLATE/bug-report.yaml

@@ -0,0 +1,55 @@
+name: Bug Report
+description: Something is broken
+labels: ["bug"]
+body:
+  - type: checkboxes
+    attributes:
+      label: Verification
+      description: Before submitting a bug report, check if similar issues already exist and use those issues to provide your feedback instead.
+      options:
+      - label: I searched for similar bug reports (including closed issues) and found none was relevant.
+        required: true
+  - type: input
+    id: desc-brief
+    attributes:
+      label: What happened?
+      description: A one-line description of the bug.
+      placeholder: "Ex. I woke up as a Kafkian insect this morning."
+    validations:
+      required: true
+  - type: input
+    id: desc-expected
+    attributes:
+      label: What should happen instead?
+      description: The behaviour you were expecting to see.
+      placeholder: "Ex. I was expecting to wake up as a human."
+  - type: textarea
+    id: desc-steps
+    attributes:
+      label: Reproduction steps
+      description: "How do you trigger this bug? Please walk us through it step by step."
+    validations:
+      required: true
+  - type: textarea
+    id: desc-long
+    attributes:
+      label: More details?
+      description: Give us more details about the bug and any personal attempts you made to fix it.
+      placeholder: Tell us more!
+  - type: input
+    id: version
+    attributes:
+      label: Version
+      description: |
+        What [version of the firmware](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/doc/gettingStarted/updating-software.md#checking-the-version-of-infinitime) are you running?
+        If you are running an older version, please consider [updating to the latest firmware](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/doc/gettingStarted/updating-software.md#updating-with-companion-apps).
+        If you are running directly from git, specify the branch or the commit hash directly.
+      placeholder: "Ex. v1.11.0 or main or fc922b60"
+    validations:
+      required: true
+  - type: input
+    id: companion-app
+    attributes:
+      label: Companion app
+      description: Which companion app are you using (if relevant)?
+      placeholder: "Ex. Gadgetbridge v0.60.0, Siglo v0.9.4"

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Feature request
+    url: https://github.com/InfiniTimeOrg/InfiniTime/discussions/categories/ideas
+    about: Request a feature or share your ideas
+  - name: PineTime community chat (Matrix)
+    url: https://app.element.io/#/room/#pinetime:matrix.org
+    about: Please ask questions about PineTime here.
+  - name: PineTime developers chat (Matrix)
+    url: https://app.element.io/#/room/#pinetime-dev:matrix.org
+    about: Please ask questions about PineTime development here.

.github/ISSUE_TEMPLATE/issue-report.yaml

@@ -0,0 +1,31 @@
+name: Issue report
+description: Something's not good enough
+body:
+- type: checkboxes
+  attributes:
+    label: Verification
+    description: Before submitting an issue, check if similar issues already exist and use those issues to provide your feedback instead.
+    options:
+      - label: I searched for similar issues (including closed issues) and found none was relevant.
+        required: true
+- type: textarea
+  attributes:
+    label: Introduce the issue
+    description: Explain why it is an issue if necessary.
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Preferred solution
+    description: You can suggest a solution to the issue here.
+    placeholder: Optional
+- type: input
+  attributes:
+    label: Version
+    description: |
+      What [version of the firmware](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/doc/gettingStarted/updating-software.md#checking-the-version-of-infinitime) are you running?
+      If you are running an older version, please consider [updating to the latest firmware](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/doc/gettingStarted/updating-software.md#updating-with-companion-apps).
+      If you are running directly from git, specify the branch or the commit hash directly.
+    placeholder: Ex. v1.11.0 or main or fc922b60
+  validations:
+    required: false

.github/workflows/docker.yml

@@ -0,0 +1,70 @@
+name: Build and push Docker image
+
+on:
+  push:
+    branches: [ main ]
+    paths:
+      - 'docker/**'
+  pull_request:
+    branches: [ main ]
+    paths:
+      - 'docker/**'
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    env:
+      USERNAME: infinitime
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Log in to Docker Hub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_HUB_LOGIN_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Set up Docker metadata
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ${{ secrets.DOCKER_HUB_IMAGE_USERNAME || env.USERNAME }}/infinitime-build
+          tags: |
+            type=sha
+            type=raw,value=latest
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Build and push
+        if: github.event_name != 'pull_request'
+        uses: docker/build-push-action@v3
+        with:
+          context: ./docker/
+          file: ./docker/Dockerfile
+          platforms: linux/amd64,linux/arm64
+          builder: ${{ steps.buildx.outputs.name }}
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=registry,ref=${{ secrets.DOCKER_HUB_IMAGE_USERNAME || env.USERNAME }}/infinitime-build:buildcache
+          cache-to: type=registry,ref=${{ secrets.DOCKER_HUB_IMAGE_USERNAME || env.USERNAME }}/infinitime-build:buildcache,mode=max
+
+      - name: Build
+        if: github.event_name == 'pull_request'
+        uses: docker/build-push-action@v3
+        with:
+          context: ./docker/
+          file: ./docker/Dockerfile
+          platforms: linux/amd64,linux/arm64
+          builder: ${{ steps.buildx.outputs.name }}
+          push: false
+          cache-from: type=registry,ref=${{ secrets.DOCKER_HUB_IMAGE_USERNAME || env.USERNAME }}/infinitime-build:buildcache

.github/workflows/format.yml

@@ -0,0 +1,70 @@
+name: Code formatting
+
+on:
+  pull_request:
+    branches: [ main ]
+    paths:
+      - '**.cpp'
+      - '**.h'
+      - '!src/libs/**'
+      - '!src/FreeRTOS/**'
+
+jobs:
+  test-format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 1000
+
+      - name: Fetch base branch
+        run: git fetch origin "$GITHUB_BASE_REF":"$GITHUB_BASE_REF"
+
+      - name: Install clang-format
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install clang-format-14
+
+      - name: Check formatting
+        run: tests/test-format.sh
+
+      - name: Upload patches
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: Patches
+          path: ./*.patch
+  test-clang-tidy:
+    runs-on: ubuntu-latest
+    container:
+      image: infinitime/infinitime-build
+    steps:
+    # This workaround fixes the error "unsafe repository (REPO is owned by someone else)".
+    # See https://github.com/actions/checkout/issues/760 and https://github.com/actions/checkout/issues/766
+    # The fix in "actions/checkout@v2" was not sufficient as the build process also uses git (to get the current
+    # commit hash, for example).
+    - name: Workaround permission issues
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+    - name: Checkout source files
+      uses: actions/checkout@v3
+      with:
+        submodules: recursive
+        fetch-depth: 1000
+    - name: Fetch base branch
+      run: git fetch origin "$GITHUB_BASE_REF":"$GITHUB_BASE_REF"
+    - name: Install clang-tidy
+      run: |
+        apt-get update
+        apt-get -y install clang-tidy-14
+    - name: Prepare environment
+      shell: bash
+      env:
+        SOURCES_DIR: .
+      run: |
+        . docker/build.sh
+        GetGcc
+        # I guess these already exist inside the docker?
+        #GetNrfSdk
+        #GetMcuBoot
+        CmakeGenerate
+    - run: tests/test-tidy.sh

.github/workflows/getSize.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+# Requires environment variables from docker/build.sh
+
+set -e
+
+SIZE_BIN="$TOOLS_DIR/$GCC_ARM_PATH/bin/arm-none-eabi-size"
+[ ! -x "$SIZE_BIN" ] && exit 1
+
+[ -z "$1" ] && exit 1
+SIZE_OUTPUT=$($SIZE_BIN "$1" | tail -n1)
+
+TEXT_SIZE=$(echo "$SIZE_OUTPUT" | cut -f 1 |tr -d '[:blank:]')
+DATA_SIZE=$(echo "$SIZE_OUTPUT" | cut -f 2 |tr -d '[:blank:]')
+BSS_SIZE=$(echo "$SIZE_OUTPUT" | cut -f 3 |tr -d '[:blank:]')
+
+echo "text_size=$TEXT_SIZE"
+echo "data_size=$DATA_SIZE"
+echo "bss_size=$BSS_SIZE"

.github/workflows/main.yml

@@ -1,171 +1,224 @@
-# GitHub Actions Workflow to build FreeRTOS Firmware for PineTime Smart Watch
+name: CI
-# See https://lupyuen.github.io/pinetime-rust-mynewt/articles/cloud
-# Based on https://github.com/JF002/Pinetime/blob/master/doc/buildAndProgram.md
-# and https://github.com/JF002/Pinetime/blob/master/bootloader/README.md
 
-# Name of this Workflow
+# Run this workflow whenever the build may be affected
-name: Build PineTime Firmware
-
-# When to run this Workflow...
 on:
-
-  # Run this Workflow when files are updated (Pushed) in the "master" Branch
   push:
-    branches: [ master ]
+    branches: [ main ]
-
+    paths-ignore:
-  # Also run this Workflow when a Pull Request is created or updated in the "master" Branch
+      - 'doc/**'
+      - '**.md'
   pull_request:
-    branches: [ master ]
+    branches: [ main ]
+    paths-ignore:
+      - 'doc/**'
+      - '**.md'
 
-# Steps to run for the Workflow
 jobs:
-  build:
+  build-firmware:
-
+    runs-on: ubuntu-22.04
-    # Run these steps on Ubuntu
+    container:
-    runs-on: ubuntu-latest
+      image: infinitime/infinitime-build
-
+    outputs:
+      text_size: ${{ steps.output-sizes.outputs.text_size }}
+      data_size: ${{ steps.output-sizes.outputs.data_size }}
+      bss_size: ${{ steps.output-sizes.outputs.bss_size }}
+      firmware_artifact: ${{ steps.upload-firmware.outputs.artifact-id }}
+      resources_artifact: ${{ steps.upload-resources.outputs.artifact-id }}
+    env:
+      # InfiniTime sources are downloaded to the current directory.
+      # Override SOURCES_DIR in build.sh
+      SOURCES_DIR: .
     steps:
-
-      #########################################################################################
-      # Download and Cache Dependencies
-
-      - name: Install cmake
-        uses: lukka/get-cmake@v3.18.0
-
-      - name: Check cache for Embedded Arm Toolchain arm-none-eabi-gcc
-        id:   cache-toolchain
-        uses: actions/cache@v2
-        env:
-          cache-name: cache-toolchain-9-2020-q2
-        with:
-          path: ${{ runner.temp }}/arm-none-eabi
-          key:  ${{ runner.os }}-build-${{ env.cache-name }}
-          restore-keys: ${{ runner.os }}-build-${{ env.cache-name }}
-
-      - name: Install Embedded Arm Toolchain arm-none-eabi-gcc
-        if:   steps.cache-toolchain.outputs.cache-hit != 'true'  # Install toolchain if not found in cache
-        uses: fiam/arm-none-eabi-gcc@v1.0.2
-        with:
-          # GNU Embedded Toolchain for Arm release name, in the V-YYYY-qZ format (e.g. "9-2019-q4")
-          release: 9-2020-q2
-          # Directory to unpack GCC to. Defaults to a temporary directory.
-          directory: ${{ runner.temp }}/arm-none-eabi
-
-      - name: Check cache for nRF5 SDK
-        id:   cache-nrf5sdk
-        uses: actions/cache@v2
-        env:
-          cache-name: cache-nrf5sdk
-        with:
-          path: ${{ runner.temp }}/nrf5_sdk
-          key:  ${{ runner.os }}-build-${{ env.cache-name }}
-          restore-keys: ${{ runner.os }}-build-${{ env.cache-name }}
-
-      - name: Install nRF5 SDK
-        if:   steps.cache-nrf5sdk.outputs.cache-hit != 'true'  # Install SDK if not found in cache
-        run:  |
-          cd ${{ runner.temp }}
-          curl https://developer.nordicsemi.com/nRF5_SDK/nRF5_SDK_v15.x.x/nRF5_SDK_15.3.0_59ac345.zip -o nrf5_sdk.zip
-          unzip nrf5_sdk.zip
-          mv nRF5_SDK_15.3.0_59ac345 nrf5_sdk
-
-      - name: Check cache for MCUBoot
-        id:   cache-mcuboot
-        uses: actions/cache@v2
-        env:
-          cache-name: cache-mcuboot
-        with:
-          path: ${{ runner.temp }}/mcuboot
-          key:  ${{ runner.os }}-build-${{ env.cache-name }}
-          restore-keys: ${{ runner.os }}-build-${{ env.cache-name }}
-
-      - name: Install MCUBoot
-        if:   steps.cache-mcuboot.outputs.cache-hit != 'true'  # Install MCUBoot if not found in cache
-        run:  |
-          cd ${{ runner.temp }}
-          git clone --branch v1.5.0 https://github.com/JuulLabs-OSS/mcuboot
-
-      - name: Install imgtool dependencies
-        run:  pip3 install --user -r ${{ runner.temp }}/mcuboot/scripts/requirements.txt
-
-      - name: Install adafruit-nrfutil
-        run:  |
-          pip3 install --user wheel
-          pip3 install --user setuptools
-          pip3 install --user adafruit-nrfutil
-
-        #########################################################################################
-        # Checkout
-
       - name: Checkout source files
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
-
-      - name: Show files
-        run:  set ; pwd ; ls -l
-
-      #########################################################################################
-      # CMake
-
-      - name: CMake
-        run:  |
-          mkdir -p build
-          cd build
-          cmake -DARM_NONE_EABI_TOOLCHAIN_PATH=${{ runner.temp }}/arm-none-eabi -DNRF5_SDK_PATH=${{ runner.temp }}/nrf5_sdk -DUSE_OPENOCD=1 ../
-
-        #########################################################################################
-        # Make and Upload DFU Package
-        # pinetime-mcuboot-app.img must be flashed at address 0x8000 in the internal flash memory with OpenOCD:
-        # program image.bin 0x8000
-
-        # For Debugging Builds: Remove "make" option "-j" for clearer output. Add "--trace" to see details.
-        # For Faster Builds: Add "make" option "-j"
-
-      - name: Make pinetime-mcuboot-app
-        run:  |
-          cd build
-          make pinetime-mcuboot-app
-
-      - name: Create firmware image
-        run:  |
-          # The generated firmware binary looks like "pinetime-mcuboot-app-0.8.2.bin"
-          ls -l build/src/pinetime-mcuboot-app*.bin
-          ${{ runner.temp }}/mcuboot/scripts/imgtool.py create --align 4 --version 1.0.0 --header-size 32 --slot-size 475136 --pad-header build/src/pinetime-mcuboot-app*.bin build/src/pinetime-mcuboot-app-img.bin
-          ${{ runner.temp }}/mcuboot/scripts/imgtool.py verify build/src/pinetime-mcuboot-app-img.bin
-
-      - name: Create DFU package
-        run:  |
-          ~/.local/bin/adafruit-nrfutil dfu genpkg --dev-type 0x0052 --application build/src/pinetime-mcuboot-app-img.bin build/src/pinetime-mcuboot-app-dfu.zip
-          unzip -v build/src/pinetime-mcuboot-app-dfu.zip
-          # Unzip the package because Upload Artifact will zip up the files
-          unzip build/src/pinetime-mcuboot-app-dfu.zip -d build/src/pinetime-mcuboot-app-dfu
-
-      - name: Upload DFU package
-        uses: actions/upload-artifact@v2
         with:
-          name: pinetime-mcuboot-app-dfu.zip
+          submodules: recursive
-          path: build/src/pinetime-mcuboot-app-dfu/*
+      - name: Install resource build dependencies
-
-        #########################################################################################
-        # Make and Upload Standalone Firmware
-
-      - name: Make pinetime-app
         run:  |
-          cd build
+          apt-get update
-          make pinetime-app
+          apt-get -y install --no-install-recommends python3-pil
-
+      - name: Build
-      - name: Upload standalone firmware
+        shell: bash
-        uses: actions/upload-artifact@v2
+        run: |
+          git config --global --add safe.directory /__w/InfiniTime/InfiniTime
+          /opt/build.sh all
+      - name: Output build size
+        id: output-sizes
+        shell: bash
+        run: |
+          . /opt/build.sh
+          .github/workflows/getSize.sh "$BUILD_DIR"/src/pinetime-app-*.out >> $GITHUB_OUTPUT
+      # Unzip the package because Upload Artifact will zip up the files
+      - name: Unzip DFU package
+        run: unzip ./build/output/pinetime-mcuboot-app-dfu-*.zip -d ./build/output/pinetime-mcuboot-app-dfu
+      - name: Set ref_name, but replace slashes with dashes.
+        shell: bash
+        env:
+          ref_name: ${{ github.head_ref || github.ref_name }}
+        run: echo "REF_NAME=${ref_name//\//-}" >> $GITHUB_ENV
+      - name: Upload DFU artifacts
+        uses: actions/upload-artifact@v4
         with:
-          name: pinetime-app.out
+          name: InfiniTime DFU ${{ env.REF_NAME }}
-          path: build/src/pinetime-app*.out
+          path: ./build/output/pinetime-mcuboot-app-dfu/*
+      - name: Upload MCUBoot image artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: InfiniTime MCUBoot image ${{ env.REF_NAME }}
+          path: ./build/output/pinetime-mcuboot-app-image-*.bin
+      - name: Upload standalone ELF artifacts
+        uses: actions/upload-artifact@v4
+        id: upload-firmware
+        with:
+          name: InfiniTime image ${{ env.REF_NAME }}
+          path: ./build/output/src/pinetime-app-*.out
+      - name: Upload resources artifacts
+        uses: actions/upload-artifact@v4
+        id: upload-resources
+        with:
+          name: InfiniTime resources ${{ env.REF_NAME }}
+          path: ./build/output/infinitime-resources-*.zip
 
-      #########################################################################################
+  build-simulator:
-      # Finish
+    runs-on: ubuntu-22.04
+    steps:
+    - name: Install SDL2 and libpng development package
+      run:  |
+        sudo apt-get update
+        sudo apt-get -y install libsdl2-dev libpng-dev
 
-      - name: Find output
+    - name: Install Ninja
-        run:  |
+      run:  |
-          find . -name "pinetime-app.*" -ls
+        sudo apt-get -y install ninja-build
-          find . -name "pinetime-mcuboot-app.*" -ls
 
-# Embedded Arm Toolchain and nRF5 SDK will only be cached if the build succeeds.
+    - name: Install lv_font_conv
-# So make sure that the first build always succeeds, e.g. comment out the "Make" step.
+      run:
+        npm i -g lv_font_conv@1.5.2
+
+    - name: Checkout source files
+      uses: actions/checkout@v3
+      with:
+        submodules: recursive
+
+    - name: Get InfiniSim repo
+      run:  |
+        git clone https://github.com/InfiniTimeOrg/InfiniSim.git --depth 1 --branch main
+        git -C InfiniSim submodule update --init lv_drivers
+
+    - name: CMake
+      # disable BUILD_RESOURCES as this is already done when building the firmware
+      run:  |
+        cmake -G Ninja -S InfiniSim -B build_lv_sim -DInfiniTime_DIR="${PWD}" -DBUILD_RESOURCES=OFF
+
+    - name: Build simulator executable
+      run:  |
+        cmake --build build_lv_sim
+
+    - name: Upload simulator executable
+      uses: actions/upload-artifact@v4
+      with:
+        name: infinisim-${{ env.REF_NAME }}
+        path: build_lv_sim/infinisim
+
+  get-base-ref-size:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-22.04
+    container:
+      image: infinitime/infinitime-build
+    outputs:
+      text_size: ${{ steps.output-sizes.outputs.text_size }}
+      data_size: ${{ steps.output-sizes.outputs.data_size }}
+      bss_size: ${{ steps.output-sizes.outputs.bss_size }}
+    env:
+      # InfiniTime sources are downloaded to the current directory.
+      # Override SOURCES_DIR in build.sh
+      SOURCES_DIR: .
+    steps:
+    - name: Checkout current base branch files
+      uses: actions/checkout@v3
+      with:
+        ref: ${{ github.base_ref }}
+        submodules: recursive
+
+    - name: Get base branch SHA
+      id: get-base-sha
+      run: |
+        # Fix for "detected dubious ownership in repository at '/__w/InfiniTime/InfiniTime'"
+        git config --global --add safe.directory /__w/InfiniTime/InfiniTime
+        echo base_sha=$(git rev-parse HEAD) >> $GITHUB_OUTPUT
+
+    - name: Cache build
+      id: cache-build
+      uses: actions/cache@v3
+      with:
+        path: ./build
+        key: build-files-${{ steps.get-base-sha.outputs.base_sha }}
+
+    - if: ${{ steps.cache-build.outputs.cache-hit != 'true' }}
+      name: Build
+      shell: bash
+      # Only pinetime-app target is needed, but post_build.sh fails
+      run: /opt/build.sh all
+
+    - name: Output build size
+      id: output-sizes
+      shell: bash
+      run: |
+        . /opt/build.sh
+        .github/workflows/getSize.sh "$BUILD_DIR"/src/pinetime-app-*.out >> $GITHUB_OUTPUT
+
+  compare-build-size:
+    if: github.event_name == 'pull_request'
+    name: 'Compare build size'
+    needs: [build-firmware, get-base-ref-size]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Compare build size
+      id: output-sizes-diff
+      run: |
+        TEXT_SIZE=${{ needs.build-firmware.outputs.text_size }}
+        DATA_SIZE=${{ needs.build-firmware.outputs.data_size }}
+        BSS_SIZE=${{ needs.build-firmware.outputs.bss_size }}
+
+        echo "text_size=$TEXT_SIZE"
+        echo "data_size=$DATA_SIZE"
+        echo "bss_size=$BSS_SIZE"
+
+        echo "text_size=$TEXT_SIZE" >> $GITHUB_OUTPUT
+        echo "data_size=$DATA_SIZE" >> $GITHUB_OUTPUT
+        echo "bss_size=$BSS_SIZE" >> $GITHUB_OUTPUT
+
+        TEXT_SIZE_BASE=${{ needs.get-base-ref-size.outputs.text_size }}
+        DATA_SIZE_BASE=${{ needs.get-base-ref-size.outputs.data_size }}
+        BSS_SIZE_BASE=${{ needs.get-base-ref-size.outputs.bss_size }}
+
+        TEXT_SIZE_DIFF=$((TEXT_SIZE - TEXT_SIZE_BASE))
+        DATA_SIZE_DIFF=$((DATA_SIZE - DATA_SIZE_BASE))
+        BSS_SIZE_DIFF=$((BSS_SIZE - BSS_SIZE_BASE))
+
+        echo "text_diff=$TEXT_SIZE_DIFF"
+        echo "data_diff=$DATA_SIZE_DIFF"
+        echo "bss_diff=$BSS_SIZE_DIFF"
+
+        echo "text_diff=$TEXT_SIZE_DIFF" >> $GITHUB_OUTPUT
+        echo "data_diff=$DATA_SIZE_DIFF" >> $GITHUB_OUTPUT
+        echo "bss_diff=$BSS_SIZE_DIFF" >> $GITHUB_OUTPUT
+
+    - name: Write comment information to files
+      run: |
+        tee comment << EOF
+        Build size and comparison to ${{ github.base_ref }}:
+        | Section | Size | Difference |
+        | ------- | ---- | ---------- |
+        | text    | ${{ needs.build-firmware.outputs.text_size }}B | ${{ steps.output-sizes-diff.outputs.text_diff }}B |
+        | data    | ${{ needs.build-firmware.outputs.data_size }}B | ${{ steps.output-sizes-diff.outputs.data_diff }}B |
+        | bss     | ${{ needs.build-firmware.outputs.bss_size }}B  | ${{ steps.output-sizes-diff.outputs.bss_diff }}B  |
+
+        [Run in InfiniEmu](https://infiniemu.pipe01.net/?firmware=artifact://${{ github.repository }}/${{ needs.build-firmware.outputs.firmware_artifact }}&resources=artifact://${{ github.repository }}/${{ needs.build-firmware.outputs.resources_artifact }})
+        EOF
+
+    - name: Upload comment
+      uses: actions/upload-artifact@v4
+      with:
+        name: comment
+        path: comment

.github/workflows/pr-comment.yml

@@ -0,0 +1,56 @@
+# THIS WORKFLOW HAS WRITE PERMISSIONS TO THE REPO.
+# MAKE SURE IT NEVER RUNS ANY CODE FROM THE FORK
+
+name: PR comment
+
+on:
+  pull_request_target:
+    branches: [ main ]
+    paths-ignore:
+      - 'doc/**'
+      - '**.md'
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Wait for builds to finish
+      id: wait-for-build
+      uses: fountainhead/action-wait-for-check@297be350cf8393728ea4d4b39435c7d7ae167c93
+      with:
+        checkName: 'Compare build size'
+        token: ${{ secrets.GITHUB_TOKEN }}
+        ref: ${{ github.event.pull_request.head.sha }}
+
+    - if: steps.wait-for-build.outputs.conclusion != 'success'
+      run: |
+        tee comment << EOF
+        Build checks have not completed. Possible reasons for this are:
+        1. The checks need to be approved by a maintainer
+        2. The branch has conflicts
+        3. The firmware build has failed
+        EOF
+
+    - if: steps.wait-for-build.outputs.conclusion == 'success'
+      name: Download artifact
+      uses: dawidd6/action-download-artifact@bd10f381a96414ce2b13a11bfa89902ba7cea07f
+      with:
+        workflow: main.yml
+        workflow_conclusion:
+        pr: ${{ github.event.pull_request.number }}
+        name: comment
+
+    - name: Find Comment
+      id: find-comment
+      uses: peter-evans/find-comment@81e2da3af01c92f83cb927cf3ace0e085617c556
+      with:
+        issue-number: ${{ github.event.pull_request.number }}
+        comment-author: 'github-actions[bot]'
+
+    - name: Create or update comment
+      uses: peter-evans/create-or-update-comment@5adcb0bb0f9fb3f95ef05400558bdb3f329ee808
+      with:
+        comment-id: ${{ steps.find-comment.outputs.comment-id }}
+        issue-number: ${{ github.event.pull_request.number }}
+        body-file: comment
+        edit-mode: replace

.gitignore

@@ -1,10 +1,16 @@
 .idea/
+# Python virtual environment for DFU images
+.venv/
+
 # CMake
-cmake-build-*/
+cmake-build-*
-CMakeFiles/
+cmake-*/
+CMakeFiles
 **/CMakeCache.txt
 cmake_install.cmake
 Makefile
+build
+tools
 
 # Resulting binary files
 *.a
@@ -33,3 +39,19 @@ Testing/Temporary/
 
 # Windows
 **/thumbs.db
+
+#VSCODE
+.vscode/.cortex-debug.registers.state.json
+.vscode/.cortex-debug.peripherals.state.json
+
+#build files
+src/nRF5_SDK_15.3.0_59ac345
+src/arm-none-eabi
+
+# clangd
+.cache/
+
+# npm files
+node_modules
+package.json
+package-lock.json

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "src/libs/lvgl"]
+	path = src/libs/lvgl
+	url = https://github.com/InfiniTimeOrg/lvgl.git
+[submodule "src/libs/littlefs"]
+	path = src/libs/littlefs
+	url = https://github.com/littlefs-project/littlefs.git
+[submodule "src/libs/arduinoFFT"]
+	path = src/libs/arduinoFFT
+	url = https://github.com/kosme/arduinoFFT.git

.gitpod.yml

@@ -0,0 +1,18 @@
+image:
+  file: docker/.gitpod.Dockerfile
+github:
+  prebuilds:
+    # enable for the master/default branch (defaults to true)
+    master: true
+    # enable for all branches in this repo (defaults to false)
+    branches: false
+    # enable for pull requests coming from this repo (defaults to true)
+    pullRequests: false
+    # enable for pull requests coming from forks (defaults to false)
+    pullRequestsFromForks: false
+    # add a "Review in Gitpod" button as a comment to pull requests (defaults to true)
+    addComment: true
+    # add a "Review in Gitpod" button to pull requests (defaults to false)
+    addBadge: false
+    # add a label once the prebuild is ready to pull requests (defaults to false)
+    addLabel: false #prebuilt-in-gitpod

.idea/codeStyles/Project.xml

@@ -12,6 +12,29 @@
       <option name="SPACE_BEFORE_REFERENCE_IN_DECLARATION" value="false" />
       <option name="SPACE_AFTER_REFERENCE_IN_DECLARATION" value="true" />
     </Objective-C>
+    <Objective-C-extensions>
+      <rules>
+        <rule entity="NAMESPACE" visibility="ANY" specifier="ANY" prefix="" style="PASCAL_CASE" suffix="" />
+        <rule entity="MACRO" visibility="ANY" specifier="ANY" prefix="" style="SCREAMING_SNAKE_CASE" suffix="" />
+        <rule entity="CLASS" visibility="ANY" specifier="ANY" prefix="" style="PASCAL_CASE" suffix="" />
+        <rule entity="STRUCT" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="ENUM" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="ENUMERATOR" visibility="ANY" specifier="ANY" prefix="" style="PASCAL_CASE" suffix="" />
+        <rule entity="TYPEDEF" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="UNION" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="CLASS_MEMBER_FUNCTION" visibility="ANY" specifier="ANY" prefix="" style="PASCAL_CASE" suffix="" />
+        <rule entity="STRUCT_MEMBER_FUNCTION" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="CLASS_MEMBER_FIELD" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="STRUCT_MEMBER_FIELD" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="GLOBAL_FUNCTION" visibility="ANY" specifier="ANY" prefix="" style="PASCAL_CASE" suffix="" />
+        <rule entity="GLOBAL_VARIABLE" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="PARAMETER" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+        <rule entity="LOCAL_VARIABLE" visibility="ANY" specifier="ANY" prefix="" style="CAMEL_CASE" suffix="" />
+      </rules>
+    </Objective-C-extensions>
+    <clangFormatSettings>
+      <option name="ENABLED" value="true" />
+    </clangFormatSettings>
     <codeStyleSettings language="ObjectiveC">
       <option name="RIGHT_MARGIN" value="140" />
       <option name="IF_BRACE_FORCE" value="3" />

.vscode/c_cpp_properties.json

@@ -0,0 +1,40 @@
+{
+    "env": {
+        // TODO: This is a duplication of the configuration set in /docker/build.sh!
+        "TOOLS_DIR": "/opt",
+        "GCC_ARM_PATH": "gcc-arm-none-eabi-10.3-2021.10"
+    },
+    "configurations": [
+        {
+            "name": "nrfCC",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/src/**",
+                "${workspaceFolder}/src"
+            ],
+            "defines": [],
+            "compilerPath": "${env:ARM_NONE_EABI_TOOLCHAIN_PATH}/bin/arm-none-eabi-gcc",
+            "cStandard": "c11",
+            "cppStandard": "c++20",
+            "intelliSenseMode": "linux-gcc-arm",
+            "configurationProvider": "ms-vscode.cpp-tools",
+            "compileCommands": "${workspaceFolder}/build/compile_commands.json"
+        },
+        {
+            "name": "nrfCC Devcontainer",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/src/**",
+                "${workspaceFolder}/src"
+            ],
+            "defines": [],
+            "compilerPath": "${TOOLS_DIR}/${GCC_ARM_PATH}/bin/arm-none-eabi-gcc",
+            "cStandard": "c99",
+            "cppStandard": "c++20",
+            "intelliSenseMode": "linux-gcc-arm",
+            "configurationProvider": "ms-vscode.cpp-tools",
+            "compileCommands": "${workspaceFolder}/build/compile_commands.json"
+        }
+    ],
+    "version": 4
+}

.vscode/cmake-kits.json

@@ -0,0 +1,6 @@
+[
+    {
+        "name": "InfiniTime Compiler",
+        "environmentSetupScript": "${workspaceFolder}/docker/build.sh"
+    }
+]

.vscode/cmake-variants.json

@@ -0,0 +1,62 @@
+{
+    "buildType": {
+      "default": "release",
+        "choices": { 
+          "debug": {
+            "short": "Debug",
+            "long": "Emit debug information without performing optimizations",
+            "buildType": "Debug"
+          },
+          "release": {
+            "short": "Release",
+            "long": "Perform optimizations",
+            "buildType": "Release"
+          }    
+        }
+    },
+    "programmer":{
+        "default": "OpenOCD",
+        "choices":{
+            "OpenOCD":{
+                "short":"OpenOCD",
+                "long": "Use OpenOCD",
+                "settings":{
+                    "USE_OPENOCD":1
+                }
+            },
+            "JLink":{
+                "short":"JLink",
+                "long": "Use JLink",
+                "settings":{
+                    "USE_JLINK":1
+                }
+            },
+            "GDB":{
+                "short":"GDB",
+                "long": "Use GDB",
+                "settings":{
+                    "USE_GDB_CLIENT":1
+                }
+            }
+        }
+    },
+    "DFU": {
+        "default": "no",
+          "choices": { 
+            "no": {
+              "short": "No DFU",
+              "long": "Do not build DFU",
+              "settings": {
+                  "BUILD_DFU":"0"
+                }
+            },
+            "yes": {
+                "short": "Build DFU",
+                "long": "Build DFU",
+                "settings": {
+                    "BUILD_DFU":"1"
+                }
+            }
+        }
+    }
+}

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+    "recommendations": ["ms-vscode.cpptools","ms-vscode.cmake-tools","marus25.cortex-debug"]
+}

.vscode/launch.json

@@ -0,0 +1,83 @@
+{
+    "version": "0.1.0",
+    "configurations": [
+        {
+            "name": "Debug - Openocd docker Remote",
+            "type": "cortex-debug",
+            "cwd": "${workspaceRoot}",
+            "executable": "${command:cmake.launchTargetPath}",
+            "request": "launch",
+            "servertype": "external",
+            "gdbPath": "${env:ARM_NONE_EABI_TOOLCHAIN_PATH}/bin/arm-none-eabi-gdb",
+            // Connect to an already running OpenOCD instance
+            "gdbTarget": "host.docker.internal:3333",
+            "svdFile": "${workspaceRoot}/nrf52.svd",
+            "runToEntryPoint": "main",
+            // Work around for stopping at main on restart
+            "postRestartCommands": [
+                "break main",
+                "continue"
+            ]
+        },
+        {
+            "name": "Debug - Openocd Local",
+            "type": "cortex-debug",
+            "cwd": "${workspaceRoot}",
+            "executable": "${command:cmake.launchTargetPath}",
+            "request": "launch",
+            "servertype": "openocd",
+            "gdbPath": "${env:ARM_NONE_EABI_TOOLCHAIN_PATH}/bin/arm-none-eabi-gdb",
+            // Connect to an already running OpenOCD instance
+            "gdbTarget": "localhost:3333",
+            "svdFile": "${workspaceRoot}/nrf52.svd",
+            "runToEntryPoint": "main",
+            // Work around for stopping at main on restart
+            "postRestartCommands": [
+                "break main",
+                "continue"
+            ]
+        },
+        {
+            "cwd": "${workspaceRoot}",
+            // TODO: find better way to get latest build filename
+            "executable": "./build/src/pinetime-app-1.3.0.out",
+            "name": "Debug OpenOCD ST-LINK pinetime-app-1.3.0.out",
+            "request": "launch",
+            "type": "cortex-debug",
+            "showDevDebugOutput": false,
+            "servertype": "openocd",
+            "runToMain": true,
+            // Work around for stopping at main on restart
+            "postRestartCommands": [
+                "break main",
+                "continue"
+            ],
+            // Only use armToolchainPath if your arm-none-eabi-gdb is not in your path (some GCC packages does not contain arm-none-eabi-gdb)
+            "armToolchainPath": "${workspaceRoot}/../gcc-arm-none-eabi-10.3-2021.10/bin",
+            "svdFile": "${workspaceRoot}/nrf52.svd",
+            "configFiles": [
+                "interface/stlink.cfg",
+                "target/nrf52.cfg"
+            ],
+        },
+        {
+            "name": "Debug - Openocd Devcontainer",
+            "type": "cortex-debug",
+            "cwd": "${workspaceRoot}",
+            "executable": "${command:cmake.launchTargetPath}",
+            "request": "launch",
+            "servertype": "external",
+            // FIXME: This is hardcoded. I have no idea how to use the values set in build.sh here
+            "gdbPath": "/opt/gcc-arm-none-eabi-10.3-2021.10/bin/arm-none-eabi-gdb",
+            // Connect to an already running OpenOCD instance
+            "gdbTarget": "host.docker.internal:3333",
+            "svdFile": "${workspaceRoot}/nrf52.svd",
+            "runToEntryPoint": "main",
+            // Work around for stopping at main on restart
+            "postRestartCommands": [
+                "break main",
+                "continue"
+            ]
+        },
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,70 @@
+{
+    "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
+    "cmake.configureArgs": [
+        "-DARM_NONE_EABI_TOOLCHAIN_PATH=${env:TOOLS_DIR}/${env:GCC_ARM_PATH}",
+        "-DNRF5_SDK_PATH=${env:TOOLS_DIR}/${env:NRF_SDK_VER}",
+    ],
+    "cmake.statusbar.advanced": {
+        "launch": {
+            "visibility": "hidden"
+        },
+        "launchTarget": {
+            "visibility": "hidden"
+        },
+        "debug": {
+            "visibility": "hidden"
+        }
+    },
+    "cmake.generator": "Unix Makefiles",
+    "clang-tidy.buildPath": "build/compile_commands.json",
+    "files.associations": {
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp"
+    }
+}

.vscode/tasks.json

@@ -0,0 +1,22 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "update submodules",
+			"type": "shell",
+			"command": "git submodule update --init",
+			"options": {
+				"cwd": "${workspaceFolder}"
+			},
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"presentation": {
+				"reveal": "always",
+				"panel": "shared"
+			},
+			"problemMatcher": []
+		}
+	]
+}

CMakeLists.txt

@@ -1,6 +1,19 @@
 cmake_minimum_required(VERSION 3.10)
-project(pinetime VERSION 0.9.0 LANGUAGES C CXX ASM)
 
+set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose Debug or Release")
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+project(pinetime VERSION 1.16.0 LANGUAGES C CXX ASM)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_CXX_STANDARD 20)
+
+# set(CMAKE_GENERATOR "Unix Makefiles")
+set(CMAKE_C_EXTENSIONS OFF)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(NRF_TARGET "nrf52")
 
 if (NOT ARM_NONE_EABI_TOOLCHAIN_PATH)
@@ -11,61 +24,50 @@ if (NOT NRF5_SDK_PATH)
   message(FATAL_ERROR "The path to the NRF52 SDK must be specified on the command line (add -DNRF5_SDK_PATH=<path>")
 endif ()
 
-if(NOT USE_JLINK AND NOT USE_GDB_CLIENT AND NOT USE_OPENOCD)
+if(BUILD_DFU)
-  set(USE_JLINK true)
+  set(BUILD_DFU true)
 endif()
 
-if(USE_JLINK)
+if(BUILD_RESOURCES)
-  if (NOT NRFJPROG)
+  set(BUILD_RESOURCES true)
-    message(FATAL_ERROR "the path to the tool nrfjprog must be specified on the command line (add -DNRFJPROG=<path>")
-  endif ()
 endif()
 
-if(USE_GDB_CLIENT)
+set(TARGET_DEVICE "PINETIME" CACHE STRING "Target device")
-  if(NOT GDB_CLIENT_BIN_PATH)
+set_property(CACHE TARGET_DEVICE PROPERTY STRINGS PINETIME MOY_TFK5 MOY_TIN5 MOY_TON5 MOY_UNK)
-    set(GDB_CLIENT_BIN_PATH "arm-none-eabi-gdb")
-  endif()
 
-  if(NOT GDB_CLIENT_TARGET_REMOTE)
+set(PROJECT_GIT_COMMIT_HASH "")
-    message(FATAL_ERROR "The GDB target must be specified (add -DGDB_CLIENT_TARGET_REMOTE=<target>")
-  endif()
-endif()
 
-if(USE_OPENOCD)
+execute_process(COMMAND git rev-parse --short HEAD
-  if(NOT OPENOCD_BIN_PATH)
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    set(OPENOCD_BIN_PATH "openocd")
+                OUTPUT_VARIABLE PROJECT_GIT_COMMIT_HASH
-  endif()
+                RESULT_VARIABLE PROJECT_GIT_COMMIT_HASH_SUCCESS)
-endif()
 
-if(DEFINED USE_DEBUG_PINS AND USE_DEBUG_PINS)
+string(STRIP "${PROJECT_GIT_COMMIT_HASH}" PROJECT_GIT_COMMIT_HASH)
-  add_definitions(-DUSE_DEBUG_PINS)
-endif()
 
+message("PROJECT_GIT_COMMIT_HASH_SUCCESS? " ${PROJECT_GIT_COMMIT_HASH_SUCCESS})
+
+message("")
 message("BUILD CONFIGURATION")
 message("-------------------")
+message("    * Mode : " ${CMAKE_BUILD_TYPE})
 message("    * Version : " ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
 message("    * Toolchain : " ${ARM_NONE_EABI_TOOLCHAIN_PATH})
+message("    * GitRef(S) : " ${PROJECT_GIT_COMMIT_HASH})
 message("    * NRF52 SDK : " ${NRF5_SDK_PATH})
-set(PROGRAMMER "???")
+message("    * Target device : " ${TARGET_DEVICE})
-if(USE_JLINK)
+if(BUILD_DFU)
-  message("    * Programmer/debugger : JLINK")
+  message("    * Build DFU (using adafruit-nrfutil) : Enabled")
-  message("    * NrfJprog : " ${NRFJPROG})
-elseif(USE_GDB_CLIENT)
-  message("    * Programmer/debugger : GDB Client")
-  message("    * GDB Client path : " ${GDB_CLIENT_BIN_PATH})
-  message("    * GDB Target : " ${GDB_CLIENT_TARGET_REMOTE})
-elseif(USE_OPENOCD)
-  message("    * Programmer/debugger : OpenOCD Client")
-endif()
-if(USE_DEBUG_PINS)
-  message("    * Debug pins : Enabled")
 else()
-  message("    * Debug pins : Disabled")
+  message("    * Build DFU (using adafruit-nrfutil) : Disabled")
+endif()
+if(BUILD_RESOURCES)
+  message("    * Build resources : Enabled")
+else()
+  message("    * Build resources : Disabled")
 endif()
 
 set(VERSION_EDIT_WARNING "// Do not edit this file, it is automatically generated by CMAKE!")
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/Version.h.in ${CMAKE_CURRENT_SOURCE_DIR}/src/Version.h)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/Version.h.in ${CMAKE_CURRENT_BINARY_DIR}/src/Version.h)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/docker/post_build.sh.in ${CMAKE_CURRENT_SOURCE_DIR}/docker/post_build.sh)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/docker/post_build.sh.in ${CMAKE_CURRENT_BINARY_DIR}/post_build.sh)
-
 
 add_subdirectory(src)

CONTRIBUTING.md

@@ -0,0 +1,61 @@
+# How to contribute?
+
+Here are things you can do to help.
+
+- [Report bugs or issues](https://github.com/InfiniTimeOrg/InfiniTime/issues/new/choose)
+- [Write and improve documentation](#documentation)
+- [Fix bugs, add functionalities and improve the code](#how-to-create-a-pull-request)
+- Participate in the discussions within issues and PRs. Your feedback is appreciated!
+- Review pull requests. Follow the instructions [here](doc/maintainer-guide.md#reviewing-prs)
+
+## Documentation
+
+Documentation might be incomplete,
+or not clear enough,
+and it is always possible to improve it with better wording, pictures, videos,...
+As the documentation is part of the source code,
+you can submit changes to the documentation by creating a [pull request](#how-to-create-a-pull-request)
+
+## How to create a pull request?
+
+The workflow is based on [GitHub flow](https://docs.github.com/en/get-started/quickstart/github-flow).
+
+To create a pull request,
+you need a [fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/about-forks) of the repo.
+Create a new [branch](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-branches) from main,
+make changes in this branch,
+[commit](https://docs.github.com/en/pull-requests/committing-changes-to-your-project/creating-and-editing-commits/about-commits) them,
+and create a [pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
+
+### PR checklist
+
+When making changes to the firmware:
+
+- Consider if your feature aligns with the [InfiniTime vision](doc/InfiniTimeVision.md)
+- Test your changes on a PineTime or InfiniSim
+- Make sure the code conforms to the [coding conventions](doc/coding-convention.md)
+
+You can also check the [maintainer's guide](doc/maintainer-guide.md)
+for what maintainers will look at in PRs.
+
+### Commit conventions
+
+- Every commit must contain a title and description,
+  that sufficiently explains all the changes in the commit
+- Commits that fix mistakes from previous commits must be squashed
+- Conflicts must be resolved by rebasing,
+  instead of merging
+
+### Commit format
+
+The preferred format for commits is the following:
+
+```
+module: Short description
+
+A more thorough description of all changes in this commit if necessary.
+```
+
+where module can be the name of the file,
+with or without extension,
+or a single word explaining the scope of the changes.

README.md

@@ -1,113 +1,111 @@
+<div align="center">
 
-# PineTime
+![Header Image](doc/logo/watchface_collage.png)
-> The PineTime is a free and open source smartwatch capable of running custom-built open operating systems. Some of the notable features include a heart rate monitor, a week-long battery as well as a capacitive touch IPS display that is legible in direct sunlight. It is a fully community driven side-project, which means that it will ultimately be up to the developers and end-users to determine when they deem the PineTime ready to ship.
 
-> We envision the PineTime as a companion for not only your PinePhone but also for your favorite devices — any phone, tablet, or even PC.
+<br>
 
-*https://www.pine64.org/pinetime/*
+[![GitHub tag](https://img.shields.io/github/tag/InfiniTimeOrg/InfiniTime?include_prereleases=&sort=semver&color=blue)](https://github.com/InfiniTimeOrg/InfiniTime/releases)
-
+[![GitHub License](https://img.shields.io/github/license/InfiniTimeOrg/InfiniTime)](https://github.com/InfiniTimeOrg/InfiniLink/blob/main/LICENSE)
-The **Pinetime** smartwatch is built around the NRF52832 MCU (512KB Flash, 64KB RAM), a 240*240 LCD display driven by the ST7789 controller, an accelerometer, a heart rate sensor, and a vibration motor.
+[![Issues - InfiniTime](https://img.shields.io/github/issues/InfiniTimeOrg/InfiniTime)](https://github.com/InfiniTimeOrg/InfiniTime/issues)
+[![Pull Requests - InfiniTime](https://img.shields.io/github/issues-pr/InfiniTimeOrg/InfiniTime)](https://github.com/InfiniTimeOrg/InfiniTime/pulls)
+[![Downloads - InfiniTime](https://img.shields.io/github/downloads/InfiniTimeOrg/InfiniTime/total)](https://github.com/InfiniTimeOrg/InfiniTime)
+[![Stars - InfiniTime](https://img.shields.io/github/stars/InfiniTimeOrg/InfiniTime?style=social)](https://github.com/InfiniTimeOrg/InfiniTime/stargazers)
+[![Forks - InfiniTime](https://img.shields.io/github/forks/InfiniTimeOrg/InfiniTime?style=social)](https://github.com/InfiniTimeOrg/InfiniTime/network/members)
 
 # InfiniTime
-![InfiniTime logo](images/infinitime-logo.jpg "InfiniTime Logo")
 
-The goal of this project is to design an open-source firmware for the Pinetime smartwatch : 
+*Fast open-source firmware for the [PineTime smartwatch](https://pine64.org/devices/pinetime/) with many features, written in modern C++.*
 
- - Code written in **modern C++**;
+<br>
- - Build system based on **CMake**;
- - Based on **[FreeRTOS 10.0.0](https://freertos.org)** real-time OS.
- - Using **[LittleVGL/LVGL 6.1.2](https://lvgl.io/)** as UI library...
- - ... and **[NimBLE 1.3.0](https://github.com/apache/mynewt-nimble)** as BLE stack.
 
-## Overview
+</div>
 
-![Pinetime screens](images/0.7.0/montage.jpg "PinetimeScreens")
+## New to InfiniTime?
 
-As of now, here is the list of achievements of this project:
+- [Getting started with InfiniTime](doc/gettingStarted/gettingStarted-1.0.md)
+- [Updating the software](doc/gettingStarted/updating-software.md)
+- [About the firmware and bootloader](doc/gettingStarted/about-software.md)
+- [Available apps](doc/gettingStarted/Applications.md)
+- [Available watch faces](/doc/gettingStarted/Watchfaces.md)
+- [PineTimeStyle Watch face](https://pine64.org/documentation/PineTime/Watchfaces/PineTimeStyle)
+  - [Weather integration](https://pine64.org/documentation/PineTime/Software/InfiniTime_weather/)
 
- - Fast and optimized LCD driver
+### Companion apps
- - BLE communication
- - Rich user interface via display, touchscreen and pushbutton
- - Time synchronization via BLE
- - Notification via BLE
- - Multiple 'apps' : 
-    * Clock (displays the date, time, battery level, BLE connection status, heart rate and step count)
-    * Heart rate
-    * Motion
-    * System info (displays various info : BLE MAC, build date/time, uptime, version, ...)
-    * Brightness (allows the user to configure the brightness of the display)
- - Supported by 2 companion apps (development is in progress):
-    * [Gadgetbridge](https://codeberg.org/Freeyourgadget/Gadgetbridge/) (on Android)
-    * [Amazfish](https://openrepos.net/content/piggz/amazfish) (on SailfishOS)
- - **[Experimental]** OTA (Over-the-air) update via BLE
- - **[Experimental]** Bootloader based on [MCUBoot](https://juullabs-oss.github.io/mcuboot/)
 
-## Documentation
+- [Gadgetbridge](https://gadgetbridge.org/) (Android)
+- [Amazfish](https://github.com/piggz/harbour-amazfish/) ([SailfishOS](https://sailfishos-chum.github.io/apps/harbour-amazfish/), [Ubuntu Touch](https://open-store.io/app/uk.co.piggz.amazfish), [Flatpak](https://flathub.org/apps/uk.co.piggz.amazfish))
+- [Siglo](https://github.com/alexr4535/siglo) (Linux)
+- [InfiniLink](https://github.com/InfiniTimeOrg/InfiniLink) (iOS)
+- [ITD](https://gitea.elara.ws/Elara6331/itd) (Linux)
+- [WatchMate](https://github.com/azymohliad/watchmate) (Linux)
+- [InfiniTimeExplorer](https://infinitimeexplorer.netlify.app) (Web)
 
-### Develop
+<br>
- - [Generate the fonts and symbols](src/displayapp/fonts/Readme.md)
+
+> *InfiniTimeExplorer is only compatible with web browsers that support Web BLE. Current fully supported browsers include Chrome and Microsoft Edge.* 
+>
+> *We removed mentions to NRFConnect as this app is closed source and recent versions do not work anymore with InfiniTime (the last version known to work is 4.24.3). If you used NRFConnect in the past, we recommend you switch to [Gadgetbridge](https://gadgetbridge.org/).* 
+
+## Development
+
+- [InfiniTime Vision](doc/InfiniTimeVision.md)
+- [Rough structure of the code](doc/code/Intro.md)
+- [How to implement an application](doc/code/Apps.md)
+- [Generate the fonts and symbols](src/displayapp/fonts/README.md)
+- [Tips on designing an app UI](doc/ui_guidelines.md)
+- [Bootloader, OTA and DFU](bootloader/README.md)
+- [External resources](doc/ExternalResources.md)
+
+### Contributing
+
+- [How to contribute](CONTRIBUTING.md)
+- [Coding conventions](doc/coding-convention.md)
 
 ### Build, flash and debug
- - [Project branches](doc/branches.md)
- - [Versioning](doc/versioning.md)
- - [Files included in the release notes](doc/filesInReleaseNotes.md)
- - [Build the project](doc/buildAndProgram.md)
- - [Flash the firmware using OpenOCD and STLinkV2](doc/openOCD.md)
- - [Build the project with Docker](doc/buildWithDocker.md)
- - [Bootloader, OTA and DFU](./bootloader/README.md)
- - [Stub using NRF52-DK](./doc/PinetimeStubWithNrf52DK.md)
- - Logging with JLink RTT.
- - Using files from the releases
 
-### Contribute
+- [InfiniTime simulator](https://github.com/InfiniTimeOrg/InfiniSim)
- - [How to contribute ?](doc/contribute.md)
+- [Build the project](doc/buildAndProgram.md)
+- [Build the project with Docker](doc/buildWithDocker.md)
+- [Build the project with VSCode](doc/buildWithVScode.md)
+- [Flash the firmware using OpenOCD and STLinkV2](doc/openOCD.md)
+- [Flash the firmware using SWD interface](doc/SWD.md)
+- [Flash the firmware using JLink](doc/jlink.md)
+- [Flash the firmware using GDB](doc/gdb.md)
+- [Stub using NRF52-DK](doc/PinetimeStubWithNrf52DK.md)
 
 ### API
- - [BLE implementation and API](./doc/ble.md)
+
+- [BLE implementation and API](doc/ble.md)
 
 ### Architecture and technical topics
- - [Memory analysis](./doc/MemoryAnalysis.md)
 
-### Using the firmware
+- [Memory analysis](doc/MemoryAnalysis.md)
- - [Integration with Gadgetbridge](doc/CompanionApps/Gadgetbridge.md)
- - [Integration with AmazFish](doc/CompanionApps/Amazfish.md)
- - [Firmware update, OTA](doc/CompanionApps/NrfconnectOTA.md)
 
+### Project management
 
-## TODO - contribute
+- [Maintainer's guide](doc/maintainer-guide.md)
-
+- [Versioning](doc/versioning.md)
-This project is far from being finished, and there are still a lot of things to do for this project to become a firmware usable by the general public.
+- [Project branches](doc/branches.md)
-
+- [Files included in the release notes](doc/filesInReleaseNotes.md)
-Here a quick list out of my head of things to do for this project:
+- [Files needed by the factory](doc/files-needed-by-factory.md)
-
- - Improve BLE communication stability and reliability
- - Improve OTA and MCUBoot bootloader
- - Add more functionalities : Alarm, chronometer, configuration, activities, heart rate logging, games,...
- - Add more BLE functionalities : call notifications, agenda, configuration, data logging,...
- - Measure power consumption and improve battery life
- - Improve documentation, take better pictures and video than mine
- - Improve the UI
- - Create companion app for multiple OSes (Linux, Android, iOS) and platforms (desktop, ARM, mobile). Do not forget the other devices from Pine64 like [the Pinephone](https://www.pine64.org/pinephone/) and the [Pinebook Pro](https://www.pine64.org/pinebook-pro/). 
- - Design a simple CI (preferably self-hosted and easy to reproduce).
- 
-Do not hesitate to clone/fork the code, hack it and create pull-requests. I'll do my best to review and merge them :)
 
 ## Licenses
+
 This project is released under the GNU General Public License version 3 or, at your option, any later version.
 
 It integrates the following projects:
- - RTOS : **[FreeRTOS](https://freertos.org)** under the MIT license
+
- - UI : **[LittleVGL/LVGL](https://lvgl.io/)** under the MIT license
+- RTOS: **[FreeRTOS](https://freertos.org)** under the MIT license
- - BLE stack : **[NimBLE](https://github.com/apache/mynewt-nimble)** under the Apache 2.0 license
+- UI: **[LittleVGL/LVGL](https://lvgl.io/)** under the MIT license
- - Font : **[Jetbrains Mono](https://www.jetbrains.com/fr-fr/lp/mono/)** under the Apache 2.0 license
+- BLE stack: **[NimBLE](https://github.com/apache/mynewt-nimble)** under the Apache 2.0 license
+- Font: **[Jetbrains Mono](https://www.jetbrains.com/fr-fr/lp/mono/)** under the Apache 2.0 license
 
 ## Credits
-I’m not working alone on this project. First, many people create PR for this projects. Then, there is the whole #pinetime community : a lot of people all around the world who are hacking, searching, experimenting and programming the Pinetime. We exchange our ideas, experiments and code in the chat rooms and forums.
+
+I’m not working alone on this project. First, many people create pull requests for this project. Then, there is the whole #pinetime community: a lot of people all around the world who are hacking, searching, experimenting and programming the Pinetime. We exchange our ideas, experiments and code in the chat rooms and forums.
 
 Here are some people I would like to highlight:
 
- - [Atc1441](https://github.com/atc1441/) : He works on an Arduino based firmware for the Pinetime and many other smartwatches based on similar hardware. He was of great help when I was implementing support for the BMA421 motion sensor and I²C driver.
+- [Atc1441](https://github.com/atc1441/): He works on an Arduino based firmware for the Pinetime and many other smartwatches based on similar hardware. He was of great help when I was implementing support for the BMA421 motion sensor and I²C driver.
- - [Koen](https://github.com/bosmoment) : He’s working on a firmware based on RiotOS. He integrated similar libs as me : NimBLE, LittleVGL,… His help was invaluable too!
+- [Koen](https://github.com/bosmoment): He’s working on a firmware based on RiotOS. He integrated similar libs as me: NimBLE, LittleVGL,… His help was invaluable too!
- - [Lup Yuen Lee](https://github.com/lupyuen) : He is everywhere: he works on a Rust firmware, builds a MCUBoot based bootloader for the Pinetime, designs a Flutter based companion app for smartphones and writes a lot of articles about the Pinetime!
+- [Lup Yuen Lee](https://github.com/lupyuen): He is everywhere: he works on a Rust firmware, builds a MCUBoot based bootloader for the Pinetime, designs a Flutter based companion app for smartphones and writes a lot of articles about the Pinetime!
-
-*If you feel like you should appear on this list, just get in touch with me or submit a PR :)*

bootloader/README.md

@@ -1,5 +1,6 @@
 # About this bootloader
-The [bootloader](https://github.com/lupyuen/pinetime-rust-mynewt/tree/master/libs/pinetime_boot/src) is mostly developed by [Lup Yuen](https://github.com/lupyuen). It is based on [MCUBoot](https://juullabs-oss.github.io/mcuboot/) and [Mynewt](https://mynewt.apache.org/).
+
+The [bootloader](https://github.com/lupyuen/pinetime-rust-mynewt/tree/master/libs/pinetime_boot/src) is mostly developed by [Lup Yuen](https://github.com/lupyuen). It is based on [MCUBoot](https://www.mcuboot.com) and [Mynewt](https://mynewt.apache.org/).
 
 The goal of this project is to provide a common bootloader for multiple (all?) Pinetime projects. It allows to upgrade the current bootloader and even replace the current application by another one that supports the same bootloader.
 
@@ -9,18 +10,20 @@ Integrating a BLE stack for the OTA functionality would have used to much memory
 
 When it is run, this bootloader looks in the SPI flash memory if a new firmware is available. It there is one, it *swaps* the current firmware with the new one (the new one is copied in the main flash memory, and the current one is copied in the SPI flash memory) and run the new one. If the new one fails to run properly, the bootloader is able to revert to the old one and mark the new one as not working.
 
-As this bootloader does not provide any OTA capability, it is not able to actually download a new version of the application. Providing OTA functionality is thus the responsability of the application firmware.
+As this bootloader does not provide any OTA capability, it is not able to actually download a new version of the application. Providing OTA functionality is thus the responsibility of the application firmware.
 
 # About MCUBoot
+
 MCUBoot is run at boot time. In normal operation, it just jumps to the reset handler of the application firmware to run it. Once the application firmware is running, MCUBoot does not run at all.
 
 ![MCUBoot boot sequence diagram](../doc/bootloader/boot.png "MCUBoot boot sequence diagram")
 
-But MCUBoot does much more than that : it can upgrade the firmware that is currently running by a new one, and it is also able to revert to the previous version of the firmware in case the new one does not run propertly.
+But MCUBoot does much more than that : it can upgrade the firmware that is currently running by a new one, and it is also able to revert to the previous version of the firmware in case the new one does not run properly.
 
 To do this, it uses 2 memory 'slots' :
- - **The primary slot** : it contains the current firmware, the one that will be executed by MCUBoot
+
- - **The secondary slot** : it is used to store the upgraded version of the firmware, when available.
+- **The primary slot** : it contains the current firmware, the one that will be executed by MCUBoot
+- **The secondary slot** : it is used to store the upgraded version of the firmware, when available.
 
 At boot time, MCUBoot detects that a new version of the firmware is available in the secondary slot and swaps them : the current version of the firmware is copied from the primary to the secondary slot and vice-versa.
 
@@ -35,12 +38,13 @@ The next time MCUBoot will be run (after a MCU reset), MCUBoot will check if the
 Note than MCUBoot **does not** provide any means to download and store the new version of the firmware into the secondary slot. This must be implemented by the application firmware.
 
 # Degraded cases
+
 This chapter describes degraded cases that are handled by our bootloader and those that are not supported.
 
 Case | Current bootloader | Solution
 -----|--------------------|----------------------------------------------
-Data got corrupted during file transfert | [OK] Application firmware does a CRC check before applying the update, and does not proceed if it fails. | N/A
+Data got corrupted during file transfer | [OK] Application firmware does a CRC check before applying the update, and does not proceed if it fails. | N/A
-New firmware does not run at all (bad file) (1) | [NOK] MCU executes unknown instructions and will most likely end up in an infinite loop or freeze in an error handler. The bootloader does not run, it can do nothing, the MCU is stucked until next reset | [OK] The bootloader starts the watchdog just before running the new firmware. This way, the watchdog will reset the MCU after ~7s because the firmware does not refresh it. Bootloader reverts to the previous version of the firmware during the reset.     
+New firmware does not run at all (bad file) (1) | [NOK] MCU executes unknown instructions and will most likely end up in an infinite loop or freeze in an error handler. The bootloader does not run, it can do nothing, the MCU is stuck until next reset | [OK] The bootloader starts the watchdog just before running the new firmware. This way, the watchdog will reset the MCU after ~7s because the firmware does not refresh it. Bootloader reverts to the previous version of the firmware during the reset.
 New firmware runs, does not set the valid bit and does not refresh the watchdog | [NOK] The new firmware runs until the next reset. The bootloader will be able to revert to the previous firmware only during the next reset. If the new firmware does not run properly and does not reset, the bootloader can do nothing until the next reset | [OK] The bootloader starts the watchdog just before running the new firmware. This way, the watchdog will reset the MCU after ~7s because the firmware does not refresh it. Bootloader reverts to the previous version of the firmware during the reset.
 New firmware does not run properly, does not set the valid bit but refreshes the watchdog | [NOK] The bootloader will be able to revert to the previous firmware only during the next reset. If the new firmware does not run properly and does not reset, the bootloader can do nothing until the next reset | [~] Wait for the battery to drain. The CPU will reset the next time the device is charged and will be able to rollback to the previous version.
 New firmware does not run properly but sets the valid bit and refreshes the watchdog | [NOK] The bootloader won't revert to the previous version because the valid flag is set | [~] Wait for the battery to drain. The CPU will reset the next time the device is charged. Then, the bootloader must provide a way for the user to force the rollback to the previous version
@@ -50,74 +54,73 @@ New firmware does not run properly but sets the valid bit and refreshes the watc
 # Using the bootloader
 
 ## Bootloader graphic
+
 The bootloader loads a graphic (Pinetime logo) from the SPI Flash memory. If this graphic is not loaded in the memory, the LCD will display garbage (the content of the SPI flash memory).
 
 The SPI Flash memory is not accessible via the SWD debugger. Use the firmware 'pinetime-graphics' to load the graphic into memory. All you have to do is build it and program it at address 0x00 :
 
- - Build:
+- Build:
-```
+
-$ make pinetime-graphics
+```sh
+make pinetime-graphics
 ```
 
- - Program (using OpenOCD for example) : 
+- Program (using OpenOCD for example) :
+
 ```
 program pinetime-graphics.bin 0
 ```
 
- - Let it run for ~10s (it does nothing for 5 seconds, then write the logo into the SPI memory, then (slowly) displays it on the LCD).
+- Let it run for ~10s (it does nothing for 5 seconds, then write the logo into the SPI memory, then (slowly) displays it on the LCD).
 
 ## Bootloader binary
+
 The binary comes from https://github.com/lupyuen/pinetime-rust-mynewt/releases/tag/v5.0.4
 
 It must be flash at address **0x00** in the internal flash memory.
 
 Using OpenOCD:
 
-`
+`program bootloader-5.0.4.bin 0`
-program bootloader-5.0.4.bin 0
-`
 
 ## Application firmware image
+
 Build the binary compatible with the booloader:
 
-`
+`make pinetime-mcuboot-app`
-make pinetime-mcuboot-app
-`
 
 The binary is located in *<build directory>/src/pinetime-mcuboot-app.bin*.
 
-It must me converted into a MCUBoot image using *imgtool.py* from [MCUBoot](https://github.com/JuulLabs-OSS/mcuboot/tree/master/scripts). Simply checkout the project and run the script <mcuboot root>/scripts/imgtool.py with the following command line:
+It must me converted into a MCUBoot image using *imgtool.py* from [MCUBoot](https://github.com/mcu-tools/mcuboot/tree/master/scripts). Simply checkout the project and run the script <mcuboot root>/scripts/imgtool.py with the following command line:
 
-`
+```sh
-imgtool.py  create --align 4 --version 1.0.0 --header-size 32 --slot-size 475136 --pad-header <build directory>/src/pinetime-mcuboot-app.bin image.bin
+imgtool.py create --align 4 --version 1.0.0 --header-size 32 --slot-size 475136 --pad-header <build directory>/src/pinetime-mcuboot-app.bin image.bin
-`
+```
 
 The image must be then flashed at address **0x8000** in the internal flash memory.
 
 Using OpenOCD:
 
-`
+`program image.bin 0x8000`
-program image.bin 0x8000
-`
 
 ## OTA and DFU
+
 Pack the image into a .zip file for the NRF DFU protocol:
 
-`
+```sh
 adafruit-nrfutil dfu genpkg --dev-type 0x0052 --application image.bin dfu.zip
-`
+```
 
 Use NRFConnect or dfu.py (in <project root>/bootloader/ota-dfu-python) to upload the zip file to the device:
 
-`
+```sh
 sudo dfu.py -z /home/jf/nrf52/bootloader/dfu.zip -a <pinetime MAC address> --legacy
-`
+```
 
 **Note** : dfu.py is a slightly modified version of [this repo](https://github.com/daniel-thompson/ota-dfu-python).
 
-See [this page](../doc/CompanionApps/NrfconnectOTA.md) for more info about OTA with NRFConect
-
 ### Firmware validation
+
 Once the OTA is done, InfiniTime will reset the watch to apply the update. When the watch reboots, the new firmware is running.
 
 One last step is needed to finalize the upgrade : the new firmware must be manually validated. If the watch resets while the image is not validated, the bootloader will automatically revert to the previous version of the firmware.
@@ -126,12 +129,12 @@ If the new firmware is working correctly, open the application menu and tap on t
 
 Firmware validation application in the menu:
 
-![Firmware Validation App](../doc/CompanionApps/firmwareValidationApp.jpg "Firmware Validation App")
+![Firmware Validation App](../doc/bootloader/firmwareValidationApp.jpg "Firmware Validation App")
 
 The firmware is not validated yet. Tap 'Validate' to validate it, or 'Reset' to rollback to the previous version.
 
-![Firmware Not Validated](../doc/CompanionApps/firmwareNoValidated.jpg "Firmware Not Validated")
+![Firmware Not Validated](../doc/bootloader/firmwareNoValidated.jpg "Firmware Not Validated")
 
 The firmware is validated!
 
-![Firmware Validated](../doc/CompanionApps/firmwareValidated.jpg "Firmware Validated")
+![Firmware Validated](../doc/bootloader/firmwareValidated.jpg "Firmware Validated")

bootloader/ota-dfu-python/.gitignore

@@ -0,0 +1 @@
+__pycache__

bootloader/ota-dfu-python/README.md

@@ -7,9 +7,9 @@ My own contribution is little more than a brute force conversion to
 python3. It is sparsely tested so there are likely to be a few
 remaining bytes versus string bugs remaining in the places I didn't test
 . I used it primarily as part of
-[wasp-os](https://github.com/daniel-thompson/wasp-os) as a way to 
+[wasp-os](https://github.com/wasp-os/wasp-os) as a way to
 deliver OTA updates to nRF52-based smart watches, especially the
-[Pine64 PineTime](https://www.pine64.org/pinetime/).
+[Pine64 PineTime](https://pine64.org/devices/pinetime/).
 
 ## What does it do?
 
@@ -17,24 +17,24 @@ This is a Python program that uses `gatttool` (provided with the Linux BlueZ dri
 
 ### Main features:
 
-* Perform OTA DFU to an nRF5 peripheral without an external USB BLE dongle.
+- Perform OTA DFU to an nRF5 peripheral without an external USB BLE dongle.
-* Ability to detect if the peripheral is running in application mode or bootloader, and automatically switch if needed (buttonless).
+- Ability to detect if the peripheral is running in application mode or bootloader, and automatically switch if needed (buttonless).
-* Support for both Legacy (SDK <= 11) and Secure (SDK >= 12) bootloader.
+- Support for both Legacy (SDK <= 11) and Secure (SDK >= 12) bootloader.
 
 Before using this utility the nRF5 peripheral device needs to be programmed with a DFU bootloader (see Nordic Semiconductor documentation/examples for instructions on that).
 
 ## Prerequisites
 
-* BlueZ 5.4 or above
+- BlueZ 5.4 or above
-* Python 3.6
+- Python 3.6
-* Python `pexpect` module (available via pip)
+- Python `pexpect` module (available via pip)
-* Python `intelhex` module (available via pip)
+- Python `intelhex` module (available via pip)
 
 ## Firmware Build Requirement
 
-* Your nRF5 peripheral firmware build method will produce  a firmware file ending with either `*.hex` or `*.bin`.
+- Your nRF5 peripheral firmware build method will produce a firmware file ending with either `*.hex` or `*.bin`.
-* Your nRF5 firmware build method will produce an Init file ending with `.dat`.
+- Your nRF5 firmware build method will produce an Init file ending with `.dat`.
-* The typical naming convention is `application.bin` and `application.dat`, but this utility will accept other names.
+- The typical naming convention is `application.bin` and `application.dat`, but this utility will accept other names.
 
 ## Generating init files
 
@@ -75,7 +75,6 @@ You can use the `hcitool lescan` to figure out the address of a DFU target, for
     CD:E3:4A:47:1C:E4 <TARGET_NAME>
     CD:E3:4A:47:1C:E4 (unknown)
 
-
 ## Example Output
 
         ================================
@@ -105,14 +104,14 @@ You can use the `hcitool lescan` to figure out the address of a DFU target, for
 
 ## TODO:
 
-* Implement link-loss procedure for Legacy Controller.
+- Implement link-loss procedure for Legacy Controller.
-* Update example output in readme.
+- Update example output in readme.
-* Add makefile examples.
+- Add makefile examples.
-* More code cleanup.
+- More code cleanup.
 
 ## Info & References
 
-* [Nordic Legacy DFU Service](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v11.0.0/bledfu_transport_bleservice.html?cp=4_0_3_4_3_1_4_1)
+- [Nordic Legacy DFU Service](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v11.0.0/bledfu_transport_bleservice.html?cp=4_0_3_4_3_1_4_1)
-* [Nordic Legacy DFU sequence diagrams](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v11.0.0/bledfu_transport_bleprofile.html?cp=4_0_3_4_3_1_4_0_1_6#ota_profile_pkt_rcpt_notif)
+- [Nordic Legacy DFU sequence diagrams](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v11.0.0/bledfu_transport_bleprofile.html?cp=4_0_3_4_3_1_4_0_1_6#ota_profile_pkt_rcpt_notif)
-* [Nordic Secure DFU bootloader](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v12.2.0/lib_dfu_transport_ble.html?cp=4_0_1_3_5_2_2)
+- [Nordic Secure DFU bootloader](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v12.2.0/lib_dfu_transport_ble.html?cp=4_0_1_3_5_2_2)
-* [nrfutil](https://github.com/NordicSemiconductor/pc-nrfutil)
+- [nrfutil](https://github.com/NordicSemiconductor/pc-nrfutil)

bootloader/ota-dfu-python/ble_secure_dfu_controller.py

@@ -236,7 +236,7 @@ class BleDfuControllerSecure(NrfBleDfuController):
         self._dfu_send_command(Procedures.EXECUTE)
         self._wait_and_parse_notify()
 
-        print("Init packet successfully transfered")
+        print("Init packet successfully transferred")
 
     # --------------------------------------------------------------------------
     #  Send the Firmware image to peripheral device.
@@ -319,5 +319,5 @@ class BleDfuControllerSecure(NrfBleDfuController):
         self._dfu_send_command(Procedures.EXECUTE)
         self._wait_and_parse_notify()
 
-        # If everything executed correctly, return amount of bytes transfered
+        # If everything executed correctly, return amount of bytes transferred
         return obj_max_size

bootloader/ota-dfu-python/nrf_ble_dfu_controller.py

@@ -162,7 +162,7 @@ class NrfBleDfuController(object, metaclass=ABCMeta):
         self.ble_conn.sendline('characteristics')
 
         try:
-            self.ble_conn.expect([uuid], timeout=2)
+            self.ble_conn.expect([uuid], timeout=10)
             handles = re.findall(b'.*handle: (0x....),.*char value handle: (0x....)', self.ble_conn.before)
             (handle, value_handle) = handles[-1]
         except pexpect.TIMEOUT as e:

cmake-nRF5x/CMake_nRF5x.cmake

@@ -36,9 +36,6 @@ macro(nRF5x_setup)
     set(CMAKE_OSX_SYSROOT "/")
     set(CMAKE_OSX_DEPLOYMENT_TARGET "")
 
-    # language standard/version settings
-    set(CMAKE_C_STANDARD 99)
-    set(CMAKE_CXX_STANDARD 11)
 
     # CPU specyfic settings
     if (NRF_TARGET MATCHES "nrf51")
@@ -77,21 +74,6 @@ macro(nRF5x_setup)
                 )
     endif ()
 
-    set(COMMON_FLAGS "-MP -MD -mthumb -mabi=aapcs -Wall -g3 -ffunction-sections -fdata-sections -fno-strict-aliasing -fno-builtin --short-enums ${CPU_FLAGS} -Wreturn-type -Werror=return-type")
-
-    # compiler/assambler/linker flags
-    set(CMAKE_C_FLAGS "${COMMON_FLAGS}")
-    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -O0 -g3")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3")
-    set(CMAKE_CXX_FLAGS "${COMMON_FLAGS}")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g3")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-    set(CMAKE_ASM_FLAGS "-MP -MD -std=c99 -x assembler-with-cpp")
-    set(CMAKE_EXE_LINKER_FLAGS "-mthumb -mabi=aapcs -std=gnu++98 -std=c99 -L ${NRF5_SDK_PATH}/modules/nrfx/mdk -T${NRF5_LINKER_SCRIPT} ${CPU_FLAGS} -Wl,--gc-sections --specs=nano.specs -lc -lnosys -lm")
-    # note: we must override the default cmake linker flags so that CMAKE_C_FLAGS are not added implicitly
-    set(CMAKE_C_LINK_EXECUTABLE "${CMAKE_C_COMPILER} <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
-    set(CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_C_COMPILER} <LINK_FLAGS> <OBJECTS> -lstdc++ -o <TARGET> <LINK_LIBRARIES>")
-
     # basic board definitions and drivers
     include_directories(
             "${NRF5_SDK_PATH}/components"
@@ -124,7 +106,6 @@ macro(nRF5x_setup)
       ${NRF5_SDK_PATH}/external/freertos/source/stream_buffer.c
       ${NRF5_SDK_PATH}/external/freertos/source/tasks.c
       ${NRF5_SDK_PATH}/external/freertos/source/timers.c
-      ${NRF5_SDK_PATH}/components/libraries/timer/app_timer_freertos.c
       )
 
     # freertos include
@@ -248,24 +229,6 @@ macro(nRF5x_setup)
       "${NRF5_SDK_PATH}/modules/nrfx/drivers/src/nrfx_twi.c"
       )
 
-    # adds target for erasing
-    if(USE_JLINK)
-        add_custom_target(FLASH_ERASE
-                COMMAND ${NRFJPROG} --eraseall -f ${NRF_TARGET}
-                COMMENT "erasing flashing"
-                )
-    elseif(USE_GDB_CLIENT)
-        add_custom_target(FLASH_ERASE
-          COMMAND ${GDB_CLIENT_BIN_PATH} -nx --batch -ex 'target extended-remote ${GDB_CLIENT_TARGET_REMOTE}' -ex 'monitor swdp_scan' -ex 'attach 1' -ex 'mon erase_mass'
-          COMMENT "erasing flashing"
-          )
-    elseif(USE_OPENOCD)
-        add_custom_target(FLASH_ERASE
-            COMMAND ${OPENOCD_BIN_PATH}  -f interface/stlink.cfg -c 'transport select hla_swd' -f target/nrf52.cfg -c init -c halt -c 'nrf5 mass_erase' -c reset -c shutdown
-            COMMENT "erasing flashing"
-            )
-    endif()
-
     if(${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Darwin")
         set(TERMINAL "open")
     elseif(${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Windows")
@@ -274,16 +237,6 @@ macro(nRF5x_setup)
         set(TERMINAL "gnome-terminal")
     endif()
 
-    if(USE_JLINK)
-        add_custom_target(START_JLINK
-                COMMAND ${TERMINAL} "${DIR_OF_nRF5x_CMAKE}/runJLinkGDBServer-${NRF_TARGET}"
-                COMMAND ${TERMINAL} "${DIR_OF_nRF5x_CMAKE}/runJLinkExe-${NRF_TARGET}"
-                COMMAND sleep 2s
-                COMMAND ${TERMINAL} "${DIR_OF_nRF5x_CMAKE}/runJLinkRTTClient"
-                COMMENT "started JLink commands"
-                )
-    endif()
-
 endmacro(nRF5x_setup)
 
 # adds a target for comiling and flashing an executable
@@ -301,29 +254,6 @@ macro(nRF5x_addExecutable EXECUTABLE_NAME SOURCE_FILES)
             COMMAND ${CMAKE_OBJCOPY} -O ihex ${EXECUTABLE_NAME}.out "${EXECUTABLE_NAME}.hex"
             COMMENT "post build steps for ${EXECUTABLE_NAME}")
 
-    # custom target for flashing the board
-    if(USE_JLINK)
-        add_custom_target("FLASH_${EXECUTABLE_NAME}"
-                DEPENDS ${EXECUTABLE_NAME}
-                COMMAND ${NRFJPROG} --program ${EXECUTABLE_NAME}.hex -f ${NRF_TARGET} --sectorerase
-                COMMAND sleep 0.5s
-                COMMAND ${NRFJPROG} --reset -f ${NRF_TARGET}
-                COMMENT "flashing ${EXECUTABLE_NAME}.hex"
-                )
-    elseif(USE_GDB_CLIENT)
-        add_custom_target("FLASH_${EXECUTABLE_NAME}"
-          DEPENDS ${EXECUTABLE_NAME}
-          COMMAND ${GDB_CLIENT_BIN_PATH} -nx --batch -ex 'target extended-remote ${GDB_CLIENT_TARGET_REMOTE}' -ex 'monitor swdp_scan' -ex 'attach 1' -ex 'load' -ex 'kill'  ${EXECUTABLE_NAME}.hex
-          COMMENT "flashing ${EXECUTABLE_NAME}.hex"
-          )
-    elseif(USE_OPENOCD)
-        add_custom_target("FLASH_${EXECUTABLE_NAME}"
-                DEPENDS ${EXECUTABLE_NAME}
-                COMMAND ${OPENOCD_BIN_PATH} -c "tcl_port disabled" -c "gdb_port 3333" -c "telnet_port 4444" -f interface/stlink.cfg -c 'transport select hla_swd' -f target/nrf52.cfg -c "program \"${EXECUTABLE_NAME}.hex\""  -c reset -c shutdown
-                COMMENT "flashing ${EXECUTABLE_NAME}.hex"
-        )
-    endif()
-
 endmacro()
 
 # adds app-level scheduler library
@@ -353,7 +283,6 @@ endmacro(nRF5x_addAppFIFO)
 # adds app-level Timer libraries
 macro(nRF5x_addAppTimer)
     list(APPEND SDK_SOURCE_FILES
-            "${NRF5_SDK_PATH}/components/libraries/timer/app_timer.c"
             )
 endmacro(nRF5x_addAppTimer)
 

cmake-nRF5x/readme.md

@@ -7,7 +7,7 @@ Cmake script for projects targeting Nordic Semiconductor nRF5x series devices us
 The script makes use of the following tools:
 
 - nRF5x SDK by Nordic Semiconductor - SoC specific drivers and libraries (also includes a lot of examples)
-- JLink by Segger - interface software for the JLink familiy of programmers
+- JLink by Segger - interface software for the JLink family of programmers
 - nrfjprog by Nordic Semiconductor - Wrapper utility around JLink
 - arm-non-eabi-gcc by ARM and the GCC Team - compiler toolchain for embedded (= bare metal) ARM chips
 
@@ -15,11 +15,11 @@ The script makes use of the following tools:
 
 1. Download this repo (or add as submodule) to the directory `cmake-nRF5x` in your project
 
-1. Search the SDK `example` directory for a `sdk_config.h`, `main.c` and a linker script (normally named `<project_name>_gcc_<chip familly>.ld`) that fits your chip and project needs.
+1. Search the SDK `example` directory for a `sdk_config.h`, `main.c` and a linker script (normally named `<project_name>_gcc_<chip family>.ld`) that fits your chip and project needs.
 
 1. Copy the `sdk_config.h` and the project `main.c` into a new directory `src`. Modify them as required for your project.
 
-1. Copy the linker script into the root of your project. Rename it to just `gcc_<chip familly>.ld` For example:
+1. Copy the linker script into the root of your project. Rename it to just `gcc_<chip family>.ld` For example:
 	
 	```
 	gcc_nrf51.ld
@@ -98,7 +98,7 @@ The script makes use of the following tools:
 
 After setup you can use cmake as usual:
 
-1. Generate the actual build files (out-of-source builds are strongly recomended):
+1. Generate the actual build files (out-of-source builds are strongly recommended):
 
 	```commandline
 	cmake -H. -B"cmake-build" -G "Unix Makefiles"

doc/BLEFS.md

@@ -0,0 +1,168 @@
+# BLE FS
+
+---
+
+The BLE FS protocol in InfiniTime is mostly Adafruit's BLE file transfer protocol, as described in [adafruit/Adafruit_CircuitPython_BLE_File_Transfer](https://github.com/adafruit/Adafruit_CircuitPython_BLE_File_Transfer). There are some deviations, such as the status codes. These will be described later in the document.
+
+---
+
+## UUIDs
+
+There are two relevant UUIDs in this protocol: the version characteristic, and the raw transfer characteristic.
+
+### Version
+
+UUID: `adaf0100-4669-6c65-5472-616e73666572`
+
+The version characteristic returns the version of the protocol to which the sender adheres. It returns a single unsigned 32-bit integer. The latest version at the time of writing this is 4.
+
+### Transfer
+
+UUID: `adaf0200-4669-6c65-5472-616e73666572`
+
+The transfer characteristic is responsible for all the data transfer between the client and the watch. It supports write and notify. Writing a packet on the characteristic results in a response via notify.
+
+---
+
+## Usage
+
+The separator for paths is `/`, and absolute paths must start with `/`.
+
+All of the following commands and responses are transferred via the transfer characteristic
+
+### Read file
+
+To begin reading a file, a header must first be sent. The header packet should be formatted like so:
+
+- Command (single byte): `0x10`
+- 1 byte of padding
+- Unsigned 16-bit integer encoding the length of the file path.
+- Unsigned 32-bit integer encoding the location at which to start reading the first chunk.
+- Unsigned 32-bit integer encoding the amount of bytes to be read.
+- File path: UTF-8 encoded string that is _not_ null terminated.
+
+To continue reading the file after this initial packet, the following packet should be sent until all the data has been received. No close command is required after the data has been received.
+
+- Command (single byte): `0x12`
+- Status: `0x01`
+- 2 bytes of padding
+- Unsigned 32-bit integer encoding the location at which to start reading the next chunk.
+- Unsigned 32-bit integer encoding the amount of bytes to be read. This may be different from the size in the header.
+
+Both of these commands receive the following response:
+
+- Command (single byte): `0x11`
+- Status (signed 8-bit integer)
+- 2 bytes of padding
+- Unsigned 32-bit integer encoding the offset of this chunk
+- Unsigned 32-bit integer encoding the total size of the file
+- Unsigned 32-bit integer encoding the amount of data in the current chunk
+- Contents of the current chunk
+
+### Write file
+
+To begin writing to a file, a header must first be sent. The header packet should be formatted like so:
+
+- Command (single byte): `0x20`
+- 1 byte of padding
+- Unsigned 16-bit integer encoding the length of the file path.
+- Unsigned 32-bit integer encoding the location at which to start writing to the file.
+- Unsigned 64-bit integer encoding the unix timestamp with nanosecond resolution. This will be used as the modification time. At the time of writing, this is not implemented in InfiniTime, but may be in the future.
+- Unsigned 32-bit integer encoding the size of the file that will be sent
+- File path: UTF-8 encoded string that is _not_ null terminated.
+
+To continue reading the file after this initial packet, the following packet should be sent until all the data has been sent and a response had been received with 0 free space. No close command is required after the data has been received.
+
+- Command (single byte): `0x22`
+- Status: `0x01`
+- 2 bytes of padding.
+- Unsigned 32-bit integer encoding the location at which to write the next chunk.
+- Unsigned 32-bit integer encoding the amount of bytes to be written.
+- Data
+
+Both of these commands receive the following response:
+
+- Command (single byte): `0x21`
+- Status (signed 8-bit integer)
+- 2 bytes of padding
+- Unsigned 32-bit integer encoding the current offset in the file
+- Unsigned 64-bit integer encoding the unix timestamp with nanosecond resolution. This will be used as the modification time. At the time of writing, this is not implemented in InfiniTime, but may be in the future.
+- Unsigned 32-bit integer encoding the amount of data the client can send until the file is full.
+
+### Delete file
+
+- Command (single byte): `0x30`
+- 1 byte of padding
+- Unsigned 16-bit integer encoding the length of the file path.
+- File path: UTF-8 encoded string that is _not_ null terminated.
+
+The response to this packet will be as follows:
+
+- Command (single byte): `0x31`
+- Status (signed 8-bit integer)
+
+### Make directory
+
+- Command (single byte): `0x40`
+- 1 byte of padding
+- Unsigned 16-bit integer encoding the length of the file path.
+- 4 bytes of padding
+- Unsigned 64-bit integer encoding the unix timestamp with nanosecond resolution.
+- File path: UTF-8 encoded string that is _not_ null terminated.
+
+The response to this packet will be as follows:
+
+- Command (single byte): `0x41`
+- Status (signed 8-bit integer)
+- 6 bytes of padding
+- Unsigned 64-bit integer encoding the unix timestamp with nanosecond resolution.
+
+### List directory
+
+Paths returned by this command are relative to the path given in the request
+
+- Command (single byte): `0x50`
+- 1 byte of padding
+- Unsigned 16-bit integer encoding the length of the file path.
+- File path: UTF-8 encoded string that is _not_ null terminated.
+
+The response to this packet will be as follows. Responses will be sent until the final entry, which will have entry number == total entries
+
+- Command (single byte): `0x51`
+- Status (signed 8-bit integer)
+- Unsigned 16-bit integer encoding the length of the file path.
+- Unsigned 32-bit integer encoding the entry number
+- Unsigned 32-bit integer encoding the total amount of entries
+- Flags: unsigned 32-bit integer
+  - Bit 0: Set when entry is a directory
+  - Bits 1-7: Reserved
+- Unsigned 64-bit integer encoding the unix timestamp of the modification time with nanosecond resolution
+- Unsigned 32-bit integer encoding the size of the file
+- Path: UTF-8 encoded string that is _not_ null terminated.
+
+### Move file or directory
+
+- Command (single byte): `0x60`
+- 1 byte of padding
+- Unsigned 16-bit integer encoding the length of the old path
+- Unsigned 16-bit integer encoding the length of the new path
+- Old path: UTF-8 encoded string that is _not_ null terminated.
+- 1 byte of padding
+- Newpath: UTF-8 encoded string that is _not_ null terminated.
+
+The response to this packet will be as follows:
+
+- Command (single byte): `0x61`
+- Status (signed 8-bit integer)
+
+---
+
+## Deviations
+
+This section describes the differences between Adafruit's spec and InfiniTime's implementation.
+
+### Status codes
+
+The status codes returned by InfiniTime are a signed 8-bit integer, rather than an unsigned one as described in the spec.
+
+InfiniTime uses LittleFS error codes rather than the ones described in the spec. Those codes can be found in [lfs.h](https://github.com/littlefs-project/littlefs/blob/master/lfs.h#L70).

doc/ExternalResources.md

@@ -0,0 +1,70 @@
+# External resources
+Since InfiniTime 1.11 apps and watchfaces can benefit from the external flash memory to store images and fonts. 
+This external memory is a lot bigger (4MB) than the internal memory that contains the firmware (512KB).
+
+This page describes how the resources are integrated in InfiniTime from a developer perspective. [This page](gettingStarted/updating-software.md) explains how to install and update the external resources using companion apps.
+
+## Resources generation
+
+Resources are generated at build time via the [CMake target `Generate  Resources`](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/src/resources/CMakeLists.txt#L19). 
+It runs 3 Python scripts that respectively convert the fonts to binary format, convert the images to binary format and package everything in a .zip file.
+
+The resulting file `infinitime-resources-x.y.z.zip` contains the images and fonts converted in binary `.bin` files and a JSON file `resources.json`. 
+
+Companion apps use this file to upload the files to the watch. 
+
+```
+{
+    "resources": [
+        {
+            "filename": "lv_font_dots_40.bin",
+            "path": "/fonts/lv_font_dots_40.bin"
+        }
+    ],
+    "obsolete_files": [
+        {
+            "path": "/example-of-obsolete-file.bin",
+            "since": "1.11.0"
+        }
+    ]
+}
+```
+
+The resource JSON file describes an array of resources and an array of obsolete files : 
+
+- `resources` : a resource is a file that must be flashed to the watch
+  - `filename`: name of the resources in the zip file.
+  - `path` : file path and name where the file must be flashed in the watch FS.
+
+- `obsolete_files` : files that are not needed anymore in the memory of the watch that can be deleted during the update procedure.
+  - `path` : path of the file in the watch FS
+  - `since` : version of InfiniTime that made this file obsolete.
+
+## Resources update procedure
+
+The update procedure is based on the [BLE FS API](BLEFS.md). The companion app simply write the binary files to the watch FS using information from the file `resources.json`.
+
+## Working with external resources in the code
+
+Load a picture from the external resources:
+
+```
+lv_obj_t* logo = lv_img_create(lv_scr_act(), nullptr);
+lv_img_set_src(logo, "F:/images/logo.bin");
+```
+
+Load a font from the external resources: you first need to check that the file actually exists. LVGL will crash when trying to open a font that doesn't exist.
+
+```
+lv_font_t* font_teko = nullptr;
+if (filesystem.FileOpen(&f, "/fonts/font.bin", LFS_O_RDONLY) >= 0) {
+    filesystem.FileClose(&f);
+    font_teko = lv_font_load("F:/fonts/font.bin");
+}
+
+if(font != nullptr) {
+    lv_obj_set_style_local_text_font(label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font);
+}
+
+```
+

doc/InfiniTimeVision.md

@@ -0,0 +1,33 @@
+# InfiniTime Vision
+
+The purpose of this document is to steer efforts towards a common goal, and as such should be taken into consideration with all developments.
+
+## InfiniTime
+
+InfiniTime is a community-built smartwatch firmware.
+It offers freedom and privacy advantages unavailable to users of proprietary wearable technology.
+
+InfiniTime is not to be used for medical or other health tracking purposes.
+
+## Core Principles
+
+- Keep It Simple
+- Reliability
+- Battery efficiency
+- Easy and simple navigation
+- Behaviour should be predictable and easy to understand
+- Prefer solid default experience over customization
+- Personalization is achieved through custom watch faces.
+  More options may be available through a companion app.
+- Use standard protocols and methods
+
+## Long term vision
+
+The perfect version of InfiniTime would include:
+
+- Capability to sideload apps and watch faces
+- Only a minimal feature set in the flashed firmware.
+  Users would add the features they want.
+- Ports to other devices
+- Translations
+- Great user documentation

doc/MemoryAnalysis.md

@@ -1,7 +1,296 @@
 # Memory analysis
+
+The PineTime is equipped with the following memories:
+
+- The internal RAM : **64KB**
+- The internal Flash : **512KB**
+- The external (SPI) Flash : **4MB**
+
+Note that the NRF52832 cannot execute code stored in the external flash : we need to store the whole firmware in the internal flash memory, and use the external one to store graphicals assets, fonts...
+
+This document describes how the RAM and Flash memories are used in InfiniTime and how to analyze and monitor their usage. It was written in the context of [this memory analysis effort](https://github.com/InfiniTimeOrg/InfiniTime/issues/313).
+
+## Code sections
+
+A binary is composed of multiple sections. Most of the time, these sections are : .text, .rodata, .data and .bss but more sections can be defined in the linker script.
+
+Here is a small description of these sections and where they end up in memory:
+
+- **TEXT** = code (FLASH)
+- **RODATA** = constants (FLASH)
+- **DATA** = initialized variables (FLASH + RAM)
+- **BSS** = uninitialized variables (RAM)
+
+## Internal FLASH
+
+The internal flash memory stores the whole firmware: code, variable that are not default-initialized, constants...
+
+The content of the flash memory can be easily analyzed thanks to the MAP file generated by the compiler. This file lists all the symbols from the program along with their size and location (section and addresses) in RAM and FLASH.
+
+![Map file](./memoryAnalysis/mapfile.png)
+
+As you can see on the picture above, this file contains a lot of information and is not easily readable by a human being. Fortunately, you can easily find tools that parse and display the content of the MAP file in a more understandable way.
+
+In this analysis, I used [Linkermapviz](https://github.com/PromyLOPh/linkermapviz).
+
+### Linkermapviz
+
+[Linkermapviz](https://github.com/PromyLOPh/linkermapviz) parses the MAP file and displays its content on an HTML page as a graphic:
+
+![linkermapviz](./memoryAnalysis/linkermapviz.png)
+
+Using this tool, you can compare the relative size of symbols. This can be helpful for checking memory usage at a glance.
+
+Also, as Linkermapviz is written in Python, you can easily modify and adapt it to your firmware or export data in another format. For example, [here it is modified to parse the contents of the MAP file and export it in a CSV file](https://github.com/InfiniTimeOrg/InfiniTime/issues/313#issuecomment-842338620). This file could later be opened in LibreOffice Calc where sort/filter functionality could be used to search for specific symbols in specific files...
+
+### Puncover
+
+[Puncover](https://github.com/HBehrens/puncover) is another useful tools that analyses the binary file generated by the compiler (the .out file that contains all debug information). It provides valuable information about the symbols (data and code): name, position, size, max stack of each functions, callers, callees...
+![Puncover](./memoryAnalysis/puncover.png)
+
+Puncover is really easy to install:
+
+- Clone the repo and cd into the cloned directory
+- Setup a venv
+  - `python -m virtualenv venv`
+  - `source venv/bin/activate`
+- Install : `pip install .`
+- Run : `puncover --gcc_tools_base=/path/to/gcc-arm-none-eabi-10.3-2021.10/bin/arm-none-eabi- --elf_file /path/to/build/directory/src/pinetime-app-1.1.0.out --src_root /path/to/sources --build_dir /path/to/build/directory`
+  - Replace
+    - `/path/to/gcc-arm-none-eabi-10.3-2021.10/bin` with the path to your gcc-arm-none-eabi toolchain
+    - `/path/to/build/directory/src/pinetime-app-1.1.0.out` with the path to the binary generated by GCC (.out file)
+    - `/path/to/sources` with the path to the root folder of the sources (checkout directory)
+    - `/path/to/build/directory` with the path to the build directory
+- Launch a browser at http://localhost:5000/
+
+### Analysis
+
+Using the MAP file and tools, we can easily see what symbols are using most of the flash memory. In this case, unsurprisingly, fonts and graphics are the largest use of flash memory.
+
+![Puncover](./memoryAnalysis/puncover-all-symbols.png)
+
+This way, you can easily check what needs to be optimized. We should find a way to store big static data (like fonts and graphics) in the external flash memory, for example.
+
+It's always a good idea to check the flash memory space when working on the project. This way, you can easily check that your developments are using a reasonable amount of space.
+
+### Links
+
+- Analysis with linkermapviz : https://github.com/InfiniTimeOrg/InfiniTime/issues/313#issuecomment-842338620
+- Analysis with Puncover : https://github.com/InfiniTimeOrg/InfiniTime/issues/313#issuecomment-847311392
+
+## RAM
+
+RAM memory contains all the data that can be modified at run-time: variables, stack, heap...
+
+### Data
+
+RAM memory can be *statically* allocated, meaning that the size and position of the data are known at compile-time:
+
+You can easily analyze the memory used by variables declared in the global scope using the MAP. You'll find them in the .BSS or .DATA sections. Linkermapviz and Puncover can be used to analyze their memory usage.
+
+Variables declared in the scope of a function will be allocated on the stack. It means that the stack usage will vary according to the state of the program, and cannot be easily analyzed at compile time.
+
+```
+uint8_t buffer[1024]
+
+int main() {
+ int a;
+}
+```
+
+#### Analysis
+
+In Infinitime 1.1, the biggest buffers are the buffers allocated for LVGL (14KB) and the one for FreeRTOS (16KB). Nimble also allocated 9KB of RAM.
+
+### Stack
+
+The stack will be used for everything except tasks, which have their own stack allocated by FreeRTOS. The stack is 8192B and is allocated in the [linker script](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/nrf_common.ld#L148).
+An easy way to monitor its usage is by filling the section with a known pattern at boot time, then use the firmware and dump the memory. You can then check the maximum stack usage by checking the address from the beginning of the stack that were overwritten.
+
+#### Fill the stack section by a known pattern:
+
+Edit <NRFSDK>/modules/nrfx/mdk/gcc_startup_nrf52.S and add the following code after the copy of the data from read only memory to RAM at around line 243:
+
+```
+/* Loop to copy data from read only memory to RAM.
+ * The ranges of copy from/to are specified by following symbols:
+ *      __etext: LMA of start of the section to copy from. Usually end of text
+ *      __data_start__: VMA of start of the section to copy to.
+ *      __bss_start__: VMA of end of the section to copy to. Normally __data_end__ is used, but by using __bss_start__
+ *                    the user can add their own initialized data section before BSS section with the INTERT AFTER command.
+ *
+ * All addresses must be aligned to 4 bytes boundary.
+ */
+    ldr r1, =__etext
+    ldr r2, =__data_start__
+    ldr r3, =__bss_start__
+
+    subs r3, r3, r2
+    ble .L_loop1_done
+
+.L_loop1:
+    subs r3, r3, #4
+    ldr r0, [r1,r3]
+    str r0, [r2,r3]
+    bgt .L_loop1
+
+.L_loop1_done:
+
+
+/* Add this code to fill the stack section with 0xFFEEDDBB */
+ldr     r0, =__StackLimit
+    ldr     r1, =8192
+ldr     r2, =0xFFEEDDBB
+.L_fill:
+str     r2, [r0]
+adds    r0, 4
+subs    r1, 4
+bne     .L_fill
+/* -- */
+```
+
+#### Dump RAM memory and check usage
+
+Dumping the content of the ram is easy using JLink debugger and `nrfjprog`:
+
+```
+nrfjprog --readram ram.bin
+```
+
+You can then display the file using objdump:
+
+```
+hexdump ram.bin -v  | less
+```
+
+The stack is positioned at the end of the RAM -> 0xFFFF. Its size is 8192 bytes, so the end of the stack is at 0xE000.
+On the following dump, the maximum stack usage is 520 bytes (0xFFFF - 0xFDF8):
+
+```
+000fdb0 ddbb ffee ddbb ffee ddbb ffee ddbb ffee
+000fdc0 ddbb ffee ddbb ffee ddbb ffee ddbb ffee
+000fdd0 ddbb ffee ddbb ffee ddbb ffee ddbb ffee
+000fde0 ddbb ffee ddbb ffee ddbb ffee ddbb ffee
+000fdf0 ddbb ffee ddbb ffee ffff ffff c24b 0003
+000fe00 ffff ffff ffff ffff ffff ffff 0000 0000
+000fe10 0018 0000 0000 0000 0000 0000 fe58 2000
+000fe20 0000 0000 0000 00ff ddbb 00ff 0018 0000
+000fe30 929c 2000 0000 0000 0018 0000 0000 0000
+000fe40 92c4 2000 0458 2000 0000 0000 80e7 0003
+000fe50 0000 0000 8cd9 0003 ddbb ffee ddbb ffee
+000fe60 00dc 2000 92c4 2000 0005 0000 929c 2000
+000fe70 007f 0000 feb0 2000 92c4 2000 feb8 2000
+000fe80 ddbb ffee 0005 0000 929c 2000 0000 0000
+000fe90 aca0 2000 0000 0000 0028 0000 418b 0005
+000fea0 02f4 2000 001f 0000 0000 0000 0013 0000
+000feb0 b5a8 2000 2199 0005 b5a8 2000 2201 0005
+000fec0 b5a8 2000 001e 0000 0000 0000 0013 0000
+000fed0 b5b0 2000 0fe0 0006 b5a8 2000 0000 0000
+000fee0 0013 0000 2319 0005 0013 0000 0000 0000
+000fef0 0000 0000 3b1c 2000 3b1c 2000 d0e3 0000
+000ff00 4b70 2000 54ac 2000 4b70 2000 ffff ffff
+000ff10 0000 0000 1379 0003 6578 2000 0d75 0003
+000ff20 6578 2000 ffff ffff 0000 0000 1379 0003
+000ff30 000c 0000 cfeb 0002 39a1 2000 a824 2000
+000ff40 0015 0000 cfeb 0002 39a1 2000 a824 2000
+000ff50 39a1 2000 0015 0000 001b 0000 b4b9 0002
+000ff60 0000 0000 a9f4 2000 4b70 2000 0d75 0003
+000ff70 4b70 2000 ffff ffff 0000 0000 1379 0003
+000ff80 ed00 e000 a820 2000 1000 4001 7fc0 2000
+000ff90 7f64 2000 75a7 0001 a884 2000 7b04 2000
+000ffa0 a8c0 2000 0000 0000 0000 0000 0000 0000
+000ffb0 7fc0 2000 7f64 2000 8024 2000 a5a5 a5a5
+000ffc0 ed00 e000 3fd5 0001 0000 0000 72c0 2000
+000ffd0 0000 0000 72e4 2000 3f65 0001 7f64 2000
+000ffe0 0000 2001 0000 0000 ef30 e000 0010 0000
+000fff0 7fc0 2000 4217 0001 3f0a 0001 0000 6100
+```
+
+#### Analysis
+
+According to my experimentations, we don't use the stack that much, and 8192 bytes is probably way too big for InfiniTime!
+
+#### Links
+
+- https://github.com/InfiniTimeOrg/InfiniTime/issues/313#issuecomment-851035070
+
+### Heap
+
+The heap is declared in the [linker script](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/nrf_common.ld#L136) and its current size is 8192 bytes. The heap is used for dynamic memory allocation(`malloc()`, `new`...).
+
+Heap monitoring is not easy, but it seems that we can use the following code to know the current usage of the heap:
+
+```
+auto m = mallinfo();
+NRF_LOG_INFO("heap : %d", m.uordblks);
+```
+
+#### Analysis
+
+According to my experimentation, InfiniTime uses ~6000bytes of heap most of the time. Except when the Navigation app is launched, where the heap usage exceeds 9500 bytes (meaning that the heap overflows and could potentially corrupt the stack). This is a bug that should be fixed in #362.
+
+To know exactly what's consuming heap memory, you can `wrap` functions like `malloc()` into your own functions. In this wrapper, you can add logging code or put breakpoints:
+
+- Add ` -Wl,-wrap,malloc` to the cmake variable `LINK_FLAGS` of the target you want to debug (pinetime-app, most probably)
+- Add the following code in `main.cpp`
+
+```
+extern "C" {
+void *__real_malloc (size_t);
+void* __wrap_malloc(size_t size) {
+  return __real_malloc(size);
+}
+}
+```
+
+Now, your function `__wrap_malloc()` will be called instead of `malloc()`. You can call the actual malloc from the stdlib by calling `__real_malloc()`.
+
+Using this technique, I was able to trace all malloc calls at boot (boot -> digital watch face):
+
+- system task = 3464 bytes (SystemTask could potentially be declared as a global variable to avoid heap allocation here)
+- string music = 31 (maybe we should not use std::string when not needed, as it does heap allocation)
+- ble_att_svr_start = 1720
+- ble gatts start = 40 + 88
+- ble ll task = 24
+- display app = 104
+- digital clock = 96 + 152
+- hr task = 304
+
+#### Links
+
+- https://github.com/InfiniTimeOrg/InfiniTime/issues/313#issuecomment-851035625
+- https://www.embedded.com/mastering-stack-and-heap-for-system-reliability-part-1-calculating-stack-size/
+- https://www.embedded.com/mastering-stack-and-heap-for-system-reliability-part-2-properly-allocating-stacks/
+- https://www.embedded.com/mastering-stack-and-heap-for-system-reliability-part-3-avoiding-heap-errors/
+
+## LVGL
+
+I did a deep analysis of the usage of the buffer dedicated to lvgl (managed by lv_mem).
+This buffer is used by lvgl to allocated memory for drivers (display/touch), screens, themes, and all widgets created by the apps.
+
+The usage of this buffer can be monitored using this code :
+
+```
+lv_mem_monitor_t mon;
+lv_mem_monitor(&mon);
+NRF_LOG_INFO("\t Free %d / %d -- max %d", mon.free_size, mon.total_size, mon.max_used);
+```
+
+The most interesting metric is `mon.max_used` which specifies the maximum number of bytes used from this buffer since the initialization of lvgl.
+According to my measurements, initializing the theme, display/touch driver and screens cost **4752** bytes!
+Then, initializing the digital clock face costs **1541 bytes**.
+For example a simple lv_label needs **~140 bytes** of memory.
+
+I tried to monitor this max value while going through all the apps of InfiniTime 1.1 : the max value I've seen is **5660 bytes**. It means that we could probably **reduce the size of the buffer from 14KB to 6 - 10 KB** (we have to take the fragmentation of the memory into account).
+
+### Links
+
+- https://github.com/InfiniTimeOrg/InfiniTime/issues/313#issuecomment-850890064
+
 ## FreeRTOS heap and task stack
+
 FreeRTOS statically allocate its own heap buffer in a global variable named `ucHeap`. This is an array of *uint8_t*. Its size is specified by the definition `configTOTAL_HEAP_SIZE` in *FreeRTOSConfig.h*
-FreeRTOS uses this buffer to allocate memory for tasks stack and all the RTOS object created during runtime (timers, mutexes,...).
+FreeRTOS uses this buffer to allocate memory for tasks stack and all the RTOS object created during runtime (timers, mutexes...).
 
 The function `xPortGetFreeHeapSize()` returns the amount of memory available in this *ucHeap* buffer. If this value reaches 0, FreeRTOS runs out of memory.
 
@@ -9,7 +298,6 @@ The function `xPortGetFreeHeapSize()` returns the amount of memory available in
 NRF_LOG_INFO("Free heap : %d", xPortGetFreeHeapSize());
 ```
 
-
 The function `uxTaskGetSystemState()` fetches some information about the running tasks like its name and the minimum amount of stack space that has remained for the task since the task was created:
 
 ```
@@ -18,61 +306,3 @@ auto nb = uxTaskGetSystemState(tasksStatus, 10, NULL);
 for (int i = 0; i < nb; i++) {
   NRF_LOG_INFO("Task [%s] - %d", tasksStatus[i].pcTaskName, tasksStatus[i].usStackHighWaterMark);
 ```
-
-
-## Global heap
-Heap is used for **dynamic memory allocation (malloc() / new)**. NRF SDK defaults the heap size to 8KB. The size of the heap can be specified by defining `__HEAP_SIZE=8192` in *src/CMakeLists.txt*:
-
-```
-add_definitions(-D__HEAP_SIZE=8192)
-``` 
-
-You can trace the dynamic memory allocation by using the flag `--wrap` of the linker. When this flag is enabled, the linker will replace the calls to a specific function by a call to __wrap_the_function(). For example, if you specify `-Wl,-wrap,malloc` in the linker flags, the linker will replace all calls to `void* malloc(size_t)` by calls to `void* __wrap_malloc(size_t)`. This is a function you'll have to define in your code. In this function, you can call `__real_malloc()` to call the actual `malloc()' function.
-
-This technic allows you to wrap all calls to malloc() with you own code.
-
-In *src/CMakeLists.txt*:
-
-```
-set_target_properties(${EXECUTABLE_NAME} PROPERTIES
-        ...
-        LINK_FLAGS "-Wl,-wrap,malloc ..."
-        ...
-        )
-
-```
-
-In *main.cpp*:
-
-```
-uint32_t totalMalloc = 0;
-extern "C" {
-    extern void* __real_malloc(size_t s);
-    void *__wrap_malloc(size_t s) {
-      totalMalloc += s;
-      return __real_malloc(s);
-    }
-}
-```
-This function sums all the memory that is allocated during the runtime. You can monitor or log this value. You can also place breakpoints in this function to determine where the dynamic memory allocation occurs in your code.
-
-
-# Global stack
-The stack is used to allocate memory used by functions : **parameters and local variables**. NRF SDK defaults the heap size to 8KB. The size of the heap can be specified by defining `__STACK_SIZE=8192` in *src/CMakeLists.txt*:
-                                                                                             
-```
-add_definitions(-D__STACK_SIZE=8192)
-``` 
-
-*NOTE*: FreeRTOS uses its own stack buffer. Thus, the global stack is only used for main() and IRQ handlers. It should be possible to reduce its size to a much lower value.
-
-**NOTE**: [?] How to track the global stack usage? 
-
-#LittleVGL buffer
-*TODO*
-
-#NimBLE buffers
-*TODO*
-
-#Tools
- - https://github.com/eliotstock/memory : display the memory usage (FLASH/RAM) using the .map file from GCC.

doc/MotionService.md

@@ -0,0 +1,25 @@
+# Motion Service
+
+## Introduction
+
+The motion service exposes step count and raw X/Y/Z motion value as READ and NOTIFY characteristics.
+
+## Service
+
+The service UUID is **00030000-78fc-48fe-8e23-433b3a1942d0**
+
+## Characteristics
+
+### Step count (UUID 00030001-78fc-48fe-8e23-433b3a1942d0)
+
+The current number of steps represented as a single `uint32_t` (4 bytes) value.
+
+### Raw motion values (UUID 00030002-78fc-48fe-8e23-433b3a1942d0)
+
+The current raw motion values. This is a 3 `int16_t` array:
+
+- [0] : X
+- [1] : Y
+- [2] : Z
+
+The three motion values are in units of "binary milli-g", where 1g is represented by a value of 1024.

doc/NavigationService.md

@@ -0,0 +1,127 @@
+# Navigation Service
+
+## Introduction
+
+The navigation ble service provides 4 characteristics to allow the watch to display navigation instructions from a companion application. This service is intended to be used when performing some outdoor activities, for example running or cycling.
+
+The 4 characteristics are:
+flag (string) - Upcoming icon name
+narrative (string) - Textual description of instruction
+manDist (string) - Manouvre Distance, the distance to the upcoming change
+progress (uint8) - Percent complete of total route, value 0-100
+
+## Service
+
+The service UUID is 00010000-78fc-48fe-8e23-433b3a1942d0
+
+## Characteristics
+
+## Flags (UUID 00010001-78fc-48fe-8e23-433b3a1942d0)
+
+All included icons are from pure-maps, which provides the actual routing from the client. The icon names ultimately come from the mapbox project "direction-icons", See https://github.com/rinigus/pure-maps/tree/master/qml/icons/navigation See the end of this document for the full list of supported icon names.
+
+## Narrative (UUID 00010002-78fc-48fe-8e23-433b3a1942d0)
+
+This is a client supplied string describing the upcoming instruction such as "At the roundabout take the first exit".
+
+## Man Dist (UUID 00010003-78fc-48fe-8e23-433b3a1942d0)
+
+This is a short string describing the distance to the upcoming instruction such as "50 m".
+
+## Progress (UUID 00010004-78fc-48fe-8e23-433b3a1942d0)
+
+The percent complete in a uint8. The watch displays this as an overall progress in a progress bar.
+
+## Full icon list
+
+- arrive
+- arrive-left
+- arrive-right
+- arrive-straight
+- close
+- continue
+- continue-left
+- continue-right
+- continue-slight-left
+- continue-slight-right
+- continue-straight
+- continue-uturn
+- depart
+- depart-left
+- depart-right
+- depart-straight
+- end-of-road-left
+- end-of-road-right
+- ferry
+- flag
+- fork
+- fork-left
+- fork-right
+- fork-slight-left
+- fork-slight-right
+- fork-straight
+- invalid
+- invalid-left
+- invalid-right
+- invalid-slight-left
+- invalid-slight-right
+- invalid-straight
+- invalid-uturn
+- merge-left
+- merge-right
+- merge-slight-left
+- merge-slight-right
+- merge-straight
+- new-name-left
+- new-name-right
+- new-name-sharp-left
+- new-name-sharp-right
+- new-name-slight-left
+- new-name-slight-right
+- new-name-straight
+- notification-left
+- notification-right
+- notification-sharp-left
+- notification-sharp-right
+- notification-slight-left
+- notification-slight-right
+- notification-straight
+- off-ramp-left
+- off-ramp-right
+- off-ramp-sharp-left
+- off-ramp-sharp-right
+- off-ramp-slight-left
+- off-ramp-slight-right
+- off-ramp-straight
+- on-ramp-left
+- on-ramp-right
+- on-ramp-sharp-left
+- on-ramp-sharp-right
+- on-ramp-slight-left
+- on-ramp-slight-right
+- on-ramp-straight
+- rotary
+- rotary-left
+- rotary-right
+- rotary-sharp-left
+- rotary-sharp-right
+- rotary-slight-left
+- rotary-slight-right
+- rotary-straight
+- roundabout
+- roundabout-left
+- roundabout-right
+- roundabout-sharp-left
+- roundabout-sharp-right
+- roundabout-slight-left
+- roundabout-slight-right
+- roundabout-straight
+- turn-left
+- turn-right
+- turn-sharp-left
+- turn-sharp-right
+- turn-slight-left
+- turn-slight-right
+- turn-stright
+- updown
+- uturn

doc/PinetimeStubWithNrf52DK.md

@@ -1,33 +1,36 @@
 # Build a stub for PineTime using NRF52-DK
-[NRF52-DK](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52-DK) is the official developpment kit for NRF52832 SoC from Nordic Semiconductor.
 
-It can be very useful for PineTime developpment:
+[NRF52-DK](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52-DK) is the official development kit for the NRF52832 SoC from Nordic Semiconductor used in the PineTime.
- * You can use it embedded JLink SWD programmer/debugger to program and debug you code on the PineTime
- * As it's based on the same SoC than the PineTime, you can program it to actually run the same code than the PineTime. 
 
-This page is about the 2nd point : we will build a stub that will allow us to run the same code than the one you could run on the PineTime. This will allow you to work more easily if you don't have a PineTime dev kit around, if you don't want to modify your dev kit for SWD programming, or if you want to use some feature from the DK (like power measurement).
+This development kit can be very useful for PineTime development:
+
+- You can use its embedded JLink SWD programmer/debugger to program and debug your code on the PineTime
+- As it's based on the same SoC than the PineTime, you can program it to actually run the same code as the PineTime.
+
+This page is about the 2nd point. We will build a stub that will allow us to run the same code you can run on the PineTime. This will allow you to work more easily if you don't have a PineTime dev kit around, if you don't want to modify your dev kit for SWD programming, or if you want to use some feature from the NRF52-DK (like power measurement).
 
 This stub only implements the display, the button and the BLE radio. The other features from the pintime are missing:
- * heart rate sensor
+
- * SPI flash
+- heart rate sensor
- * touchpad
+- SPI flash
- * accelerometer
+- touchpad
+- accelerometer
 
 These devices could be added on this stub, but I do not have the parts to try them out for now.
 
 ![Pinetime stub](../images/pinetimestub1.jpg "PinetimeStub")
 
-
 Here are the parts you need to build this simulator:
- * [NRF52-DK](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52-DK)
+
- * An ST7889 display (I bought [this one](https://www.aliexpress.com/item/32859772356.html?spm=a2g0s.9042311.0.0.1b774c4dSoc4Xz))
+- [NRF52-DK](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52-DK)
- * A push-button (the one I use comes from a previous project build around ESP8266 board Wemos D1 Mini).
+- An ST7889 display (I bought [this one](https://www.aliexpress.com/item/32859772356.html?spm=a2g0s.9042311.0.0.1b774c4dSoc4Xz))
- * Dupont wires
+- A push-button (the one I use comes from a previous project build around ESP8266 board Wemos D1 Mini).
+- Dupont wires
 
 You just need to make the following connections:
 
 | NRF52-DK | ST7889 display |
-| ---------|--------------- |
+| -------- | -------------- |
 | VDD      | VCC            |
 | GND      | GND            |
 | P0.03    | SDA            |
@@ -35,16 +38,15 @@ You just need to make the following connections:
 | P0.02    | SCL            |
 | P0.18    | DC             |
 
+| NRF52-DK | Push Button               |
+| -------- | ------------------------- |
+| P0.13    | Button IN (D3 in my case) |
+| GND      | GND                       |
 
-| NRF52-DK | Push Button            |
+You also need to enable the I/O expander to disconnect pins from the buttons and LED on the NRF52-DK and leave them available on the pin headers:
-| ---------|----------------------- |
-| P0.13 | Button IN (D3 in my case) |
-| GND | GND                         |
-
-You also need to enable the I/O expander to disconnect pins from buttons and led on the NRF52-DK and leave them available on the pin headers:
 
 | NRF52 -DK | NRF52- DK |
 | --------- | --------- |
 | DETECT    | GND       |
 
-Now, you should be able to program the SoC on the NRF52-DK board, and use it as if it was running on the pintime.
+Now, you should be able to program the SoC on the NRF52-DK board, and use it as if it was running on the PineTime.

doc/SPI-LCD-driver.md

@@ -1,6 +1,9 @@
 # The SPI LCD driver
+
 ## Introduction
-The LCD controller that drive the display of the Pinetime is the Sitronix ST7789V. This controller is easy to integrate with an MCU thanks to its SPI interface, and has some interesting features like:
+
+The LCD controller that drives the display of the Pinetime is the [Sitronix ST7789V](https://wiki.pine64.org/images/5/54/ST7789V_v1.6.pdf). This controller is easy to integrate with an MCU thanks to its SPI interface, and has some interesting features like:
+
 - an on-chip display data RAM that can store the whole framebuffer
 - partial screen update
 - hardware assisted vertical scrolling
@@ -11,6 +14,7 @@ When you want to write a device driver for a specific component, its datasheet i
 Luckily for us, the datasheet of the ST7789 is great! It contains everything we need to write a nice driver for our beloved Pinetime.
 
 In this document, I'll try to explain the process I've followed to write a device driver for the LCD. There were multiple iterations:
+
 - First, I tried to find the correct initialization sequence so that the controller is configured correctly according to the hardware configuration;
 - Then, I tried to display some pixels on the screen;
 - Next, I wanted to display squares, colors and text;
@@ -20,12 +24,14 @@ In this document, I'll try to explain the process I've followed to write a devic
 I'll describe all these steps in the following chapters.
 
 ## The datasheet
+
 As I said in the introduction, the datasheet will be your bedside book during your journey as a device driver designer. You'll read it from the beginning to the end once, twice, maybe ten times. Then, each time you'll want to do something new, you'll reopen the file and search for that specific paragraph or diagram than explains how the controller works so that you can figure out how to use it.
 
 The schematic of your board (the Pinetime schematics in this case) will also be very important, as you'll need to know how the LCD controller is physically connected to the MCU.
 
 How to read the datasheet? I recommend to read it from the beginning to the end (no joke) at least once. You certainly do not need to read everything in details, but it's good to know what information is available and where in the document. It'll be very useful during the development phase.
 You'll want to read some part with more attention :
+
 - Data color coding in 4-Line Serial Interface : how to send the pixel to be display to the controller
 - Display Data Ram : how is the memory organized
 - Power On/Off sequence
@@ -33,7 +39,6 @@ You'll want to read some part with more attention :
 
 ## One Pixel at a time
 
-
 ## Bulk transfers
 
 ## DMA
@@ -41,6 +46,7 @@ You'll want to read some part with more attention :
 ## IRQ
 
 ## Bare metal integration
+
 Integration customisée dans la lib GFX que j'ai écrite
 
 ## Integration with LittleVGL

doc/SWD.md

@@ -0,0 +1,15 @@
+# How to flash InfiniTime using the SWD interface
+
+Download the files **bootloader.bin**, **image-x.y.z.bin** and **pinetime-graphics-x.y.z.bin** from the release page:
+
+![Image file](gettingStarted/imageFile.png)
+
+The bootloader reads a boot logo from the external SPI flash memory. The first step consists of flashing a tool in the MCU that will flash the boot logo into this SPI flash memory. This first step is optional but recommended (the bootloader will display garbage on screen for a few second if you don't do it).
+Using your SWD tool, flash **pinetime-graphics-x.y.z.bin** at offset **0x0000**. Reset the MCU and wait for a few seconds until the logo is completely drawn on the display.
+
+Then, using your SWD tool, flash these file at the following offsets:
+
+- bootloader.bin : **0x0000**
+- image-x.y.z.bin : **0x8000**
+
+Reset and voilà, you're running InfiniTime on your PineTime!

doc/SimpleWeatherService.md

@@ -0,0 +1,78 @@
+# Simple Weather Service
+
+## Introduction
+
+The Simple Weather Service provides a simple and straightforward API to specify the current weather and the forecast for the next 5 days.
+It effectively replaces the original Weather Service (from InfiniTime 1.8) since InfiniTime 1.14.
+
+## Service
+
+The service UUID is `00050000-78fc-48fe-8e23-433b3a1942d0`.
+
+## Characteristics
+
+## Weather data (UUID 00050001-78fc-48fe-8e23-433b3a1942d0)
+
+The host uses this characteristic to update the current weather information and the forecast for the next 5 days.
+
+This characteristics accepts a byte array with the following 2-Bytes header:
+
+ - [0] Message Type :
+   - `0` : Current weather
+   - `1` : Forecast
+ - [1] Message Version :
+   - `0` : Currently supported
+   - `1` : Adds support for sunrise and sunset
+
+### Current Weather
+
+The byte array must contain the following data:
+
+ - [0] : Message type = `0`
+ - [1] : Message version = `1`
+ - [2][3][4][5][6][7][8][9] : Timestamp (64 bits UNIX timestamp, number of seconds elapsed since 1 JAN 1970)  in local time (the same timezone as the one used to set the time)
+ - [10, 11] : Current temperature (°C * 100)
+ - [12, 13] : Minimum temperature (°C * 100)
+ - [14, 15] : Maximum temperature (°C * 100)
+ - [16]..[47] : location (string, unused characters should be set to `0`)
+ - [48] : icon ID
+   - 0 = Sun, clear sky
+   - 1 = Few clouds
+   - 2 = Clouds
+   - 3 = Heavy clouds
+   - 4 = Clouds & rain
+   - 5 = Rain
+   - 6 = Thunderstorm
+   - 7 = Snow
+   - 8 = Mist, smog
+  - [49, 50] : Sunrise (number of minutes elapsed since midnight)
+    - `0` sun already up when day starts
+    - `-1` unknown
+    - `-2` no sunrise (e.g. polar night)
+  - [51, 52] : Sunset (number of minutes elapsed since midnight)
+    - `-1` unknown
+    - `-2` no sunset (e.g. polar day)
+
+### Forecast
+
+The byte array must contain the following data:
+
+  - [0] : Message type = `1`
+  - [1] : Message version = `0`
+  - [2][3][4][5][6][7][8][9] : Timestamp (64 bits UNIX timestamp, number of seconds elapsed since 1 JAN 1970) in local time (the same timezone as the one used to set the time)
+  - [10] Number of days (Max 5, fields for unused days should be set to `0`)
+  - [11,12] Day 0 Minimum temperature (°C * 100)
+  - [13,14] Day 0 Maximum temperature (°C * 100)
+  - [15] Day 0 Icon ID
+  - [16,17] Day 1 Minimum temperature (°C * 100)
+  - [18,19] Day 1 Maximum temperature (°C * 100)
+  - [20] Day 1 Icon ID
+  - [21,22] Day 2 Minimum temperature (°C * 100)
+  - [23,24] Day 2 Maximum temperature (°C * 100)
+  - [25] Day 2 Icon ID
+  - [26,27] Day 3 Minimum temperature (°C * 100)
+  - [28,29] Day 3 Maximum temperature (°C * 100)
+  - [30] Day 3 Icon ID
+  - [31,32] Day 4 Minimum temperature (°C * 100)
+  - [33,34] Day 4 Maximum temperature (°C * 100)
+  - [35] Day 4 Icon ID

doc/ble.md

@@ -1,28 +1,309 @@
 # Bluetooth Low-Energy :
+
 ## Introduction
+
 This page describes the BLE implementation and API built in this firmware.
 
-**Note** : I'm a beginner in BLE related technologies and the information of this document reflect my current knowledge and understanding of the BLE stack. These informations might be erroneous or incomplete. Feel free to submit a PR if you think you can improve these.  
+---
+
+### Table of Contents
+
+- [BLE Connection](#ble-connection)
+- [BLE FS](#ble-fs)
+- [BLE UUIDs](#ble-uuids)
+- [BLE Services](#ble-services)
+  - [CTS](#cts)
+  - [ANS](#ans)
+- [Getting Information](#getting-information)
+  - [Firmware Version](#firmware-version)
+  - [Battery Level](#battery-level)
+  - [Heart Rate](#heart-rate)
+- [Notifications](#notifications)
+  - [New Alert](#new-alert)
+  - [Notification Event](#notification-event)
+- [Firmware Upgrades](#firmware-upgrades)
+  - [Step one](#step-one)
+  - [Step two](#step-two)
+  - [Step three](#step-three)
+  - [Step four](#step-four)
+  - [Step five](#step-five)
+  - [Step six](#step-six)
+  - [Step seven](#step-seven)
+  - [Step eight](#step-eight)
+  - [Step nine](#step-nine)
+- [Music Control](#music-control)
+  - [Events](#events)
+  - [Status](#status)
+  - [Artist, Track, and Album](#artist-track-and-album)
+- [Time](#time)
+
+---
 
 ## BLE Connection
-When starting the firmware start a BLE advertising : it send small messages that can be received by any *central* device in range. This allows the device to announce its presence to other devices.
 
-A companion application (running on a PC, RasberryPi, smartphone) which received this avertising packet can request a connection to the device. This connection procedure allows the 2 devices to negociate communication parameters, security keys,...
+When starting, the firmware starts BLE advertising. It sends small messages that can be received by any *central* device in range. This allows the device to announce its presence to other devices.
 
-When the connection is established, the pinetime will try to discover services running on the companion application. For now **CTS** (**C**urrent **T**ime **S**ervice) and **ANS** (**A**lert **N**otification **S**ervice) are supported.
+A companion application (running on a PC, Raspberry Pi, smartphone, etc.) which receives this advertising packet can request a connection to the device. This connection procedure allows the 2 devices to negotiate communication parameters, security keys, etc.
+
+When the connection is established, the PineTime will try to discover services running on the companion application. For now **CTS** (**C**urrent **T**ime **S**ervice) and **ANS** (**A**lert **N**otification **S**ervice) are supported.
 
 If **CTS** is detected, it'll request the current time to the companion application. If **ANS** is detected, it will listen to new notifications coming from the companion application.
 
 ![BLE connection sequence diagram](ble/connection_sequence.png "BLE connection sequence diagram")
 
+---
+
+## BLE FS
+
+The documentation for BLE FS can be found here:
+[BLEFS.md](./BLEFS.md)
+
+---
+
+## BLE UUIDs
+
+When possible, InfiniTime tries to implement BLE services defined by the BLE specification.
+
+When the service does not exist in the BLE specification, InfiniTime implements custom services. Custom services are identified by a UUID, as are all BLE services. Here is how to define the UUID of custom services in InfiniTime:
+
+```
+ - Base UUID :           xxxxxxxx-78fc-48fe-8e23-433b3a1942d0
+ - Service UUID :        SSSS0000-78fc-48fe-8e23-433b3a1942d0 where SSSS is the service ID
+ - Characteristic UUID : SSSSCCCC-78fc-48fe-8e23-433b3a1942d0 where CCCC is the characteristic ID for the service SSSS and is different than 0
+```
+
+The following custom services are implemented in InfiniTime:
+
+- Since InfiniTime 0.8:
+
+  - Music Service : `00000000-78fc-48fe-8e23-433b3a1942d0`
+
+- Since InfiniTime 0.11:
+
+  - [Navigation Service](NavigationService.md) : `00010000-78fc-48fe-8e23-433b3a1942d0`
+
+- Since InfiniTime 0.13
+
+  - Call characteristic (extension to the Alert Notification Service): `00020001-78fc-48fe-8e23-433b3a1942d0`
+
+- Since InfiniTime 1.7:
+
+  - [Motion Service](MotionService.md): `00030000-78fc-48fe-8e23-433b3a1942d0`
+
+- Since InfiniTime 1.8:
+
+  - ~~Weather Service: `00040000-78fc-48fe-8e23-433b3a1942d0`~~ (replaced by Simple Weather Service in InfiniTime 1.14)
+
+- Since InfiniTime 1.14
+  - [Simple Weather Service](SimpleWeatherService.md) : `00050000-78fc-48fe-8e23-433b3a1942d0`
+
+---
+
 ## BLE services
+
 [List of standard BLE services](https://www.bluetooth.com/specifications/gatt/services/)
 
 ### CTS
+
 [Current Time Service](https://www.bluetooth.com/wp-content/uploads/Sitecore-Media-Library/Gatt/Xml/Services/org.bluetooth.service.current_time.xml)
 
 ### ANS
+
 [Alert Notification Service](https://www.bluetooth.com/wp-content/uploads/Sitecore-Media-Library/Gatt/Xml/Services/org.bluetooth.service.alert_notification.xml)
 
 ![ANS sequence diagram](./ble/ans_sequence.png "ANS sequence diagram")
 
+---
+
+### Getting Information
+
+The InfiniTime firmware exposes some information about itself through BLE. The BLE characteristic UUIDs for this information are as follows:
+
+- Firmware Version: `00002a26-0000-1000-8000-00805f9b34fb`
+- Battery Level: `00002a19-0000-1000-8000-00805f9b34fb`
+- Heart Rate: `00002a37-0000-1000-8000-00805f9b34fb`
+
+#### Firmware Version
+
+Reading a value from the firmware version characteristic will yield a UTF-8 encoded string containing the version of InfiniTime being run on the device. Example: `1.6.0`.
+
+#### Battery Level
+
+Reading from the battery level characteristic yields a single byte of data. This byte can be converted to an unsigned 8-bit integer which will be the battery percentage. This characteristic allows notifications for updates as the value changes.
+
+#### Heart Rate
+
+Reading from the heart rate characteristic yields two bytes of data. I am not sure of the function of the first byte. It appears to always be zero. The second byte can be converted to an unsigned 8-bit integer which is the current heart rate. This characteristic also allows notifications for updates as the value changes.
+
+---
+
+### Notifications
+
+InfiniTime uses the Alert Notification Service (ANS) for notifications. The relevant UUIDs are as follows:
+
+- New Alert: `00002a46-0000-1000-8000-00805f9b34fb`
+- Notification Event: `00020001-78fc-48fe-8e23-433b3a1942d0`
+
+#### New Alert
+
+The new alert characteristic allows sending new notifications to InfiniTime. It requires the following format:
+
+```
+<category><amount>\x00<\x00-separated data>
+```
+
+For example, here is what a normal notification looks like in Golang (language of `itd`):
+
+```go
+// \x00 is the category for simple alert, and there is one new notification, hence \x01.
+"\x00\x01\x00Test Title\x00Test Body"
+```
+
+A call notification looks like so:
+
+```go
+// \x03 is the category for calls, and there is one new call notification, hence \x01.
+"\x03\x01\x00Mary"
+```
+
+The `\x00` stands for hexadecimal `00` which means null.
+
+Here is the list of categories and commands:
+
+- Simple Alert: `0`
+- Email: `1`
+- News: `2`
+- Call Notification: `3`
+- Missed Call: `4`
+- SMS/MMS: `5`
+- Voicemail: `6`
+- Schedule: `7`
+- High Prioritized Alert: `8`
+- Instant Message: `9`
+- All Alerts: `0xFF`
+
+These lists and information were retrieved from the following pages in the Nordic docs:
+
+- [Alert Notification Service Client](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.sdk5.v12.2.0%2Fgroup__ble__ans__c.html)
+- [Alert Notification Application](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.sdk5.v13.0.0%2Fble_sdk_app_alert_notification.html)
+
+#### Notification Event
+
+A call notification in InfiniTime contains three buttons. Decline, Accept, and Mute. The notification event characteristic contains the button tapped by the user on a call notification. This characteristic only allows notify, **not** read.
+
+Enabling notifications from this characteristic, you get a single byte whenever the user taps a button on the call notification. This byte is an unsigned 8-bit integer that signifies one of the buttons. The numbers are as follows:
+
+- 0: Declined
+- 1: Accepted
+- 2: Muted
+
+---
+
+### Firmware Upgrades
+
+Firmware upgrades in InfiniTime are probably the most complex of the BLE operations. It is a nine step process requiring multiple commands be sent to multiple characteristics. The relevant UUIDs are as follows:
+
+- Control Point: `00001531-1212-efde-1523-785feabcd123`
+- Packet: `00001532-1212-efde-1523-785feabcd123`
+
+A DFU upgrade archive for InfiniTime consists of multiple files. The most important being the .bin and .dat files. The first is the actual firmware, while the second is a packet that initializes DFU. Both are needed for a DFU upgrade.
+
+The first thing to do is to enable notifications on the control point characteristic. This will be needed for verifying that the proper responses are being sent back from InfiniTime.
+
+#### Step one
+
+For the first step, write `0x01`, `0x04` to the control point characteristic. This will signal InfiniTime that a DFU upgrade is to be started.
+
+#### Step two
+
+In step two, send the total size in bytes of the firmware file to the packet characteristic. This value should be an unsigned 32-bit integer encoded as little-endian. In front of this integer should be 8 null bytes. This is because there are three items that can be updated and each 4 bytes is for one of those. The last four are for the InfiniTime application, so those are the ones that need to be set.
+
+#### Step three
+
+Before running step three, wait for a response from the control point. This response should be `0x10`, `0x01`, `0x01` which indicates a successful DFU start. In step three, send `0x02`, `0x00` to the control point. This will signal InfiniTime to expect the init packet on the packet characteristic.
+
+#### Step four
+
+The previous step prepared InfiniTime for this one. In this step, send the contents of the .dat init packet file to the packet characteristic. After this, send `0x02`, `0x01` indicating that the packet has been sent.
+
+#### Step five
+
+Before running this step, wait to receive `0x10`, `0x02`, `0x01` which indicates that the packet has been received. During this step, send the packet receipt interval to the control point. The firmware file will be sent in segments of 20 bytes each. The packet receipt interval indicates how many segments should be received before sending a receipt containing the amount of bytes received so that it can be confirmed to be the same as the amount sent. This is very useful for detecting packet loss. `itd` uses `0x08`, `0x0A` which indicates 10 segments.
+
+#### Step six
+
+In step six, write `0x03` to the control point, indicating that the firmware will be sent next on the packet characteristic.
+
+#### Step seven
+
+This step is the most difficult. Here, the actual firmware is sent to InfiniTime.
+
+As mentioned before, the firmware file must be split up into segments of 20 bytes each and sent to the packet characteristic one by one. Every 10 segments (or whatever you have set the interval to), check for a response starting with `0x11`. The rest of the response will be the amount of bytes received encoded as a little-endian unsigned 32-bit integer. Confirm that this matches the amount of bytes sent, and then continue sending more segments.
+
+#### Step eight
+
+Before running this step, wait to receive `0x10`, `0x03`, `0x01` which indicates a successful receipt of the firmware image. In this step, write `0x04` to the control point to signal InfiniTime to validate the image it has received.
+
+#### Step nine
+
+Before running this step, wait to receive `0x10`, `0x04`, `0x01` which indicates that the image has been validated. In this step, send `0x05` to the control point as a command with no response. This signals InfiniTime to activate the new firmware and reboot.
+
+Once all of these steps are complete, the DFU is complete. Don't forget to validate the firmware in the settings.
+
+---
+
+### Music Control
+
+InfiniTime contains a music controller app which is meant to control the music playback and volume through the companion.
+
+The following UUIDs are relevant to this:
+
+- Events: `00000001-78fc-48fe-8e23-433b3a1942d0`
+- Status: `00000002-78fc-48fe-8e23-433b3a1942d0`
+- Artist: `00000003-78fc-48fe-8e23-433b3a1942d0`
+- Track: `00000004-78fc-48fe-8e23-433b3a1942d0`
+- Album: `00000005-78fc-48fe-8e23-433b3a1942d0`
+
+#### Events
+
+The events characteristic is meant to respond to user input in the music controller app.
+
+Enabling notifications on this characteristic gives you a single byte upon any event. This byte can be converted to an unsigned 8-bit integer which corresponds to each possible event. Here are the events:
+
+- App Opened: `0xe0`
+- Play: `0x00`
+- Pause: `0x01`
+- Next: `0x03`
+- Previous: `0x04`
+- Volume up: `0x05`
+- Volume down: `0x06`
+
+#### Status
+
+The status characteristic allows setting the playing status of music. Send `0x01` to the status characteristic for playing, and `0x00` for paused.
+
+#### Artist, Track, and Album
+
+These characteristics all work the same way. Simply send a UTF-8 encoded string to the relevant characteristic in order to set the value in the app.
+
+---
+
+### Time
+
+InfiniTime allows setting its time via the Current Time Service (CTS)
+
+The UUID for the current time characteristic is: `00002a2b-0000-1000-8000-00805f9b34fb`
+
+This characteristic expects a particular format:
+
+- Year (`uint16`)
+- Month (`uint8`)
+- Day (`uint8`)
+- Hour (`uint8`)
+- Minute (`uint8`)
+- Second (`uint8`)
+- Weekday (`uint8`)
+- Microsecond divided by `1e6*256` (`uint8`)
+- Binary 0001 (`uint8`)
+
+Write all of these together, encoded as little-endian, to the current time characteristic.

doc/ble/connection_sequence.puml

@@ -3,7 +3,7 @@ Pinetime --> CompanionApp: Start advertising
 
 group BLE Connection
 CompanionApp -> Pinetime: Connection request
-CompanionApp <-> Pinetime: Connection parameters negociation, security procedure,...
+CompanionApp <-> Pinetime: Connection parameters negotiation, security procedure,...
 end
 
 group Service Discovery

doc/branches.md

@@ -1,12 +1,12 @@
 # Branches
-The branching model of this project is based on the workflow named [Git flow](https://nvie.com/posts/a-successful-git-branching-model/).
 
-It is based on 2 main branches:
+The project has 1 main branch, aptly called **main**.
- - **master** : this branch is always ready to be reployed. It means that at any time, we should be able to build the branch and release a new version of the application.
+This branch contains the latest development that will be tagged for the next release once it's considered stable.
- - **develop** : this branch contains the latest development that will be integrated in the next release once it's considered as stable.
 
-New features should be implemented in **feature branches** created from **develop**. When the feature is ready, a pull-request is created and it'll be merge into **develop** when it is succesfully reviewed and accepted.
+New features should be implemented in **feature branches** created from **main**.
+When the feature is ready, a pull request is created and it'll be merged into **main** when it is successfully reviewed and accepted.
 
-To release a new version of the application, when develop is considered stable, a **release** branch is created from **develop**. This can be considered as a *release candidate* branch. When everything is OK, this release branch is merged into **master** and the release is generated (a tag is applied to git, the release note is finalized, binaries are built,...) from **master**.
+To release a new version of the application, when main is considered stable, a tag is created on the version bump commit in **main** and the release is generated (a tag is applied to git, the release note is finalized, binaries are built,...).
 
-Git flow also supports the creation of **hotfix** branches when a bug is discovered in a released version. The **hotfix** branch is created from **master** and will be used only to implement a fix to this bug. Multiple hotfix branches can be created for the same release if more than one bugs are discovered.
+We also supports the creation of **hotfix** branches when a bug is discovered in a released version. The **hotfix** branch is created from the latest tag and will be used only to implement a fix to this bug.
+Multiple hotfix branches can be created for the same release if multiple bugs are discovered.

doc/buildAndProgram.md

@@ -1,209 +1,101 @@
 # Build
+
 ## Dependencies
+
 To build this project, you'll need:
- - A cross-compiler : [ARM-GCC (9-2020-q2-update)](https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads/9-2020-q2-update)
+
- - The NRF52 SDK 15.3.0 : [nRF-SDK v15.3.0](https://developer.nordicsemi.com/nRF5_SDK/nRF5_SDK_v15.x.x/nRF5_SDK_15.3.0_59ac345.zip)
+- A cross-compiler : [ARM-GCC (10.3-2021.10)](https://developer.arm.com/downloads/-/gnu-rm)
- - A reasonably recent version of CMake (I use 3.16.5)
+- The NRF52 SDK 15.3.0 : [nRF-SDK v15.3.0](https://nsscprodmedia.blob.core.windows.net/prod/software-and-other-downloads/sdks/nrf5/binaries/nrf5sdk153059ac345.zip)
+- The Python 3 modules `cbor`, `intelhex`, `click` and `cryptography` modules for the `mcuboot` tool (see [requirements.txt](../tools/mcuboot/requirements.txt))
+  - To keep the system clean, you can install python modules into a python virtual environment (`venv`)
+    ```sh
+    python -m venv .venv
+    source .venv/bin/activate
+    python -m pip install wheel
+    python -m pip install -r tools/mcuboot/requirements.txt
+    ```
+- A reasonably recent version of CMake (I use 3.16.5)
+- lv_font_conv, to generate the font .c files
+  - see [lv_font_conv](https://github.com/lvgl/lv_font_conv#install-the-script)
+  - install npm (commonly done via the package manager, ensure node's version is at least 12)
+  - install lv_font_conv: `npm install lv_font_conv`
 
 ## Build steps
+
 ### Clone the repo
+
 ```
-git clone https://github.com/JF002/Pinetime.git
+git clone https://github.com/InfiniTimeOrg/InfiniTime.git
-cd Pinetime
+cd InfiniTime
+git submodule update --init
 mkdir build
 cd build
 ```
+
 ### Project generation using CMake
+
 CMake configures the project according to variables you specify the command line. The variables are:
 
  Variable | Description | Example|
 ----------|-------------|--------|
-**ARM_NONE_EABI_TOOLCHAIN_PATH**|path to the toolchain directory|`-DARM_NONE_EABI_TOOLCHAIN_PATH=/home/jf/nrf52/gcc-arm-none-eabi-9-2020-q2-update/`|
+**ARM_NONE_EABI_TOOLCHAIN_PATH**|path to the toolchain directory|`-DARM_NONE_EABI_TOOLCHAIN_PATH=/home/jf/nrf52/gcc-arm-none-eabi-10.3-2021.10/`|
 **NRF5_SDK_PATH**|path to the NRF52 SDK|`-DNRF5_SDK_PATH=/home/jf/nrf52/Pinetime/sdk`|
-**USE_JLINK, USE_GDB_CLIENT and USE_OPENOCD**|Enable *JLink* mode, *GDB Client* (Black Magic Probe) mode or *OpenOCD* mode (set the one you want to use to `1`)|`-DUSE_JLINK=1`
+**CMAKE_BUILD_TYPE (\*)**| Build type (Release or Debug). Release is applied by default if this variable is not specified.|`-DCMAKE_BUILD_TYPE=Debug`
-**CMAKE_BUILD_TYPE**| Build type (Release or Debug). Release is applied by default if this variable is not specified.|`-DCMAKE_BUILD_TYPE=Debug`
+**BUILD_DFU (\*\*)**|Build DFU files while building (needs [adafruit-nrfutil](https://github.com/adafruit/Adafruit_nRF52_nrfutil)).|`-DBUILD_DFU=1`
-**NRFJPROG**|Path to the NRFJProg executable. Used only if `USE_JLINK` is 1.|`-DNRFJPROG=/opt/nrfjprog/nrfjprog`
+**BUILD_RESOURCES (\*\*)**| Generate external resource while building (needs [lv_font_conv](https://github.com/lvgl/lv_font_conv) and [python3-pil/pillow](https://pillow.readthedocs.io) module). |`-DBUILD_RESOURCES=1`
-**GDB_CLIENT_BIN_PATH**|Path to arm-none-eabi-gdb executable. Used only if `USE_GDB_CLIENT` is 1.|`-DGDB_CLIENT_BIN_PATH=/home/jf/nrf52/gcc-arm-none-eabi-9-2019-q4-major/bin/arm-none-eabi-gdb`
+**TARGET_DEVICE**|Target device, used for hardware configuration. Allowed: `PINETIME, MOY_TFK5, MOY_TIN5, MOY_TON5, MOY_UNK`|`-DTARGET_DEVICE=PINETIME` (Default)
-**GDB_CLIENT_TARGET_REMOTE**|Target remote connection string. Used only if `USE_GDB_CLIENT` is 1.|`-DGDB_CLIENT_TARGET_REMOTE=/dev/ttyACM0`
 
+#### (\*) Note about **CMAKE_BUILD_TYPE**
+By default, this variable is set to *Release*. It compiles the code with size and speed optimizations. We use this value for all the binaries we publish when we [release](https://github.com/InfiniTimeOrg/InfiniTime/releases) new versions of InfiniTime.
+
+The *Debug* mode disables all optimizations, which makes the code easier to debug. However, the binary size will likely be too big to fit in the internal flash memory. If you want to build and debug a *Debug* binary, you can disable some parts of the code that are not needed for the test you want to achieve. You can also apply the *Debug* mode selectively on parts of the application by applying the `DEBUG_FLAGS` only for the part (CMake target) you want to debug. For example, let's say you want to debug code related to LittleFS, simply set the compilation options for the RELEASE configuration of the target to `DEBUG_FLAGS` (in `src/CMakeLists.txt`). This will force the compilation of that target in *Debug* mode while the rest of the project will be built in *Release* mode. Example:
 
-#### CMake command line for JLink
 ```
-cmake -DCMAKE_BUILD_TYPE=Debug -DARM_NONE_EABI_TOOLCHAIN_PATH=... -DNRF5_SDK_PATH=... -DUSE_JLINK=1 -DNRFJPROG=... ../
+target_compile_options(littlefs PRIVATE
+        ${COMMON_FLAGS}
+        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}> # Change from RELEASE_FLAGS to DEBUG_FLAGS
+        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
+        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
+        )
 ```
 
-#### CMake command line for GDB Client (Black Magic Probe)
+#### (\*\*) Note about **BUILD_DFU**
-```
+DFU files are the files you'll need to install your build of InfiniTime using OTA (over-the-air) mechanism. To generate the DFU file, the Python tool [adafruit-nrfutil](https://github.com/adafruit/Adafruit_nRF52_nrfutil) is needed on your system. Check that this tool is properly installed before enabling this option.
-cmake -DARM_NONE_EABI_TOOLCHAIN_PATH=... -DNRF5_SDK_PATH=... -DUSE_GDB_CLIENT=1 -DGDB_CLIENT_BIN_PATH=... -DGDB_CLIENT_TARGET_REMOTE=... ../
+
-```
+#### CMake command 
 
-#### CMake command line for OpenOCD
 ```
-cmake -DARM_NONE_EABI_TOOLCHAIN_PATH=... -DNRF5_SDK_PATH=... -DUSE_OPENOCD=1 -DGDB_CLIENT_BIN_PATH=[optional] ../
+cmake -DARM_NONE_EABI_TOOLCHAIN_PATH=... -DNRF5_SDK_PATH=... -S ..
 ```
 
 ### Build the project
-During the project generation, CMake created the following targets:
-- FLASH_ERASE : mass erase the flash memory of the NRF52.
-- FLASH_pinetime-app : flash the firmware into the NRF52.
-- pinetime-app : build the standalone (without bootloader support) version of the firmware.
-- pinetime-mcuboot-app : build the firmware with the support of the bootloader (based on MCUBoot).
-- pinetime-graphics : small firmware that writes the boot graphics into the SPI flash.
 
-If you just want to build the project and run it on the Pinetime, using *pinetime-app* is recommanded. See [this page](../bootloader/README.md) for more info about bootloader support.
+During the project generation, CMake created the following targets:
+
+- **pinetime-app** : build the standalone (without bootloader support) version of the firmware.
+- **pinetime-recovery** : build the standalone recovery version of infinitime (light firmware that only supports OTA and basic UI)
+- **pinetime-recovery-loader** : build the standalone tool that flashes the recovery firmware into the external SPI flash
+- **pinetime-mcuboot-app** : build the firmware with the support of the bootloader (based on MCUBoot).
+- **pinetime-mcuboot-recovery** : build pinetime-recovery with bootloader support
+- **pinetime-mcuboot-recovery-loader** : build pinetime-recovery-loader with bootloader support
+
+If you just want to build the project and run it on the Pinetime, using *pinetime-app* is recommended. See [this page](../bootloader/README.md) for more info about bootloader support.
 
 Build:
+
 ```
-make -j pinetime-app
+make -j4 pinetime-app
 ```
 
 List of files generated:
 Binary files are generated into the folder `src`:
- - **pinetime-app.bin, .hex and .out** : standalone firmware in bin, hex and out formats.
- - **pinetime-app.map** : map file
- - **pinetime-mcuboot-app.bin, .hex and .out** : firmware with bootloader support in bin, hex and out formats.
- - **pinetime-mcuboot-app.map** : map file
- - **pinetime-graphics.bin, .hex and .out** : firmware for the boot graphic in bin, hex and out formats.
- - **pinetime-graphics.map** : map file
 
-### Program and run
+- **pinetime-app.bin, .hex and .out** : standalone firmware in bin, hex and out formats.
-#### Using CMake targets
+- **pinetime-app.map** : map file
-These target have been configured during the project generation by CMake according to the parameters you provided to the command line.
+- **pinetime-mcuboot-app.bin, .hex and .out** : firmware with bootloader support in bin, hex and out formats.
+- **pinetime-mcuboot-app.map** : map file
+- **pinetime-mcuboot-app-image** : MCUBoot image of the firmware
+- **pinetime-mcuboot-app-dfu** : DFU file of the firmware
 
-Mass erase:
+The same files are generated for **pinetime-recovery** and **pinetime-recovery-loader**
-```
-make FLASH_ERASE
-``` 
-
-Flash the application:
-```
-make FLASH_pinetime-app
-```
-
-### Using JLink
-Start JLinkExe:
-```
-$ /opt/SEGGER/JLink/JLinkExe -device nrf52 -if swd -speed 4000 -autoconnect 1     
-SEGGER J-Link Commander V6.70d (Compiled Apr 16 2020 17:59:37)
-DLL version V6.70d, compiled Apr 16 2020 17:59:25
-
-Connecting to J-Link via USB...O.K.
-Firmware: J-Link OB-SAM3U128-V2-NordicSemi compiled Mar 17 2020 14:43:00
-Hardware version: V1.00
-S/N: 682579153
-License(s): RDI, FlashBP, FlashDL, JFlash, GDB
-VTref=3.300V
-Device "NRF52" selected.
-
-
-Connecting to target via SWD
-InitTarget() start
-InitTarget() end
-Found SW-DP with ID 0x2BA01477
-DPIDR: 0x2BA01477
-Scanning AP map to find all available APs
-AP[2]: Stopped AP scan as end of AP map has been reached
-AP[0]: AHB-AP (IDR: 0x24770011)
-AP[1]: JTAG-AP (IDR: 0x02880000)
-Iterating through AP map to find AHB-AP to use
-AP[0]: Core found
-AP[0]: AHB-AP ROM base: 0xE00FF000
-CPUID register: 0x410FC241. Implementer code: 0x41 (ARM)
-Found Cortex-M4 r0p1, Little endian.
-FPUnit: 6 code (BP) slots and 2 literal slots
-CoreSight components:
-ROMTbl[0] @ E00FF000
-ROMTbl[0][0]: E000E000, CID: B105E00D, PID: 000BB00C SCS-M7
-ROMTbl[0][1]: E0001000, CID: B105E00D, PID: 003BB002 DWT
-ROMTbl[0][2]: E0002000, CID: B105E00D, PID: 002BB003 FPB
-ROMTbl[0][3]: E0000000, CID: B105E00D, PID: 003BB001 ITM
-ROMTbl[0][4]: E0040000, CID: B105900D, PID: 000BB9A1 TPIU
-ROMTbl[0][5]: E0041000, CID: B105900D, PID: 000BB925 ETM
-Cortex-M4 identified.
-J-Link>
-```
-
-Use the command loadfile to program the .hex file:
-```
-J-Link>loadfile pinetime-app.hex 
-Downloading file [pinetime-app.hex]...
-Comparing flash   [100%] Done.
-Erasing flash     [100%] Done.
-Programming flash [100%] Done.
-Verifying flash   [100%] Done.
-J-Link: Flash download: Bank 0 @ 0x00000000: 1 range affected (4096 bytes)
-J-Link: Flash download: Total time needed: 0.322s (Prepare: 0.043s, Compare: 0.202s, Erase: 0.003s, Program: 0.064s, Verify: 0.000s, Restore: 0.007s)
-O.K.
-```
-
-Then reset (r) and start (g) the CPU:
-```
-J-Link>r
-Reset delay: 0 ms
-Reset type NORMAL: Resets core & peripherals via SYSRESETREQ & VECTRESET bit.
-Reset: Halt core after reset via DEMCR.VC_CORERESET.
-Reset: Reset device via AIRCR.SYSRESETREQ.
-J-Link>g
-```
-
-#### JLink RTT
-RTT is a feature from Segger's JLink devices that allows bidirectionnal communication between the debugger and the target. This feature can be used to get the logs from the embedded software on the development computer.
-
- - Program the MCU with the code (see above)
- - Start JLinkExe
- 
-```
-$ JLinkExe -device nrf52 -if swd -speed 4000 -autoconnect 1
-```
-
-Start JLinkRTTClient
-```
-$ JLinkRTTClient
-```
-
-### Using GDB and Black Magic Probe (BMP)
-Enter the following command into GDB:
-
-```
-target extended-remote /dev/ttyACM0
-monitor swdp_scan
-attach 1
-file ./pinetime-app-full.hex 
-load
-run
-```
-
-Example :
-```
-$ /home/jf/nrf52/gcc-arm-none-eabi-8-2019-q3-update/bin/arm-none-eabi-gdb
-
-(gdb) target extended-remote /dev/ttyACM0
-Remote debugging using /dev/ttyACM0
-(gdb) monitor swdp_scan
-Target voltage: ABSENT!
-Available Targets:
-No. Att Driver
- 1      Nordic nRF52 M3/M4
- 2      Nordic nRF52 Access Port 
-
-(gdb) attach 1
-Attaching to Remote target
-warning: No executable has been specified and target does not support
-determining executable automatically.  Try using the "file" command.
-0xfffffffe in ?? ()
-(gdb) file ./pinetime-app-full.hex 
-A program is being debugged already.
-Are you sure you want to change the file? (y or n) y
-Reading symbols from ./pinetime-app-full.hex...
-(No debugging symbols found in ./pinetime-app-full.hex)
-(gdb) load
-Loading section .sec1, size 0xb00 lma 0x0
-Loading section .sec2, size 0xf000 lma 0x1000
-Loading section .sec3, size 0x10000 lma 0x10000
-Loading section .sec4, size 0x5150 lma 0x20000
-Loading section .sec5, size 0xa000 lma 0x26000
-Loading section .sec6, size 0x10000 lma 0x30000
-Loading section .sec7, size 0xdf08 lma 0x40000
-Start address 0x0, load size 314200
-Transfer rate: 45 KB/sec, 969 bytes/write.
-```

doc/buildWithDocker.md

@@ -1,33 +1,89 @@
 # Build the project using Docker
-A [Docker image (Dockerfile)](../docker) containing all the build environment is available for X86_64 and AMD64 architectures. This image makes the build of the firmware and the generation of the DFU file for OTA.
 
-## Build the image
+A [Docker image (Dockerfile)](../docker) containing all the build environment is available for X86_64 and ARM64 architectures.
-The image is not (yet) available on DockerHub, you need to build it yourself, which is quite easy. The following commands must be run from the root of the project.
+These images make the build of the firmware and the generation of the DFU file for OTA quite easy, as well as preventing clashes with any other toolchains or development environments you may have installed.
 
-If you are running on a x86_64 computer : 
+Based on Ubuntu 22.04 with the following build dependencies:
-```
+
-docker image build -t infinitime-build --build-arg USER_ID=$(id -u) --build-arg GROUP_ID=$(id -g) docker/x86_64/
+- ARM GCC Toolchain
+- nRF SDK
+- MCUBoot
+- adafruit-nrfutil
+- lv_font_conv
+
+## Clone the repository
+
+Before building, local repository must be fully initialized.
+
+```sh
+git clone https://github.com/InfiniTimeOrg/InfiniTime.git
+cd InfiniTime
+git submodule update --init
 ```
 
-And if your are running on an ARM64 device (tested on RaspberryPi4 and Pine64 PineBookPro):
+## Provision the image
-```
+
-docker image build -t infinitime-build --build-arg USER_ID=$(id -u) --build-arg GROUP_ID=$(id -g) docker/arm64/
+Before continuing, the build image needs to be either build locally or pulled
+from Docker Hub, as described in the two sections below:
+
+### Build the image
+
+You can build the image yourself if you like!
+
+The following commands must be run from the root of the project. This operation
+will take some time but, when done, a new image named `infinitime-build` is
+available.
+
+```sh
+docker build -t infinitime-build ./docker
 ```
 
-This operation will take some time. It builds a Docker image based on Ubuntu, install some packages, download the ARM toolchain, the NRF SDK, MCUBoot and adafruit-nrfutil.
+### Pull the image from Docker Hub
 
-When this is done, a new image named *infinitime-build* is available.
+The image is available via Docker Hub for both the amd64 and arm64v8 architectures at
+[infinitime/infinitime-build](https://hub.docker.com/repository/docker/infinitime/infinitime-build).
 
-## Run a container to build the project:
+You can run it using the following command:
 
-```
+```sh
-docker run --rm -v <project_root>:/sources infinitime-build
+docker run --rm -it -v ${PWD}:/sources --user $(id -u):$(id -g) infinitime/infinitime-build
 ```
 
-Replace *<project_root>* by the path of the root of the project on your computer. For example:
+The default `latest` tag *should* automatically identify the correct image architecture, but if for some reason Docker does not, you can specify it manually:
 
-```
+- For AMD64 (x86_64) systems: `docker pull --platform linux/amd64 infinitime/infinitime-build`
-docker run --rm -v /home/jf/git/PineTime:/sources infinitime-build
+
+- For ARM64v8 (ARM64/aarch64) systems: `docker pull --platform linux/arm64 infinitime/infinitime-build`
+
+## Run a container to build the project
+
+The `infinitime-build` image contains all the dependencies you need.
+The default `CMD` will compile sources found in `/sources`, so you need only mount your code.
+
+This example will build the firmware, generate the MCUBoot image and generate the DFU file.
+Outputs will be written to **<project_root>/build/output**:
+
+```sh
+cd <project_root> # e.g. cd ./work/Pinetime
+docker run --rm -it -v ${PWD}:/sources infinitime-build
 ```
 
-This will start a container, build the firmware and generate the MCUBoot image and the DFU file. The output of the build is stored in **<project_root>/built/output**.
+If the docker service is running as `root`, the build process inside the
+container also runs as `root`, which is not convenient as all the files
+generated by the build will also belong to `root`. The parameter `--user`
+overrides this behaviour. The command below ensures that all files are created
+as your current user:
+
+
+```sh
+cd <project_root> # e.g. cd ./work/Pinetime
+docker run --rm -it -v ${PWD}:/sources --user $(id -u):$(id -g) infinitime-build
+```
+
+If you only want to build a single CMake target, you can pass it in as the first parameter to the build script.
+This means calling the script explicitly as it will override the `CMD`.
+Here's an example for `pinetime-app`:
+
+```sh
+docker run --rm -it -v ${PWD}:/sources --user $(id -u):$(id -g) infinitime-build /opt/build.sh pinetime-app
+```

doc/buildWithVScode.md

@@ -0,0 +1,47 @@
+# Build and Develop the project using VS Code
+
+The .VS Code folder contains configuration files for developing InfiniTime with VS Code. Effort was made to have these rely on Environment variables instead of hardcoded paths.
+
+## Environment Setup
+
+To support as many setups as possible the VS Code configuration files expect there to be certain environment variables to be set.
+
+ Variable | Description | Example
+----------|-------------|--------
+**ARM_NONE_EABI_TOOLCHAIN_PATH**|path to the toolchain directory|`export ARM_NONE_EABI_TOOLCHAIN_PATH=/opt/gcc-arm-none-eabi-10.3-2021.10`
+**NRF5_SDK_PATH**|path to the NRF52 SDK|`export NRF5_SDK_PATH=/opt/nRF5_SDK_15.3.0_59ac345`
+
+## VS Code Extensions
+
+We leverage a few VS Code extensions for ease of development.
+
+#### Required Extensions
+
+- [C/C++](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) - C/C++ IntelliSense, debugging, and code browsing.
+- [CMake Tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools) - Extended CMake support in Visual Studio Code
+
+#### Optional Extensions
+
+[Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug) - ARM Cortex-M GDB Debugger support for VS Code
+
+Cortex-Debug is only required for interactive debugging using VS Codes built in GDB support.
+
+## VS Code/Docker DevContainer
+
+The .devcontainer folder contains the configuration and scripts for using a Docker dev container for building InfiniTime
+
+Using the [Remote-Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) extension is recommended. It will handle configuring the Docker virtual machine and setting everything up.
+
+More documentation is available in the [readme in .devcontainer](usingDevcontainers.md)
+
+### DevContainer on Ubuntu
+
+To use the DevContainer configuration on Ubuntu based systems two changes need to be made:
+
+1. Modify the file `.devcontainer/devcontainer.json` and add the argument `"--net=host"` to the `"runArgs"` parameter making the line look like this:
+   `"runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined", "--net=host"],`
+2. Modify the file `.vscode/launch.json` and change the argument of `"gdbTarget"` to `"127.0.0.1:3333"`, making the line look like:
+   `"gdbTarget": "127.0.0.1:3333",`
+3. To start debugging launch openocd on your host system with the appropriate configuration, for example with a stlink-v2 the command is:
+   `openocd -f interface/stlink.cfg -f target/nrf52.cfg`. This launches openocd with the default ports `3333`, `4444` and `6666`.
+4. In VsCode go to the Debug pane on the left of the screen and select the configuration `Debug - Openocd docker Remote` and hit the play button on the left.

doc/code/Apps.md

@@ -0,0 +1,214 @@
+# Apps
+
+This page will teach you:
+
+- what screens and apps are in InfiniTime
+- how to implement your own app
+
+## Theory
+
+The user interface of InfiniTime is made up of **screens**.
+Screens that are opened from the app launcher are considered **apps**.
+Every app in InfiniTime is its own class.
+An instance of the class is created when the app is launched, and destroyed when the user exits the app.
+Apps run inside the `DisplayApp` task (briefly discussed [here](./Intro.md)).
+Apps are responsible for everything drawn on the screen when they are running.
+Apps can be refreshed periodically and reacts to external events (touch or button).
+
+## Interface
+
+Every app class is declared inside the namespace `Pinetime::Applications::Screens` 
+and inherits
+from [`Pinetime::Applications::Screens::Screen`](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/src/displayapp/screens/Screen.h).
+
+Each app defines its own constructor.
+The constructors mostly take references to InfiniTime `Controllers` (ex: Alarm, DateTime, BLE services, Settings,...)
+the app needs for its operations. The constructor is responsible for initializing the UI of the app.
+
+The **destructor** cleans up LVGL and restores any changes (for example re-enable sleeping).
+
+App classes can override `bool OnButtonPushed()`, `bool OnTouchEvent(TouchEvents event)`
+and `bool OnTouchEvent(uint16_t x, uint16_t y)` to implement their own functionality for those events.
+
+Apps that need to be refreshed periodically create an `lv_task` (using `lv_task_create()`)
+that will call the method `Refresh()` periodically.
+
+## App types
+
+There are basically 3 types of applications : **system** apps and **user** apps and **watch faces**.
+
+**System** applications are always built into InfiniTime, and InfiniTime cannot work properly without those apps.
+Settings, notifications and the application launcher are examples of such system applications.
+
+**User** applications are optionally built into the firmware. They extend the functionalities of the system.
+
+**Watch faces** are very similar to the **user** apps, they are optional, but at least one must be built into the firmware.
+
+The distinction between **system** apps,  **user** apps and watch faces allows for more flexibility and customization.
+This allows to easily select which user applications and watch faces must be built into the firmware
+without overflowing the system memory.
+
+## Apps and watch faces initialization
+
+Apps are created by `DisplayApp` in `DisplayApp::LoadScreen()`.
+This method simply call the creates an instance of the class that corresponds to the app specified in parameters.
+
+The constructor of **system** apps is called directly. If the application is a **user** app,
+the corresponding `AppDescription` is first retrieved from `userApps`
+and then the function `create` is called to create an instance of the app.
+
+Watch faces are handled in a very similar way as the **user** apps : they are created by `DisplayApp` in the method `DisplayApp::LoadScreen()` when the application type is `Apps::Clock`.
+
+## User application selection at build time
+
+The list of user applications is generated at build time by the `consteval` function `CreateAppDescriptions()`
+in `UserApps.h`. This method takes the list of applications that must be built into the firmware image.
+This list of applications is defined as a list `Apps` enum values named `UserAppTypes` in `Apps.h`.
+For each application listed in `UserAppTypes`, an entry of type `AppDescription` is added to the array `userApps`.
+This entry is created by using the information provided by a template `AppTraits`
+that is customized for every user application.
+
+Here is an example of an AppTraits customized for the Alarm application. 
+It defines the type of application, its icon and a function that returns an instance of the application.
+
+```c++
+template <>
+struct AppTraits<Apps::Alarm> {
+  static constexpr Apps app = Apps::Alarm;
+  static constexpr const char* icon = Screens::Symbols::clock;
+
+  static Screens::Screen* Create(AppControllers& controllers) {
+    return new Screens::Alarm(controllers.alarmController,
+                              controllers.settingsController.GetClockType(),
+                              *controllers.systemTask,
+                              controllers.motorController);
+  };
+};
+```
+
+This array `userApps` is used by `DisplayApp` to create the applications and the `AppLauncher`
+to list all available applications.
+
+## Watch face selection at build time
+
+The list of available watch faces is also generated at build time by the `consteval`
+function `CreateWatchFaceDescriptions()` in `UserApps.h` in the same way as the **user** apps.
+Watch faces must declare a `WatchFaceTraits` so that the corresponding `WatchFaceDescription` can be generated.
+Here is an example of `WatchFaceTraits`:
+```c++
+    template <>
+    struct WatchFaceTraits<WatchFace::Analog> {
+      static constexpr WatchFace watchFace = WatchFace::Analog;
+      static constexpr const char* name = "Analog face";
+
+      static Screens::Screen* Create(AppControllers& controllers) {
+        return new Screens::WatchFaceAnalog(controllers.dateTimeController,
+                                            controllers.batteryController,
+                                            controllers.bleController,
+                                            controllers.notificationManager,
+                                            controllers.settingsController);
+      };
+
+      static bool IsAvailable(Pinetime::Controllers::FS& /*filesystem*/) {
+        return true;
+      }
+    };
+```
+
+## Creating your own app
+
+A minimal user app could look like this:
+
+MyApp.h:
+
+```cpp
+#pragma once
+
+#include "displayapp/apps/Apps.h"
+#include "displayapp/screens/Screen.h"
+#include "displayapp/Controllers.h"
+#include "Symbols.h"
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class MyApp : public Screen {
+      public:
+        MyApp();
+        ~MyApp() override;
+      };
+    }
+    
+    template <>
+    struct AppTraits<Apps::MyApp> {
+      static constexpr Apps app = Apps::MyApp;
+      static constexpr const char* icon = Screens::Symbols::myApp;
+      static Screens::Screen* Create(AppControllers& controllers) {
+        return new Screens::MyApp();
+      }
+    };
+  }
+}
+```
+
+MyApp.cpp:
+
+```cpp
+#include "displayapp/screens/MyApp.h"
+
+using namespace Pinetime::Applications::Screens;
+
+MyApp::MyApp() {
+  lv_obj_t* title = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_static(title, "My test application");
+  lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(title, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
+}
+
+MyApp::~MyApp() {
+  lv_obj_clean(lv_scr_act());
+}
+```
+
+Both of these files should be in [displayapp/screens/](/src/displayapp/screens/).
+
+Now we have our very own app, but InfiniTime does not know about it yet.
+The first step is to include your `MyApp.cpp` (or any new cpp files for that matter)
+in the compilation by adding it to [CMakeLists.txt](/CMakeLists.txt).
+The next step to making it launch-able is to give your app an id.
+To do this, add an entry in the enum class `Pinetime::Applications::Apps` ([displayapp/apps/Apps.h](/src/displayapp/apps/Apps.h.in)).
+Name this entry after your app. Add `#include "displayapp/screens/MyApp.h"`
+to the file [displayapp/DisplayApp.cpp](/src/displayapp/DisplayApp.cpp).
+
+If your application is a **system** application, go to the function `DisplayApp::LoadScreen`
+and add another case to the switch statement.
+The case will be the id you gave your app earlier.
+If your app needs any additional arguments, this is the place to pass them.
+
+If your application is a **user** application, you don't need to add anything in DisplayApp,
+everything will be automatically generated for you.
+The user application will also be automatically be added to the app launcher menu.
+
+Since the list of **user** application is generated by CMake, you need to add the variable `ENABLE_USERAPPS` to the command line of CMake.
+This variable must be set with a string composed of an ordered list of the **user** applications that must be built into the firmware.
+The items of the list are fields from the enumeration `Apps`.
+Ex : build the firmware with 3 user application : Alarm, Timer and MyApp (the application will be listed in this specific order in the application menu).
+
+```cmake
+$ cmake ... -DENABLE_USERAPPS="Apps::Alarm, Apps::Timer, Apps::MyApp" ... 
+```
+
+Similarly, the list of watch faces is also generated by CMake, so you need to add the variable `ENABLE_WATCHFACES` to the command line of CMake.
+It must be set with the comma separated list of watch faces that will be built into the firmware.
+
+Ex: build the firmware with 3 watch faces : Analog, PineTimeStyle and Infineat:
+
+```cmake
+$ cmake ... -DENABLE_WATCHFACES="WatchFace::Analog,WatchFace::PineTimeStyle,WatchFace::Infineat" ...
+```
+
+You should now be able to [build](../buildAndProgram.md) the firmware
+and flash it to your PineTime. Yay!
+
+Please remember to pay attention to the [UI guidelines](../ui_guidelines.md)
+when designing an app that you want to be included in InfiniTime.

doc/code/Intro.md

@@ -0,0 +1,49 @@
+# Introduction to the code
+
+This page is meant to guide you through the source code, so you can find the relevant files for what you're working on.
+
+## FreeRTOS
+
+Infinitime is based on FreeRTOS, a real-time operating system.
+FreeRTOS provides several quality of life abstractions (for example easy software timers)
+and most importantly supports multiple tasks.
+If you want to read up on real-time operating systems, you can look [here](https://www.freertos.org/implementation/a00002.html) and [here](https://www.freertos.org/features.html).
+The main "process" creates at least one task and then starts the FreeRTOS task scheduler.
+This main "process" is the standard main() function inside [main.cpp](/src/main.cpp).
+The task scheduler is responsible for giving every task enough cpu time.
+As there is only one core on the SoC of the PineTime, real concurrency is impossible and the scheduler has to swap tasks in and out to emulate it.
+
+### Tasks
+
+Tasks are created by calling `xTaskCreate` and passing a function with the signature `void functionName(void*)`.
+For more info on task creation see the [FreeRTOS Documentation](https://www.freertos.org/a00125.html).
+In our case, main calls `systemTask.Start()`, which creates the **"MAIN" task**.
+The function running inside that task is `SystemTask::Work()`.
+You may also see this task being referred to as the **work task**.
+Both functions are located inside [systemtask/SystemTask.cpp](/src/systemtask/SystemTask.cpp). `SystemTask::Work()` initializes all the driver and controller objects.
+It also starts the **task "displayapp"**, which is responsible for launching and running apps, controlling the screen and handling touch events (or forwarding them to the active app).
+You can find the "displayapp" task inside [displayapp/DisplayApp.cpp](/src/displayapp/DisplayApp.cpp).
+There are also other tasks that are responsible for Bluetooth ("ll" and "ble" inside [libs/mynewt-nimble/porting/npl/freertos/src/nimble_port_freertos.c](/src/libs/mynewt-nimble/porting/npl/freertos/src/nimble_port_freertos.c))
+and periodic tasks like heartrate measurements ([heartratetask/HeartRateTask.cpp](/src/heartratetask/HeartRateTask.cpp)).
+
+While it is possible for you to create your own task when you need it, it is recommended to just add functionality to `SystemTask::Work()` if possible.
+If you absolutely need to create another task, try to estimate how much [stack space](https://www.freertos.org/FAQMem.html#StackSize) (in words/4-byte packets)
+it will need instead of just typing in a large-ish number.
+You can use `configMINIMAL_STACK_SIZE` which is currently set to 120 words.
+
+## Controllers
+
+Controllers in InfiniTime are singleton objects that can provide access to certain resources to apps.
+Some of them interface with drivers, others are the driver for the resource.
+The resources provided don't have to be hardware-based.
+They are declared in main.cpp and initialized in [systemtask/SystemTask.cpp](/src/systemtask/SystemTask.cpp).
+Some controllers can be passed by reference to apps that need access to the resource (for example vibration motor).
+They reside in [components/](/src/components/) inside their own subfolder.
+
+## Apps
+
+For more detail see the [Apps page](./Apps.md)
+
+## Bluetooth
+
+Header files with short documentation for the functions are inside [libs/mynewt-nimble/nimble/host/include/host/](/src/libs/mynewt-nimble/nimble/host/include/host/).

doc/coding-convention.md

@@ -0,0 +1,29 @@
+# Coding style
+
+## Use these tools to find and fix issues.
+
+- Use `clang-format` to format the code.
+- Use `clang-tidy` to check the code for other potential issues.
+
+## Follow these guidelines while writing code.
+
+- **Indentation** : 2 spaces, no tabulation
+- **Opening brace** at the end of the line
+- **Naming** : Choose self-describing variable name
+  - **class** : PascalCase
+  - **namespace** : PascalCase
+  - **variable** : camelCase, **no** prefix/suffix (`_`, `m_`,...) for class members
+- **Include guard** : `#pragma once` (no `#ifdef __MODULE__ / #define __MODULE__ / #endif`)
+- **Includes** :
+  - files from the project : `#include "relative/path/to/the/file.h"`
+  - external files and std : `#include <file.h>`
+  - use includes relative to included directories like `src`, not relative to the current file. Don't do: `#include "../file.h"`
+- Only use [primary spellings for operators and tokens](https://en.cppreference.com/w/cpp/language/operator_alternative)
+- Use `auto` sparingly. Don't use `auto` for [fundamental/built-in types](https://en.cppreference.com/w/cpp/language/types) and [fixed width integer types](https://en.cppreference.com/w/cpp/types/integer), except when initializing with a cast to avoid duplicating the type name.
+  ```c++
+  // Examples:
+  auto* app = static_cast<DisplayApp*>(instance);
+  auto number = static_cast<uint8_t>(variable);
+  uint8_t returnValue = MyFunction();
+  ```
+- Use `nullptr` instead of `NULL`

doc/companionapps/Amazfish.md

@@ -1,15 +0,0 @@
-# Amazfish
-[Amazfish](https://openrepos.net/content/piggz/amazfish) is a companion app that supports many smartwatches and activity trackers running on [SailfishOS](https://sailfishos.org/).
-
-## Features
-The following features are implemented:
- - Scanning & detection of Pinetime-JF / InfiniTime
- - Connection / disconnection
- - Time synchronization
- - Notifications
- - Music control
- 
-## Demo
-[This video](https://seafile.codingfield.com/f/21c5d023452740279e36/) shows how to connect to the Pinetime and control the playback of the music on the phone.
-Amazfish and Sailfish OS are running on the [Pinephone](https://www.pine64.org/pinephone/), another awesome device from Pine64.
- 

doc/companionapps/Gadgetbridge.md

@@ -1,13 +0,0 @@
-# Integration with Gadgetbridge
-[Gadgetbridge](https://gadgetbridge.org/) is an Android application that supports many smartwatches and fitness trackers.
-
-The integration of InfiniTime (previously Pinetime-JF) is now merged into the master branch (https://codeberg.org/Freeyourgadget/Gadgetbridge/).
-
-## Features
-The following features are implemented:
- - Scanning & detection of Pinetime-JF / InfiniTime
- - Connection / disconnection
- - Notifications
- 
-## Demo
-[This video](https://seafile.codingfield.com/f/0a2920b9d765462385e4/) shows how to scan, connect, send notification (using the debug screen) and disconnect from the Pinetime.

doc/companionapps/NrfconnectOTA.md

@@ -1,12 +0,0 @@
-# OTA using NRFConnect
-[NRFConnect](https://www.nordicsemi.com/Software-and-tools/Development-Tools/nRF-Connect-for-mobile) is a powerful application (running on Android and iOS) which allows to scan and connect to BLE devices.
-
-## Features
- - Scanning, connect, disconnect
- - Time synchronization
- - OTA
- 
-InfiniTime implements the Nordic DFU protocol for the OTA functionality. NRFConnect also supports this protocol.
-
-# Demo
-[This video](https://seafile.codingfield.com/f/a52b69683a05472a90c7/) shows how to use NRFConnect to update the firmware running on the Pinetime.

doc/contribute.md

@@ -1,44 +0,0 @@
-# How to contribute?
-## Report bugs
-You use your Pinetime and find a bug in the firmware? [Create an issue on Github](https://github.com/JF002/Pinetime/issues) explaining the bug, how to reproduce it, the version of the firmware you use...
-## Write and improve documentation
-Documentation might be incomplete, or not clear enough, and it is always possible to improve it with better wording, pictures, photo, video,... 
-
-As the documentation is part of the source code, you can submit your improvements to the documentation by submitting a pull request (see below).
-## Fix bugs, add functionalities and improve the code
-You want to fix a bug, add a cool new functionality or improve the code? See *How to submit a pull request below*.
-## Spread the word
-Pinetime is a cool open source project that deserves to be know. Talk about it around you, on social networks, on your blog,... and let people know that we are working on an open-source firmware for a smartwatch!
-
-# How to submit a pull request ?
-Your contribution is more than welcome! 
-
-If you want to fix a bug, add a functionality or improve the code, you'll first need to create a branch from the **develop** branch (see [this page about the branching model](./branches.md)). This branch is called a feature branch, and you should choose a name that explains what you are working on (ex: "add-doc-about-contributions"). In this branch, try to focus on only one topic, bug or feature. For example, if you created this branch to work on the UI of a specific application, do not commit modifications about the SPI driver. If you want to work on multiple topics, create one branch per topic.
-
-When your feature branch is ready, make sure it actually works and do not forget to write documentation about it if necessary.
-
-Then, you can submit a pull-request for review. Try to describe your pull request as much as possible: what did you do in this branch, how does it work, how is it designed, are there any limitations,... This will help the contributors to understand and review your code easily.
-
-Other contributors can post comments about the pull request, maybe ask for more info or adjustements in the code.
-
-Once the pull request is reviewed an accepted, it'll be merge in **develop** and will be released in the next release version of the firmware.
-
-# Coding convention
-## Language
-The language of this project is **C++**, and all new code must be written in C++. (Modern) C++ provides a lot of useful tools and functionalities that are beneficial for embedded software development like `constexpr`, `template` and anything that provides zero-cost abstraction.  
-
-It's OK to include C code if this code comes from another library like FreeRTOS, NimBLE, LVGL or the NRF-SDK. 
-
-## Coding style
-The most important rule to follow is to try to keep the code as easy to read and maintain as possible. 
-
- - **Identation** : 2 spaces, no tabulation
- - **Opening brace** at the end of the line
- - **Naming** : Choose self-describing variable name
-    - **class** : PascalCase
-    - **namespace** : PascalCase
-    - **variable** : camelCase, **no** prefix/suffix ('_', 'm_',...) for class members
- - **Include guard** : `#pragma once` (no `#ifdef __MODULE__ / #define __MODULE__ / #endif`)
- - **Includes** :
-    - files from the project : `#include "relative/path/to/the/file.h"`
-    - external files and std : `#include <file.h>`

doc/files-needed-by-factory.md

@@ -0,0 +1,37 @@
+# How to generate files needed by the factory
+
+These files are needed by the Pine64 factory to flash InfiniTime as the default firmware on the PineTimes.
+
+Two files are needed: an **HEX (.hex)** file that contains the content of the internal flash memory (bootloader + InfiniTime) and a **binary (.bin)** file that contains the content of the external flash memory (recovery firmware).
+
+## merged-internal.hex
+
+First, convert the bootloader to hex:
+
+```
+<ARM TOOLCHAIN>/bin/arm-none-eabi-objcopy -I binary -O ihex ./bootloader.bin ./bootloader.hex
+```
+
+where `bootloader.bin` is the [last stable version](https://github.com/JF002/pinetime-mcuboot-bootloader/releases) of the [bootloader](https://github.com/JF002/pinetime-mcuboot-bootloader).
+
+Then, convert the MCUBoot image of InfiniTime:
+
+```
+<ARM TOOLCHAIN>/bin/arm-none-eabi-objcopy -I binary -O ihex --change-addresses 0x8000 ./pinetime-mcuboot-app-image-1.6.0.bin ./pinetime-mcuboot-app-image-1.6.0.hex
+```
+
+where `pinetime-mcuboot-app-image-1.6.0.bin` is [the bin of the last MCUBoot image](https://github.com/InfiniTimeOrg/InfiniTime/releases) of [InfiniTime](https://github.com/InfiniTimeOrg/InfiniTime).
+
+Pay attention to the parameter `--change-addresses 0x8000`. It's needed to ensure the image will be flashed at the offset expected by the bootloader (0x8000).
+
+Finally, merge them together with **mergehex**:
+
+```
+/opt/mergehex/mergehex -m ./bootloader.hex ./pinetime-mcuboot-app-image-1.6.0.hex  -o merged-internal.hex
+```
+
+This file must be flashed at offset **0x00** of the internal memory of the NRF52832.
+
+## spinor.bin
+
+This file is the MCUBoot image of the last stable version of the recovery firmware. It must be flashed at offset **0x00** of the external SPINOR flash memory.

doc/filesInReleaseNotes.md

@@ -1,56 +1,60 @@
 # Using the releases
-For each new *stable* version of Pinetime, a [release note](https://github.com/JF002/Pinetime/releases) is created. It contains a description of the main changes in the release and some files you can use to flash the firmware in your Pinetime.
+
+For each new *stable* version of IniniTime, a [release note](https://github.com/InfiniTimeOrg/InfiniTime/releases) is created. It contains a description of the main changes in the release and some files you can use to flash the firmware to your Pinetime.
 
 This page describes the files from the release notes and how to use them.
 
-**NOTE :** the files included in different could be different. This page describes the release note of [version 0.7.1](https://github.com/JF002/Pinetime/releases/tag/0.7.1), which is the version that'll probably be pre-programmed at the factory for the next batch of Pinetime devkits.
+**NOTE :** the files included in different Releases could be different. This page describes the release notes of [version 0.7.1](https://github.com/InfiniTimeOrg/InfiniTime/releases/tag/0.7.1), which is the version that is pre-programmed for the last batches of pinetimes but will be replaced with [1.0.0](https://github.com/jF002/infiniTime/releases/tag/1.0.0) around june 2021.
 
-## Files included in the release note
+## Files included in the release notes
 
 ### Standalone firmware
-This firmware is standalone, meaning that it does not need a bootloader to actually run. It is intended to be flash at offset 0, meaning it will erase any bootloader that might be present in memory.
 
- - **pinetime-app.out** : Output file of GCC containing debug symbols, useful is you want to debug the firmware using GDB.
+This firmware is standalone, meaning that it does not need a bootloader to actually run. It is intended to be flashed at offset 0, meaning it will erase any bootloader that might be present in memory.
- - **pinetime-app.hex** : Firmware in Intel HEX file format. Easier to use because it contains the offset in memory where it must be flashed, you don't need to specify it.
+
- - **pintime-app.bin** : Firmware in binary format. When programming it, you have to specify the offset (0x00) in memory where it must be flashed.
+- **pinetime-app.out** : Output file of GCC containing debug symbols, useful if you want to debug the firmware using GDB.
- - **pinetime-app.map** : Map file containing all the symbols, addresses in memory,...
+- **pinetime-app.hex** : Firmware in Intel HEX file format. Easier to use because it contains the offset in memory where it must be flashed, you don't need to specify it.
+- **pintime-app.bin** : Firmware in binary format. When programming it, you have to specify the offset (0x00) in memory where it must be flashed.
+- **pinetime-app.map** : Map file containing all the symbols, addresses in memory,...
 
 **This firmware must be flashed at address 0x00 in the main flash memory**
 
 ### Bootloader
-The bootloader  is maintained by [lupyuen](https://github.com/lupyuen) and is a binary version of [this release](https://github.com/lupyuen/pinetime-rust-mynewt/releases/tag/v5.0.4).
 
- - **bootloader.hex** : Firmware in Intel HEX file format.
+The bootloader is maintained by [lupyuen](https://github.com/lupyuen) and is a binary version of [this release](https://github.com/lupyuen/pinetime-rust-mynewt/releases/tag/v5.0.4).
 
- **This firmware must be flashed at address 0x00 in the main flash memory**
+- **bootloader.hex** : Firmware in Intel HEX file format.
 
+**This firmware must be flashed at address 0x00 in the main flash memory**
 
 ### Graphics firmware
+
 This firmware is a small utility firmware that writes the boot graphic in the external SPI flash memory. You need it if you want to use the [bootloader](../bootloader/README.md).
 
- - **pinetime-graphics.out** : Output file of GCC containing debug symbols, useful is you want to debug the firmware using GDB.
+- **pinetime-graphics.out** : Output file of GCC containing debug symbols, useful is you want to debug the firmware using GDB.
- - **pinetime-graphics.hex** : Firmware in Intel HEX file format. Easier to use because it contains the offset in memory where it must be flashed, you don't need to specify it.
+- **pinetime-graphics.hex** : Firmware in Intel HEX file format. Easier to use because it contains the offset in memory where it must be flashed, you don't need to specify it.
- - **pintime-graphics.bin** : Firmware in binary format. When programming it, you have to specify the offset (0x00) in memory where it must be flashed.
+- **pintime-graphics.bin** : Firmware in binary format. When programming it, you have to specify the offset (0x00) in memory where it must be flashed.
- - **pinetime-graphics.map** : Map file containing all the symbols, addresses in memory,...
+- **pinetime-graphics.map** : Map file containing all the symbols, addresses in memory,...
 
 **This firmware must be flashed at address 0x00 in the main flash memory**
 
 ### Firmware with bootloader
+
 This firmware is intended to be used with our [MCUBoot-based bootloader](../bootloader/README.md).
 
- - **pinetime-mcuboot-app-image.hex** : Firmware wrapped into an MCUBoot image. This is **the** file that must be flashed **@ 0x8000** into flash memory. If the [bootloader](../bootloader/README.md) has been successfully programmed, it should run this firmware after the next reset.
+- **pinetime-mcuboot-app-image.hex**: Firmware wrapped into an MCUBoot image. This is **the** file that must be flashed at **0x8000** into the flash memory. If the [bootloader](../bootloader/README.md) has been successfully programmed, it should run this firmware after the next reset.
 
 The following files are not directly usable by the bootloader:
 
- - **pinetime-mcuboot-app.out** : Output file of GCC containing debug symbols, useful is you want to debug the firmware using GDB.
+- **pinetime-mcuboot-app.out** : Output file of GCC containing debug symbols, useful is you want to debug the firmware using GDB.
- - **pinetime-mcuboot-app.hex** : Firmware in Intel HEX file format. 
+- **pinetime-mcuboot-app.hex** : Firmware in Intel HEX file format.
- - **pinetime-mcuboot-app.bin** : Firmware in binary format. 
+- **pinetime-mcuboot-app.bin** : Firmware in binary format.
- - **pinetime-mcuboot-app.map** : Map file containing all the symbols, addresses in memory,...
+- **pinetime-mcuboot-app.map** : Map file containing all the symbols, addresses in memory,...
 
 ### OTA (Update the firmware Over-The-Air)
+
 Once the bootloader and application firmware are running, it is possible to update the current firmware or even replace it with another firmware **that uses the same bootloader based on MCUBoot**.
 
 **NOTE :** Use this file **only** if you programmed our [MCUBoot-based bootloader](../bootloader/README.md). This file is not compatible with other bootloaders like the one that is based on the closed source NRF SoftDevice !
 
- - **pinetime-app-dfu.zip** : This is the file you must provide toNRFConnect to update the firmware over BLE.
+- **pinetime-app-dfu.zip** : This is the file you must provide toNRFConnect to update the firmware over BLE.
-

doc/gdb.md

@@ -0,0 +1,48 @@
+# Flashing the firmware with GDB and Black Magic Probe (BMP)
+
+Enter the following command into GDB:
+
+```
+target extended-remote /dev/ttyACM0
+monitor swdp_scan
+attach 1
+file ./pinetime-app-full.hex
+load
+run
+```
+
+Example :
+
+```
+$ /home/jf/nrf52/gcc-arm-none-eabi-8-2019-q3-update/bin/arm-none-eabi-gdb
+
+(gdb) target extended-remote /dev/ttyACM0
+Remote debugging using /dev/ttyACM0
+(gdb) monitor swdp_scan
+Target voltage: ABSENT!
+Available Targets:
+No. Att Driver
+ 1      Nordic nRF52 M3/M4
+ 2      Nordic nRF52 Access Port
+
+(gdb) attach 1
+Attaching to Remote target
+warning: No executable has been specified and target does not support
+determining executable automatically.  Try using the "file" command.
+0xfffffffe in ?? ()
+(gdb) file ./pinetime-app-full.hex
+A program is being debugged already.
+Are you sure you want to change the file? (y or n) y
+Reading symbols from ./pinetime-app-full.hex...
+(No debugging symbols found in ./pinetime-app-full.hex)
+(gdb) load
+Loading section .sec1, size 0xb00 lma 0x0
+Loading section .sec2, size 0xf000 lma 0x1000
+Loading section .sec3, size 0x10000 lma 0x10000
+Loading section .sec4, size 0x5150 lma 0x20000
+Loading section .sec5, size 0xa000 lma 0x26000
+Loading section .sec6, size 0x10000 lma 0x30000
+Loading section .sec7, size 0xdf08 lma 0x40000
+Start address 0x0, load size 314200
+Transfer rate: 45 KB/sec, 969 bytes/write.
+```

doc/gettingStarted/Applications.md

@@ -0,0 +1,99 @@
+# Applications
+
+InfiniTime has 13 apps on the `main` branch at the time of writing.
+
+## List of apps
+- Stopwatch
+- Alarm
+- Timer
+- Steps
+- Heartrate
+- Music
+- InfiniPaint
+- Paddle
+- 2
+- InfiniDice
+- Metronome
+- Maps
+- Weather
+
+### Stopwatch
+![Stopwatch UI](/doc/gettingStarted/AppsScreenshots/stopwatch.png)
+- Press the Start button (bottom right) to start or stop the timer.
+   - You can also press the side button while the timer is running to pause the timer.
+- Press the Flag button (bottom left) to add a lap.
+- The stopwatch will not yet continue counting time while the app is closed.
+
+### Alarm
+![Alarm UI](/doc/gettingStarted/AppsScreenshots/alarm.png)
+- Ajust the time with the time picker.
+- Press the Info button in the top middle to see time remaning.
+- Use the toggle in the bottom left to turn the alarm on/off.
+- Use the button in the bottom right to change the alarm frequency.
+   - You can choose between once, daily, or Monday - Friday.
+
+### Timer
+![Timer UI](/doc/gettingStarted/AppsScreenshots/timer.png)
+- Ajust how long the timer should go for with the time picker.
+- Press the Start button at the bottom to start/stop the timer.
+
+### Steps
+![Steps UI](/doc/gettingStarted/AppsScreenshots/steps.png)
+- The total count of steps for the current display will show in the middle of the screen.
+- The Reset button in the bottom middle resets the Trip counter. (Total of all steps taken.)
+- The progress circle shows the percentage of your daily goal completed.
+
+### Heartrate
+![Heartrate UI](/doc/gettingStarted/AppsScreenshots/Heartrate.png)
+- Press Start to start measuring your heartrate.
+    - It may take a bit to get the first measurement.
+
+### Music
+![Music UI](/doc/gettingStarted/AppsScreenshots/Music.png)
+- This app shows currently playing music.
+    - Please note that this app is not very useful without a device connected.
+- Press the button in the center to play/pause, and the buttons on the left and right to go to the previous and next tracks, respectively.
+- Swipe up to get to volume controls.
+
+### InfiniPaint
+![InfiniPaint UI](/doc/gettingStarted/AppsScreenshots/Paint.png)
+- This app does not allow you to swipe from the top to exit, use the side button instead.
+- Draw on the screen to add lines.
+- Hold down in one spot to change paint colors.
+
+### Paddle
+![Paddle UI](/doc/gettingStarted/AppsScreenshots/Pong.png)
+- This app does not allow you to swipe from the top to exit, use the side button instead.
+- Drag your finger to move the paddle.
+- Goal: Don't let the ball go off the left side of the screen.
+
+### 2
+![2 UI](/doc/gettingStarted/AppsScreenshots/2048.png)
+- This app does not allow you to swipe from the top to exit, use the side button instead.
+- Play a game of 2048.
+- Swipe up, down, left, or right tomove the tiles.
+- When two tiles with the same number run into each other, they will add together.
+- Goal: Don't let the screen fill up with tiles, and get to the 2048 tile to win.
+
+### InfiniDice
+![InfiniDice UI](/doc/gettingStarted/AppsScreenshots/Dice.png)
+- Ajust the count to change the number of dice.
+- Ajust the sides to change the number of sides.
+- Press the button at the bottom to roll.
+- The result will be on the right side of the screen.
+
+### Metronome
+![Metronome UI](/doc/gettingStarted/AppsScreenshots/Metronome.png)
+- Ajust the BPM with the circular slider.
+    - A bug currently makes it always snap to 98 BPM.
+- Use the button in the bottom left to start the metronome.
+
+### Maps
+![Maps UI](/doc/gettingStarted/AppsScreenshots/Maps.png)
+- This app shows info from a navigation app.
+    - Please note that this app is not very useful without a device connected.
+
+### Weather
+![Weather UI](/doc/gettingStarted/AppsScreenshots/Weather.png)
+- This app shows weather info.
+    - Please note that this app is not very useful without a device connected.

doc/gettingStarted/Watchfaces.md

@@ -0,0 +1,31 @@
+# Watchfaces
+
+InfiniTime has 6 apps on the `main` branch at the time of writing.
+
+## List of apps
+- Digital
+- Analog
+- PineTimeStyle
+- Terminal
+- Infinineat
+- Casio G7710
+
+### Digital
+![Digital face](/doc/gettingStarted/Watchfaces/Digital.png)
+
+### Analog
+![Analog face](/doc/gettingStarted/Watchfaces/Analog.png)
+
+### PineTimeStyle
+![PineTimeStyle face](/doc/gettingStarted/Watchfaces/PineTimeStyle.png)
+    - You can long-press on the display to change colors, step style, and weather.
+
+### Terminal
+![Terminal face](/doc/gettingStarted/Watchfaces/Terminal.png)
+
+### Infinineat
+![Infinineat face](/doc/gettingStarted/Watchfaces/Infinineat.png)
+    - You can long-press on the display to change colors.
+
+### Casio G7710
+![Casio G7710 face](/doc/gettingStarted/Watchfaces/CasioG7710.png)

doc/gettingStarted/about-software.md

@@ -0,0 +1,26 @@
+# Firmware, InfiniTime, Bootloader, Recovery firmware, OTA, DFU... What is it?
+
+You may have already encountered these words by reading the announcement, release notes, or [the wiki guide](https://wiki.pine64.org/wiki/Upgrade_PineTime_to_InfiniTime_1.0.0) and you may find them confusing if you're not familiar with the project.
+
+A **firmware** is software running on the embedded hardware of a device.
+
+InfiniTime has three distinct firmwares:
+
+- **[InfiniTime](https://github.com/InfiniTimeOrg/InfiniTime)** is the operating system.
+- **[The bootloader](https://github.com/JF002/pinetime-mcuboot-bootloader)** is responsible for safely applying firmware updates and runs before booting into InfiniTime.
+- **The recovery firmware** is a special *application firmware* than can be loaded by the bootloader on user request. This firmware can be useful in case of serious issue, when the main application firmware cannot perform an OTA update correctly.
+
+**OTA** (**O**ver **T**he **A**ir) refers to updating of the firmware over BLE (**B**luetooth **L**ow **E**nergy). This is a functionality that allows the user to update the firmware on their device wirelessly.
+
+**DFU** (**D**evice **F**irmware **U**pdate) is the file format and protocol used to send the update of the firmware to the watch over-the-air. InfiniTime implements the (legacy) DFU protocol from Nordic Semiconductor (NRF).
+
+## Bootloader
+
+Most of the time, the bootloader just runs without your intervention (updating and loading the firmware).
+
+However, you can use the bootloader to rollback to the previous firmware, or load the recovery firmware using the push button:
+
+- Press and hold the button until the pine cone is drawn in **blue** to force the rollback of the previous version of the firmware, even if you've already validated the current one.
+- Press and hold the button until the pine cone is drawn in **red** to load the recovery firmware. This recovery firmware only provides BLE connectivity and OTA functionality.
+
+More info about the bootloader in [its project page](https://github.com/JF002/pinetime-mcuboot-bootloader/blob/master/README.md).

doc/gettingStarted/gettingStarted-1.0.md

@@ -0,0 +1,57 @@
+# Getting started with InfiniTime
+
+On April 22, 2021, InfiniTime and Pine64 [announced the release of InfiniTime 1.0.0](https://www.pine64.org/2021/04/22/its-time-infinitime-1-0/) and the availability of PineTime smartwatches as an *enthusiast grade end-user product*. This page aims to guide you with your first step with your new PineTime.
+
+It is highly recommended to update the firmware to the latest version when you receive your watch and when a new InfiniTime version is released. More information on updating the firmware [here](/doc/gettingStarted/updating-software.md).
+
+## InfiniTime quick user guide
+
+### Setting the time
+
+By default, InfiniTime starts on the digital watch face. It'll probably display the epoch time (1 Jan 1970, 00:00).
+
+You can sync the time using companion apps.
+
+- Gadgetbridge automatically synchronizes the time when you connect it to your watch. More information on Gadgetbridge [here](/doc/gettingStarted/ota-gadgetbridge.md)
+- [Sync the time with NRFConnect](/doc/gettingStarted/time-nrfconnect.md)
+- [Sync the time with your browser](https://hubmartin.github.io/WebBLEWatch/)
+
+You can also set the time in the settings without a companion app. (version >1.7.0)
+
+InfiniTime doesn't handle daylight savings automatically, so make sure to set the correct time or sync it with a companion app.
+
+### Digital watch face
+
+![Digital watch face](ui/watchface.jpg)
+
+This is what the default digital watch face looks like. You can change watch faces in the settings.
+
+The indicator on the top left is visible if you have unread notifications
+
+On the top right, there are status icons
+
+- The battery icon shows roughly how much charge is remaining
+- The Bluetooth icon is visible when the watch is connected to a companion app
+- A plug icon is shown when the watch is plugged into a charger.
+
+On the bottom left, you can see your heart rate if you have the measurement enabled in the heart rate app.
+
+On the bottom right, you can see how many steps you have taken today.
+
+### Navigation in the menu
+
+![Application menu](ui/applist.jpg)
+![Notifications](ui/notifications.jpg)
+![Quick actions](ui/quicksettings.jpg)
+![Settings](ui/settings.jpg)
+
+- Swipe **up** to display the application menus. Apps (stopwatch, music, step, games,...) can be started from this menu.
+- Swipe **down** to display the notification panel. Notifications sent by your companion app will be displayed here.
+- Swipe **right** to display the Quick Actions menu. This menu allows you to
+  - Set the brightness of the display
+  - Start the **flashlight** app
+  - Enable/disable notifications (Do Not Disturb mode)
+  - Enter the **settings** menu
+    - Swipe up and down to see all options
+- Click the button to go back a screen.
+- You can hold the button for a short time to return to the watch face. (version >1.7.0)