<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        
        
        <!-- This is broken by doc revisioning.
         -->
        <link rel="shortcut icon" href="../../../img/favicon.ico">

        <title>BLE Bare Bones Application - Apache Mynewt</title>

        <link href="../../../css/bootstrap-3.0.3.min.css" rel="stylesheet">
        <link rel="stylesheet" href="../../../css/highlight.css">
        <link href="../../../css/base.css" rel="stylesheet">
        <link href="../../../css/custom.css" rel="stylesheet">
        <link href="../../../css/v2.css" rel="stylesheet">
        <link href="https://fonts.googleapis.com/css?family=Lato" rel="stylesheet">
        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">

        <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
        <!--[if lt IE 9]>
            <script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
            <script src="https://oss.maxcdn.com/libs/respond.js/1.3.0/respond.min.js"></script>
        <![endif]-->

        
            <script>
            (function(i, s, o, g, r, a, m) {
    i["GoogleAnalyticsObject"] = r;
    (i[r] =
        i[r] ||
        function() {
            (i[r].q = i[r].q || []).push(arguments);
        }),
        (i[r].l = 1 * new Date());
    (a = s.createElement(o)), (m = s.getElementsByTagName(o)[0]);
    a.async = 1;
    a.src = g;
    m.parentNode.insertBefore(a, m);
})(window, document, "script", "//www.google-analytics.com/analytics.js", "ga");

ga("create", "UA-72162311-1", "auto");
ga("send", "pageview");
</script>
        
    </head>


    <body class="BLE Bare Bones Application">


        <div class="container">
    <div class="row v2-main-banner">
        <a class="logo-cell" href="/">
            <img class="logo" src="/img/logo.png">
        </a>
        <div class="tagline-cell">
            <h4 class="tagline">An OS to build, deploy and securely manage billions of devices</h4>
        </div>
        <div class="news-cell">
            <div class="well">
                <h4>Latest News:</h4> <a href="/download">Apache Mynewt 1.12.0, Apache NimBLE 1.7.0 </a> released (April 4, 2024)
            </div>
        </div>
    </div>
</div>

        






<nav id="navbar" class="navbar navbar-inverse affix-top" data-spy="affix" data-offset-top="150" role="navigation">
    <div class="container">
        <!-- Collapsed navigation -->
        <div class="navbar-header">
            <!-- Expander button -->
            <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
                <span class="sr-only">Toggle navigation</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>

        </div>

        <!-- Expanded navigation -->
        <div class="navbar-collapse collapse">
            <!-- Main navigation -->
            <ul class="nav navbar-nav navbar-right">
                <li 
  class=""
>
                    <a href="/"><i class="fa fa-home" style="font-size: larger;"></i></a>
                </li>
                <li 
  class="important"
>
                    <a href="/quick-start/">Quick Start</a>
                </li>
                <li 
  class=""
>
                    <a href="/about/">About</a>
                </li>
                <li 
  class=""
>
                    <a href="/talks/">Talks</a>
                </li>
                <li 
  class="active"
>
                    <a href="/documentation/">Documentation</a>
                </li>
                <li 
  class=""
>
                    <a href="/download/">Download</a>
                </li>
                <li 
  class=""
>
                    <a href="/community/">Community</a>
                </li>
                <li 
  class=""
>
                    <a href="/events/">Events</a>
                </li>
            </ul>

        </div>
    </div>
</nav>

        

        <div class="container">
            
                <div class="row">
                    <div class="col-md-3 v2-sidebar sidebar-container"><div id="docSidebar" class="hidden-print" role="complementary">
    <div class="top">
        <div role="search">
            <form id="rtd-search-form" class="wy-form" action="../../../search.html" method="get">
                <div class="form-group">
                    <input type="text" name="q" class="form-control" placeholder="Search documentation" />
                </div>
            </form>
        </div>
    </div>
    <ul class="toc-nav">
      <li class="doc-version"><select class="form-control" onchange="if (this.value) window.location.href=this.value">
  <option value="/latest">
    Version: master
  </option>
  <option value="/v1_12_0/" >
    Version: 1.12.0
  </option>
  <option value="/v1_11_0/" >
    Version: 1.11.0
  </option>
  <option value="/v1_10_0/" >
    Version: 1.10.0
  </option>
  <option value="/v1_9_0/" >
    Version: 1.9.0
  </option>
    <option value="/v1_8_0/" >
    Version: 1.8.0
  </option>
  <option value="/v1_7_0/" >
    Version: 1.7.0
  </option>
  <option value="/v1_6_0/" >
    Version: 1.6.0
  </option>
  <option value="/v1_5_0/" >
    Version: 1.5.0
  </option>
  <option value="/v1_4_0/" >
    Version: 1.4.0
  </option>
  <option value="/v1_3_0/os/introduction" selected="selected" >
    Version: 1.3.0
  </option>
  <option value="/v1_2_0/os/introduction" >
    Version: 1.2.0
  </option>
  <option value="/v1_1_0/os/introduction" >
    Version: 1.1.0
  </option>
  <option value="/v1_0_0/os/introduction" >
    Version: 1.0.0
  </option>
  <option value="/v0_9_0/os/introduction" >
    Version: 0.9.0
  </option>
</select></li>
      
        
      
        
      
        
      
        
      
        
      
        
      
        
      
        
      
        
      
        
          
  
  
    <li ><a href="../../introduction/">Mynewt Documentation</a>
  
  
    <ul>
          
              
          
              
                
  
  
    <li ><a href="../../get_started/get_started/">Basic Setup</a>
  
  
    </li>

              
          
              
                
  <li >
    <a href="../../get_started/vocabulary/">Concepts</a>
  </li>

              
          
              
                
  
  
    <li ><a href="../tutorials/">Tutorials</a>
  
  
    <ul>
          
              
          
              
                
  
  
    <li ><a href="../blinky/">Project Blinky</a>
  
  
    </li>

              
          
              
                
  
  
    <li ><a href="../repo/add_repos/">Work with repositories</a>
  
  
    </li>

              
          
              
                
  
  
    <li ><a href="../project-slinky/">Project Slinky for Remote Comms</a>
  
  
    </li>

              
          
              
                
  
  
    <li><a href="
  ./
">Bluetooth Low Energy</a>
  
  
    <ul>
          
              
                
  <li class="active">
    <a href="./">BLE Bare Bones Application</a>
  </li>

              
          
              
                
  <li >
    <a href="../ibeacon/">BLE iBeacon</a>
  </li>

              
          
              
                
  <li >
    <a href="../eddystone/">BLE Eddystone</a>
  </li>

              
          
              
                
  
  
    <li ><a href="../bleprph/bleprph-intro/">BLE Peripheral Project</a>
  
  
    </li>

              
          
              
                
  <li >
    <a href="../blehci_project/">BLE HCI interface</a>
  </li>

              
          
    </ul>
  
    </li>

              
          
              
                
  
  
    <li><a href="
  ../lora/lorawanapp/
">LoRa</a>
  
  
    </li>

              
          
              
                
  
  
    <li><a href="
  ../event_queue/
">OS Fundamentals</a>
  
  
    </li>

              
          
              
                
  
  
    <li><a href="
  ../add_newtmgr/
">Remote Device Management</a>
  
  
    </li>

              
          
              
                
  
  
    <li><a href="
  
  
  ../sensors/sensors/

">Sensors</a>
  
  
    </li>

              
          
              
                
  
  
    <li><a href="
  ../segger_rtt/
">Tooling</a>
  
  
    </li>

              
          
              
                
  
  
    <li><a href="
  ../codesize/
">Other</a>
  
  
    </li>

              
          
    </ul>
  
    </li>

              
          
              
                
  
  
    <li ><a href="../../os_user_guide/">OS User Guide</a>
  
  
    </li>

              
          
              
                
  
  
    <li><a href="
  ../../../network/ble/ble_intro/
">BLE User Guide</a>
  
  
    </li>

              
          
              
                
  
  
    <li ><a href="../../../newt/newt_intro/">Newt Tool Guide</a>
  
  
    </li>

              
          
              
                
  
  
    <li ><a href="../../../newtmgr/overview/">Newt Manager Guide</a>
  
  
    </li>

              
          
              
                
  <li >
    <a href="../../../known_issues/">Known Issues</a>
  </li>

              
          
    </ul>
  
    </li>

        
      
        
          
  
  
    <li><a href="
  ../../../newt/install/prev_releases/
">Appendix</a>
  
  
    </li>

        
      
    </ul>
</div></div>

                    <div class="col-md-9" role="main">
                        <div class="doc-header">
                            <div role="navigation" aria-label="breadcrumbs navigation">
  <ul class="wy-breadcrumbs">
    <li><a href="/documentation/">Docs</a></li>
    
    
        
          <li>&raquo; Bluetooth Low Energy</li>
        
      
        
          <li>&raquo; <a href="os/tutorials/tutorials/">Tutorials</a></li>
        
      
        
          <li>&raquo; <a href="os/introduction/">Mynewt Documentation</a></li>
        
      
      
        <li>&raquo; BLE Bare Bones Application</li>
      
    
    
      <li class="wy-breadcrumbs-aside">
        
          <a href="https://github.com/apache/mynewt-site/blob/master/docs/os/tutorials/ble_bare_bones.md"
            class="icon icon-github"> Edit on GitHub</a>
        
      </li>
    
  </ul>
</div>
                        </div>
                        
                          
                        
                          
                        
                          
                        
                          
                        
                          
                        
                          
                        
                          
                            <div class="alert alert-warning">
                                <p>
                                    Version 1.3.0 is not the most recent version of the Apache Mynewt
                                    documentation. Click <a href="/latest">here</a> to read the latest
                                    version.
                                </p>
                            </div>
                          
                        
                        
                            <h2 id="set-up-a-bare-bones-nimble-application">Set up a bare bones NimBLE application</h2>
<p>This tutorial explains how to set up a minimal application using the NimBLE
stack.  This tutorial assumes that you have already installed the newt tool and are familiar with its concepts.</p>
<h3 id="create-a-mynewt-project">Create a Mynewt project</h3>
<p>We start by creating a project space for your own application work using the
Newt tool.  We will call our project <code>my_proj</code>.</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev$ newt new my_proj1
Downloading project skeleton from apache/mynewt-blinky...
Installing skeleton in my_proj1...
Project my_proj1 successfully created.
</code></pre></div>

<p>The above command created the following directory tree:</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev$ tree my_proj1
my_proj1
├── DISCLAIMER
├── LICENSE
├── NOTICE
├── README.md
├── apps
│   └── blinky
│       ├── pkg.yml
│       └── src
│           └── main.c
├── project.yml
└── targets
    ├── my_blinky_sim
    │   ├── pkg.yml
    │   └── target.yml
    └── unittest
        ├── pkg.yml
        └── target.yml

6 directories, 11 files
</code></pre></div>

<p>Next, we need to retrieve the Mynewt repositories that our app will depend on.
When you retrieve a repository, your project gains access to the libraries and
applications that the repo contains.</p>
<p>A new project automatically depends on the Apache Mynewt core repo
(<code>apache-mynewt-core</code>).  The core repo contains the Apache Mynewt operating
system, NimBLE stack, and other system libraries.  Later, our app may need
packages from additional repos, but for now the core repo suits our needs.</p>
<p>We download the dependent repos using the <code>newt install</code> command:</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev$ cd my_proj1
~/dev/my_proj1$ newt install
apache-mynewt-core
</code></pre></div>

<p>Now it's time to create your own app.</p>
<h3 id="create-an-application-package">Create an application package</h3>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev/my_proj1$ newt pkg new apps/ble_app -t app
Download package template for package type app.
Package successfully installed into /home/me/dev/my_proj1/apps/ble_app.
</code></pre></div>

<p>You now have an application called <code>apps/ble_app</code>.  It isn't terribly
interesting as far as applications go, but it does all the configuration and
set up required of a Mynewt app.  It will be a useful starting point for our
BLE application.</p>
<h3 id="create-the-target">Create the target</h3>
<p>Now you have to create the target that ties your application to a BSP.  We will
call this target "ble_tgt".</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev/my_proj1$ newt target create ble_tgt
Target targets/ble_tgt successfully created
</code></pre></div>

<p>We now have a new target:</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev/my_proj1]$ tree targets/ble_tgt
targets/ble_tgt
├── pkg.yml
└── target.yml
</code></pre></div>

<p>We need to fill out a few details in our target before it is usable.  At a
minimum, a target must specify three bits of information:</p>
<ul>
<li>Application pacakge</li>
<li>BSP package</li>
<li>Build profile</li>
</ul>
<p>The application package is straightforward; this is the ble_app package that we
created in the previous step.</p>
<p>For the BSP package, this tutorial chooses to target the nRF52dk BSP.  If you
would like to use a different platform, substitute the name of the appropriate
BSP package in the command below.</p>
<p>Finally, the build profile specifies the set of compiler and linker options to
use during the build.  Apache Mynewt supports two build profiles: <code>debug</code> and
<code>optimized</code>.</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev/my_proj1$ newt target set ble_tgt     \
    app=apps/ble_app                        \
    bsp=@apache-mynewt-core/hw/bsp/nrf52dk  \
    build_profile=optimized
Target targets/ble_tgt successfully set target.app to apps/ble_app
Target targets/ble_tgt successfully set target.bsp to @apache-mynewt-core/hw/bsp/nrf52dk
Target targets/ble_tgt successfully set target.build_profile to optimized
</code></pre></div>

<h3 id="enter-ble">Enter BLE</h3>
<p>Since our application will support BLE functionality, we need to give it access
to a BLE stack.  We do this by adding the necessary NimBLE packages to the
app's dependency list.  To enable a combined host-controller in the app, add
dependencies for the NimBLE controller, host, in-RAM transport, and persistence store to <code>apps/ble_app/pkg.yml</code>:</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>pkg.deps:
    - &quot;@apache-mynewt-core/kernel/os&quot;
    - &quot;@apache-mynewt-core/sys/console/full&quot;
    - &quot;@apache-mynewt-core/sys/log/full&quot;
    - &quot;@apache-mynewt-core/sys/stats/full&quot;
<span style="background-color: #ffffcc">    - &quot;@apache-mynewt-core/net/nimble/controller&quot;
</span><span style="background-color: #ffffcc">    - &quot;@apache-mynewt-core/net/nimble/host&quot;
</span><span style="background-color: #ffffcc">    - &quot;@apache-mynewt-core/net/nimble/host/store/config&quot;
</span>    - &quot;@apache-mynewt-core/net/nimble/transport/ram&quot;
</code></pre></div>

<p><strong>Important note:</strong> The controller package affects system configuration, see
<a href="../../../network/ble/ble_setup/ble_lp_clock/">this page</a> for details.</p>
<h3 id="build-the-target">Build the target</h3>
<p>Now would be a good time for a basic sanity check.  Let's make sure the target builds.</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev/my_proj1$ newt build ble_tgt
Building target targets/ble_tgt
Compiling repos/apache-mynewt-core/hw/hal/src/hal_common.c
Compiling repos/apache-mynewt-core/hw/drivers/uart/src/uart.c
&lt;...snip...&gt;
Linking /home/me/dev/my_proj1/bin/targets/ble_tgt/app/apps/ble_app/ble_app.elf
Target successfully built: targets/ble_tgt
</code></pre></div>

<p>Now let's try running our minimal application on actual hardware.  Attach the target device to your computer and run the application with <code>newt run</code>:</p>
<div class="codehilite" style="background: #ffffff"><pre style="line-height: 125%;"><span></span><code>~/dev/my_proj1$ newt run ble_tgt 0
App image succesfully generated: /home/me/dev/my_proj1/bin/targets/ble_tgt/app/apps/ble_app/ble_app.img
&lt;...snip...&gt;
Resetting target
[Switching to Thread 57005]
0x000000dc in ?? ()
(gdb)
</code></pre></div>

<p>You can start the application by pressing <code>c &lt;enter&gt;</code> at the gdb prompt.  When the excitement of watching the idle loop run wears off, quit gdb with <code>&lt;ctrl-c&gt; q &lt;enter&gt;</code>.</p>
<p>If your target fails to build or run, you might want to revisit the <a href="../../../os/tutorials/blinky/">project
blinky tutorial</a> to see if there is a setup
step you missed.  You may also find help by posting a question to the <a href="../../../community/">mailing
list</a> or searching the archives.</p>
<h3 id="conclusion">Conclusion</h3>
<p>You now have a fully functional BLE app (never mind that it doesn't actually do
anything yet!).  With all the necessary infrastructure in place, you can now
start turning this into a real application.  A good next step would be to turn
your app into a beaconing device.  The
<a href="../../../os/tutorials/ibeacon/">BLE iBeacon tutorial</a> builds on this one and
ends with a functioning iBeacon.  For something a little more ambitious, the
<a href="../../../os/tutorials/bleprph/bleprph-intro/">BLE peripheral project tutorial</a>
describes a NimBLE peripheral application in detail.</p>
                        
                        <div class="row">
                            



<ul class="nav nav-pills" style="margin-bottom: 10px">
    <li>
    
    </li>
    <li class="pull-right">
    
    </li>
</ul>
                        </div>
                        <footer class="row">
    <div class="col-xs-12">
        
            <p class="copyright">Apache Mynewt is available under Apache License, version 2.0.</p>
        
    </div>
    <div class="col-xs-12">
        <div class="logos">
            <a href="https://www.apache.org/">
                <img src="/img/asf_logo_wide_small.png" alt="Apache" title="Apache">
            </a>
            <p>
                Copyright © 2015-2021 The Apache Software Foundation.<br>
                <small class="footnote">
                    Apache Mynewt, Mynewt, Apache, the Apache feather logo, and the Apache Mynewt
                    project logo are either registered trademarks or trademarks of the Apache
                    Software Foundation in the United States and other countries.
                </small>
            </p>
            <a href="">
                <img src="https://www.countit.com/images/add_to_slack.png" alt="Slack Icon" title="Join our Slack Community" />
            </a>
        </div>
    </div>
    <a href="https://www.apache.org/licenses/">
        <button class="button-footer-asf">
            License
        </button>
    </a>
    <a href="https://www.apache.org/foundation/sponsorship.html">
        <button class="button-footer-asf">
            Sponsorship
        </button>
    </a>
    <a href="https://www.apache.org/foundation/thanks.html">
        <button class="button-footer-asf">
            Thanks
        </button>
    </a>
    <a href="https://www.apache.org/security/">
        <button class="button-footer-asf">
            Security
        </button>
    </a>
    <a href="https://apache.org/events/current-event">
        <button class="button-footer-asf">
            ASF Events
        </button>
    </a>
</footer>
                    </div>
                </div>
            
            
        </div>

        <script src="../../../js/jquery-1.10.2.min.js"></script>
        <script src="../../../js/bootstrap-3.0.3.min.js"></script>
        <script src="../../../js/highlight.pack.js"></script>
        <script src="../../../js/base.js"></script>
        <script src="../../../js/custom.js"></script>
            <script src="search/main.js"></script>

    </body>
</html>