Website:
http://www.coocox.org
Forum:
http://forum.coocox.org
Technical: master@coocox.com
Market:
market@coocox.com
Catalog
1
2.1.1
2.1.2
2.2
2.2.2
Preparation ...................................................................................................................... 19
3.1
3.1.1
3.1.2
3.2
4
2.2.1
2.3
3
4.1.1
4.1.2
4.1.3
4.1.4
4.1.5
4.1.6
4.1.7
4.1.8
4.2
Toolbar ..................................................................................................................... 26
4.2.1
4.2.2
4.3
4.3.1
Breakpoint ........................................................................................................ 28
4.3.2
Components ..................................................................................................... 28
4.3.3
Console ............................................................................................................. 28
4.3.4
Configuration .................................................................................................... 30
4.3.5
Editor ................................................................................................................ 34
4.3.6
Help................................................................................................................... 35
4.3.7
4.3.8
Outline .............................................................................................................. 37
4.3.9
Peripheral ......................................................................................................... 38
4.3.10
4.3.11
Repository......................................................................................................... 40
4.3.12
Search ............................................................................................................... 40
4.4
4.4.1
Breakpoints ....................................................................................................... 42
4.4.2
Debug................................................................................................................ 43
4.4.3
Disassembly ...................................................................................................... 44
4.4.4
Expressions ....................................................................................................... 46
4.4.5
Memory ............................................................................................................ 47
4.4.6
4.4.7
Registers ........................................................................................................... 50
4.4.8
4.4.9
Variables ........................................................................................................... 52
Create Project........................................................................................................... 55
5.2
5.2.1
5.3
Project configuration................................................................................................ 62
5.3.1
Change device................................................................................................... 62
5.3.2
5.3.3
5.3.4
5.3.5
5.3.6
5.3.7
5.4
5.5
6
Debug .............................................................................................................................. 74
6.1
Introduction ............................................................................................................. 74
6.1.1
6.1.2
6.1.3
6.1.4
Single step......................................................................................................... 74
6.1.5
6.2
6.2.1
6.2.2
6.2.3
Components ............................................................................................................. 83
7.1.1
7.1.2
7.2
Examples .................................................................................................................. 89
7.2.1
7.2.2
2.
Select your target chip, e.g. MKL25Z128VLK4, and then the Help view on the right side
of CoIDE will show corresponding information of the chip.
3.
Check/Select the components which you want to use, e.g. xGPIO component, CoIDE will
ask you to create a new project.
4.
After clicking "Yes", CoIDE will pop up a window for you to specify where to save the
project.
5.
Select an English path, e.g. the "workspace" folder under the CoIDE installation path,
and then create a new folder such as "test" to save your project.
6.
7.
After clicking "Save", CoIDE will create a project for you, containing manually-selected
component code in step 3, auto-selected components code depended on by manuallyselected component (e.g. the startup component), as well as a main.c file.
8.
9.
The Components view shows all selected components and the example number of each
component. Click a component and its Example window will popup.
10. Click view to view the example (e.g. Blinky) and add to add it to your project.
11. Click Yes to confirm adding the example to the default path.
12. CoIDE will add the Blinky.c file to the project, and the Blinky function to the main
fuction.
18. If debugging is launched successfully, CoIDE will enter the debug mode.
19. The default debug UI only shows several debug windows, you can open the other debug
windows through view menu.
21. Use the debug functions like single stepping via the tool bar or debug menu.
2 General Introduction
CoIDE is a new, free and highly integrated software development environment for ARM
Cortex MCU based microcontrollers, which includes all the tools necessary to develop highquality software solutions in a timely and cost effective manner.
2.1.1
Free to use
Full functional IDE
Component-oriented development platform
Internet-based, efficient integration of network resources
Integrates CoOS
Peripheral registers
Terminology Note
2.1.1.1 Component
In CoIDE, any reusable code can be called as a component, including OS, drivers, examples,
middle layer software and so on. It is easy to understand and use by providing useful
functions, and most importantly, can work correctly. Each component has its corresponding
code snippets, usage, documentation and comments.
2.1.1.2 Dependence
If component A calls the content of component B (known as Compilation Dependence), or
component A cannot correctly execute without component B (known as Application
Dependence). We call component A depends on component B. When you check component
A, CoIDE will automatically check the dependence components of component A. One
component can depend on several components. It can be depended by multiple
components, too.
2.1.1.3 Code Snippet
Code Snippet is also known as example code, it is an extension of component. If the
component is object-oriented, the code snippet will be application-oriented. For example, a
PIO driver can be known as a component, a function using PIO driver to achieve LED flashing
can be known as a code snippet. The code snippet is generally very short, but the features
are not restricted. It can be automatically inserted into the code.
2.1.2
CoIDE Features
CoIDE can be used for code editing, code browsing, compiling, linking, debugging, project
management; it also can be used to obtain components, to share components and to
exchange ideas.
2.1.2.1 Component Network
Component Network contains a large amount of free components, the components are
provided by CooCox and CooCox users. CooCox has provided RTOS, flash manager,
embedded database, protocol stack and other components, which are all free and open.
Everyone can use these components and upload their own components.
2.1.2.2 Component Oriented Programming
In embedded application development, if there is no suitable libraries, development work
will become very complicated. Once you have the suitable libraries, anything will be
manipulated in your hands. CooCox CoIDE Component Network contains a large amount of
free components, users can choose suitable components according to your own needs, and
use the component code snippets to build application will become more quickly. With a
large number of components and detailed component documentation, programming will be
as simple as building block.
2.1.2.3 Component Documentation
Each component has a detailed documentation (displayed in the Help View), including
component description, component dependency relationship, component source files, usage
of the component, comments and so on. CoIDE automatically generates documentation for
source files. If the code comment style is consistent with Doxygen, the documentation will
be very detailed. Moreover, the detailed documentation allows you to use the component
more quickly.
2.1.2.4 Interaction
In order to help users to solve the problems encountered in development process, CoIDE
provides a powerful interaction function. In CooCox CoIDE, everything can interact, such as
chip, component, peripheral, register, code snippet and so on; users can even ask questions
directly to solve their problems.
2.1.2.5 Development Environment
CoIDE is based on the Eclipse development platform, it has the following features:
Integrated CDT editor: You can edit and browse the code; it is a full-featured editor.
Integrated GCC ARM Embedded: Using gcc tool chain, which is efficient and stable.
A clear interface: Menus and toolbar are simple, clear and easy to use.
GUI Setting: Dialogs for all settings.
Support Devices
CooCox CoIDE mainly supports ARM Cortex M series. Until now, CooCox has supported
Cortex-M4, Cortex-M3, Cortex-M0 and Cortex-M0 plus chips from Atmel, Energy Micro,
Freescale, Holtek, NXP, Nuvoton, ST and TI. For the entire support list, you can go to:
http://www.coocox.org/CooCox_CoIDE.htm
Here we list the Freescale chips that are supported by the newest version of CoIDE (v 1.6.2):
2.2.2
Supported Adapters
Available Devices
CoLinkEx
Open-SDA
Freescale
Hardware requirements:
Software requirements:
3 Preparation
3.1 Set GCC Compiler
Before you use CoIDE to start your project, you need to configure the GCC compiler and
debugger at first.
CooCox suggests you to choose ARM GCC Compiler as the compiler since it is from ARM
official. If you want to know more details about ARM GCC, please click here. In addition, you
can also choose other GCC compilers such as CodeSourcery GCC.
3.1.1
Features:
The different compilers have different C libraries, for example: ARM GCC have base C
Library and Semihosting Library, Retarget Library. However, CodeSourcery GCC only has
the base C Library. See: Project Configuration
ARM GCC and CodeSourcery GCC use different link.ld when they compile the same
project. CoIDE will generate different link.ld when you create the project, so it is
strongly recommended of you to set the GCC compiler before you start.
If you want to use ARM GCC to compiler the project you created under CodeSourcery
GCC, you need to delete the Build.xml, link.ld, memory.ld. Then check a component
and reconfigure the project after set the GCC.
3.1.2
1.
After launched CooCox CoIDE, click "Select Toolchain Path" under the Project menu.
2.
Click the Browse button, select the folder that contains the arm-none-eabi-gcc.exe and
the other GCC execute files.
3.
4.
4 User Interface
4.1 Menus and Actions
4.1.1
Name
Description
Shortcut
New File
Ctrl + Shift + N
Save
Save the content of the current editor. Disabled if the editor does
not contain unsaved changes.
Ctrl + S
Save As...
Save All
Exit
Exit CoIDE.
4.1.2
Ctrl + Shift + S
Name
Description
Shortcut
Undo
Ctrl + Z
Cut
Ctrl + X
Copy
Ctrl + C
Paste
Ctrl + V
4.1.3
Description
Repository
Configuration
Project
Components
Help
Outline
Peripherals
Breakpoints
Default layout
Shortcut
4.1.4
Name
Description
New Project
Shortcut
Open Project... Show a dialog that can be used to select an existing project.
Close Project
Select
Select the GCC Toolchain you want to use.
Toolchain path
Build the currently selected project. This is an incremental build, meaning
Build
that the builder analyzes the changes since the last time of build and
minimizes the number of changed files.
Ctrl +
R
Rebuild
Clean
Upload
Component
Open the Login dialog box, you can upload Component after login with
CooCox account.
Upload Board
You can upload development board after login with CooCox account.
Upload
Example
You can upload component examples after login with CooCox account.
4.1.5
Description
Program Download
Flash Erase
Erase Flash.
4.1.6
F7
Shortcut
Description
Shortcut
Debug
Ctrl+F5
Toggle Breakpoint
Ctrl +Shift+ B
Breakpoint Type
Breakpoint Type
4.1.7
Name
Description
Search...
File...
4.1.8
Shortcut
Ctrl + H
Name
Description
Shortcut
4.2 Toolbar
4.2.1
Icons
Name
Description
New Project
Save
Build
Shortcut
Ctrl + S
F7
Rebuild
Ctrl + R
Start Debug.
Ctrl + F5
Download Code
to Flash
Flash Erase
Configuration
Target Manage
Repository
Open Element
Ctrl +Shift +T
Search
Ctrl + H
Toggle Mark
Occurrences
Next Annotation
Ctrl +.
Previous
Annotation
Ctrl + ,
Ctrl + Q
Back to...
Alt + Left
Forward to...
Alt + Right
Alt+Shift+0
4.2.2
Icons
Name
Description
Shortcut
Open Element
Ctrl +Shift +T
Search
Ctrl + H
Toggle Mark
Occurrences
Next Annotation
Ctrl + R
Alt+Shift+0
Ctrl +.
Ctrl + ,
Ctrl + Q
Back to...
Alt + Left
Forward to...
Alt + Right
4.3.1
Breakpoint
This view shows the information of breakpoints set by user in the code.
4.3.2
Components
This view displays all the components of the
current project selection. If you click a
component in this view:
4.3.3
Console
This view shows the output of the execution of your program and enables you to enter input
for the program.
Description
Pin Console
Open Console
Clear Console
Scroll Lock
4.3.4
Configuration
1.
The following pictures show the different pages: The Device configuration
2.
3.
4.
5.
6.
7.
4.3.5
Editor
The C/C++ editor provides specialized features for editing C/C++ related files.
The most common way to invoke the C/C++ editor is to open a file from the Project Explorer
by clicking the file (single or double-click depending on the user preferences).
The C/C++ editor just have the context menu (right click your mouse in the editor view, the
context menu will be presented) and key binding actions.
4.3.6
Help
This view displays all information about the selected component, it always include the
following issues:
1.
2.
3.
4.
4.3.7
Help Contents
You can open the Help Contents through the Help Menu, which shows the help for use
CoIDE.
Toolbar
Icon
Name
Description
Availability
Go Back
Toolbar
Go Forward to
Toolbar
Home
Show in table of
content
Toolbar
Toolbar
Toolbar
Print Page
Toolbar
Print Topics
Context menu
Search Topics
Context menu
Collapse All
Context menu
Context menu
Show Result
Categories
Search Results
View
4.3.8
Show Result
Description
Delete Selected
Bookmark
Bookmark View
Bookmark View
Outline
Description
Icon
Description
Filters
Hide Fields
Group Includes
Group Macros
Group Methods
Group Namespaces
The table below lists the icons displayed in the Outline view.
Icon
Description
Icon
Description
Class
Include
Namespace
Method private
Macro Definition
Method protected
Enum
Method public
Enumerator
Struct
Variable
Type definition
Field private
Union
Field protected
Function
Field public
4.3.9
Peripheral
4.3.11 Repository
This view displays all available components in the project. The before the component
shows this component has been checked into the project. By checking or unchecking the
before components to add or delete the components.
4.3.12 Search
The Search view only shows when you have searched something in the project.
The type of the selected C/C++ element defines which search context menus are available.
The C/C++ editor does not constrain the list of available C/C++ searches based on the
selection.
Search view Toolbar:
Icon
Command
Next
Description
Navigate to the next search result.
Previous
Terminate
Menu
Minimize Console
Maximize Console
Breakpoints
The Breakpoints View lists all the breakpoints you have set in your workspace. Only up to six
breakpoints can be toggled if you are debugging in flash with Cortex-M3 series' chips, for
Cortex-M0, the number is four. Otherwise, warnings will be presented at runtime.
You can double-click a breakpoint to find its location in the editor (if applicable). You can
also enable or disable breakpoints, delete them, add new ones.
Name
Description
Availability
Context
menu and
view action
Context
menu and
view action
Remove Selected
Breakpoints
Show Breakpoints
Supported by Selected
Target
View action
Go to File
Context
menu and
view action
Skip All
View action
Expand All
View action
Collapse All
View action
View action
Add Event
Breakpoint(C/C++)...
View action
Add Watchpoints
(C/C++)...
View action
View action
Group By...
View action
4.4.2
View action
View action
View action
Context
menu
Context
menu
Context
menu
Context
menu
Context
menu
Context
menu
Context
menu
Context
menu
Select All
Copy
Paste
Import Breakpoints...
Export Breakpoints...
Breakpoint Properties...
Debug
1.
2.
The Debug view shows the target debugging information in a tree hierarchy.
The number beside the thread label is a reference counter, not a thread identification
number.
3.
The CDT displays stack frames as child elements. It displays the reason for the
suspension beside the thread, (such as end of stepping range, breakpoint hit, and signal
received). When a program exits, the exit code is displayed.
Name
Remove All
Terminated
Description
Clear all terminated processes in Debug view.
Step Into
Step Over
Step Return
Instruction
Stepping Mode
Resume
Suspend
Terminate
Terminate and
Relaunch
Restart
Disconnect
Relaunch
Edit...
Edit Source
Lookup...
Lookup Source
Terminate and
Remove
Terminate/Discon
nect All
Properties
4.4.3
Toggle step filters on/off. When on, all step functions apply step
filters.
Copy the selected stack of suspended threads as well as the state
of the running threads to the clipboard.
Terminate the selected debug target and removes it from the view.
Terminate all active launches in the view.
Open the Properties for window showing the process properties.
Disassembly
The Disassembly View shows the loaded program as assembler instructions mixed with
source code for comparison. The currently executing line is indicated by an arrow marker
and highlighted in the view. You can do the following tasks in the Disassembly view.
Name
Description
Availability
Copy
Context menu
Select All
Context menu
Show Source
Context menu
and View action
Show Symbols
Context menu
Preferences
Parameter selection.
Context menu
Run To Line
Context menu
Move to Line
Context menu
Resume At Line
4.4.4
Refresh View
View action
Go to Current
Program
Counter(Home)
View action
View action
View action
Pin to Debug
Context
View action
Expressions
An expression is a snippet of code that can be evaluated to produce a result. The context for
an expression depends on the particular debug model. Some expressions may need to be
evaluated at a specific location in the program so that the variables can be referenced. You
can view information about expressions in the Expressions view.
You can inspect expressions from a scrapbook page, a stack frame of a suspended thread,
and other places. The Expressions View opens automatically when an item is added to the
view. When debugging a C/C++ program, data that contains variables can be expanded to
show the variables and the fields of the variables.
Name
Description
Availability
View action
Show logic
structure
View action
Collapse All
View action
Add Watch
Expression
Remove
Remove All
View action
Pin to Debug
Context
4.4.5
View action
Refresh
Refresh.
View action
Select All
Context menu
Copy Expressions
Context menu
Find...
Context menu
Disable
Context menu
Enable
Context menu
Edit Watch
Expression
Context menu
Reevaluate
Expression
Context menu
Format
Context menu
Memory
The Memory view of the Debug perspective lets you monitor and modify your process
memory. Memory can be displayed in different predefined data formats -- memory
renderings. The CoIDE supports five rendering types -- hexadecimal (default), ASCII, signed
integer and unsigned integer.
The Memory view can display and modify the value of selected memory address. The
Rendering pane can be configured to display more than two renderings simultaneously.
Memory view toolbar icons:
The table below lists the icons displayed in the Memory view toolbar.
Command
Name
Description
New Tab
Go
Import
Export
Find/Replace
Find next
Clear Expressions
Description
Panes
Enable or disable the showing of the Address, Binary, and Text portions of the
rendering view.
Endian
Toggle between the Little (default) and Big Endian display of memory.
Text
Choose the character encoding used to convert memory values into text for display.
Choices include: ISO-8859-1 (default), US-ASCII, or UTF-8.
Cell Size
Specify the cell size used to display values in the Binary column. Choices include 1, 2,
4 (default), and 8 bytes.
Radix
Columns
Specify the radix used to display the values in the Binary column. Choices include
Hex, Decimal Signed, Decimal Unsigned (default), Octal, and Binary.
Specify the number of columns in the Binary column.
Update Mode Select the update mode of the Rendering pane: Always, On Breakpoints, or Manual.
Copy
Copies the selected portion (address, content or binary number) of the Rendering
pane to the clipboard.
Reset To Base
Reset the Rendering pane to the original base address.
Address
Refresh
4.4.6
The Peripherals View can be used to view and modify the value of Peripherals' registers.
Values that have changed are highlighted in the Peripherals view when your program stops.
It shows the register list and views the value of these registers. Register that have changed
are highlighted in in the Peripherals view.
Click the name of Register to open the detail information view. In this view, you can get the
description, RW access, address offset and the reset value of the register. You can modify
the value of register when you debug a project.
4.4.7
Registers
Name
Description
Show logic
structure
Collapse All
Pin to Debug
Context
Refresh
Refresh
Layout
Command
Name
Description
Select All
Copy Registers
Enable
Disable
Format
Find...
Change Value...
Restore Default
Register Groups
Add Watchpoints
(C/C++)...
Watch
4.4.8
Semihosting view
Semihosting view is used to show the information of the host computer and the ARM input
and output communication when running debug.
Name
Description
Clear Console
Scroll Lock
4.4.9
Name
Description
Cut
Copy
Paste
Select All
Find/Replace
Open Link
Clear
Scroll Lock
Variables
The Variables View displays information about the variables associated with the stack frame
selected in the Debug View. When debugging a C/C++ program, data that contains variables
can be expanded to show the variables and the fields the variables contain.
You can view information about the variables in a selected stack frame in the Variables view.
When execution stops, the changed values are by default highlighted . Like the other debug-
related views, the Variables view does not refresh as you run your executable. A refresh
occurs when execution stops.
Variables view
Name
Description
Availability
View action
View action
Collapse All
View action
Remove Global
Variables
View action
View action
Select All
Context menu
Copy Variables
Context menu
Enable
Context menu
Disable
Context menu
Cast To Type
Cast To Type
Context menu
View Memory
Context menu
Format
Context menu
Find...
Context menu
Change Value...
Context menu
Add
Watchpoints(C/C++)
Add Watchpoints(C/C++).
Context menu
Watch
Context menu
5 Project Management
5.1 Create Project
To create an embedded project using CoIDE, you only need to perform the following steps:
1. Select Project > New Project.
2.
Select any folder as a project file save directory, and fill in the name of the project file
(for example: GPIO_Test)
3.
4.
5.
Check a component. For example, select 'GPIO'. CoIDE will automatically check the
components, which are depended by the checked component.
6.
7.
You can also click Drivers to view the Driver pages and add the driver components to
your project.
There is one default configurations target after creating project: Flash configuration target.
In the project view, select the parent directory in which you want to create the Group (If you
do not select the parent directory, the default is the root directory of the project), select Add
Group in context menu:
Group edit box pops up, and you can add the Group.
Click Add Files menu item, you can add a link file to the project view:
Click the new file menu item, you can create a new file, as it is shown in the following figure
after clicking ''Save'' you can create a file and add the file to the project view as a link file.
Double click the file name in Project view to open and edit it.
5.3
Project configuration
Configuration area is divided into seven different configuration items: Device, Compile, Link,
Output, User, Debugger and Download. The first five configurations are building and linking
configurations, the last two are debugging/programming configurations.
5.3.1
Change device
2.
Select the target file you need to switch, and then click change device.
3.
4.
Click OK, then CoIDE will show you the following view. Peripherals view and all the
other views will be related to the new chip.
5.3.2
1)
Compile configuration
Option area:
a)
2)
FPU select MCU type: Not use FPU, FPU soft and FPU hard (Note: If you select the
FPU hard, you need to enable FPU module in the code)
b) Optimization Select the level of optimization(None(-O0), Optimize(-O1), Optimize
More(-O2), Optimize Most(-O3), Optimize Size(-Os))
Include paths area:
Add / Remove header files path
The added path will be relative to the current path of the project file to do deal.
3)
4)
5)
5.3.3
Link configuration
1) Options area:
a)
Allow recovery of unused input section. Segment that contains the entrance symbol, and all
the segments of undefined symbols in the command line will be retained. Segment that
contains a dynamic object reference symbol will also be retained. Check this option to
reduce code size.
c)
5.3.4
Output configuration
The files generated after build will be output to the directory made up of Path of
Executable+/+ Name of Executable.
1)
2)
3)
4)
Name of Executable: Specify the folder of the output files, the default is the
configuration name of the current project configuration;
Path of Executable: Specify the output file path
Create Executable(.elf) :: Generate .elf executable files, by check / uncheck decide
whether to generate the HEX or BIN file
Create Library(.a): Generate .a library file
5.3.5
User configuration
5.3.6
Debugger configuration
1) Hardware area
a)
Adapter: CoIDE supports Colink, CoLinkEx, Nu-Link, ST-Link, J-Link and Stellaris-ICDI
debug adapter.
b)
c)
Max Clock (Hz): You can select the clock frequency 2M, 1M, 500K, 300K and 100K.
2) Startup area
Need to check or uncheck Run to main.
3) Advance area
a)
Reset Mode: There are three reset modes: HW RESET, VECTRESET and SYSRESETREQ.
b)
c)
4) TargetInfo area
Target Info area displays the host name and port number.
5.3.7
Download configuration
1)
2)
3)
4)
5)
6)
7)
2.
2.
3.
6 Debug
6.1 Introduction
6.1.1
You can click the Debug button to start debug. After launching debug successfully,
CoIDE will come into debug mode.
The debug mode has a quiet different interface from edit mode, to learn more, you can go
to Chapter 4.4 Debug View
6.1.2
The debug execution controls are superseded by breakpoints. For example, if you attempt to
step over a function and the program hits a breakpoint, it pauses, regardless of whether the
function is completed. You can control your debug execution in various ways, but they all
rely on a core set of debug controls.
To control the debug session, you can use the buttons in the toolbar of debug mode.
Reference: Chapter 4.2.2 Debug Toolbar Actions
6.1.3
Set breakpoints
A breakpoint can be set on an executable line of the program. If the breakpoint is enabled
when you debug, the execution will suspend before the code of that line is executed.
To add a breakpoint point, you could double-click the marker bar located in the left margin
of the C/C++ Editor beside the line of code where you want to add a breakpoint. A dot
will display in the marker bar and in the Breakpoints View, along with the name of the
associated file.
6.1.4
Single step
CoIDE support two kinds of step modes: C code step and instruction step. C code step is the
default option.
C code step means step in c code area, while the instruction step means step each assembler
instructions.
To activate the instruction step mode, you just need to click the Instruction Stepping Mode
option ( ) on the Debug view toolbar. Then when you click the step button ( ), the
Debugger switches to the instruction stepping mode, the Disassembly view will be opened
automatically. If you want to switch back to c code step mode, click the Stepping Mode
option ( ) again.
2.
After launching debug successfully, CoIDE will come into debug mode.
3.
4.
Step in C code
5.
6.
End debug
6.2.1
Disassembly view
The Disassembly view lets you examine your program as it steps into disassembled code.
This is useful when the instruction pointer enters a function for which it does not have the
source. To open the Disassembly view, select View > Disassembly menu.
6.2.2
Memory view
To open the Memory view, select View > Memory menu. Input the memory address you
want to view, for example 0x20000000, then press Enter or click the Go button.
6.2.3
Variables view
1.
To open the Variables view select View > Variables menu. Click Add Global Variables to
add a global variable.
2.
Check the global variables you want to add, then click OK button.
3.
Right click on the variable and select the Change Value item to change the value of the
variable.
4.
Input the new value of the variable and click the OK button.
Add Components
When you have created a project and selected a chip, CoIDE will show you a Repository
View, which lists all the components that fit for the chip.
2.
3.
CoIDE will add the component and the dependent components to your project
automatically.
4.
You can also click the Driver page to view and add driver components, etc.
5.
6.
You can view the Doxygen documents for the component by click the related links in
help view.
7.
For the driver component, we have more documents that guide you to use.
7.1.2
1.
Click "Refresh Component List" button in the right corner of Repository View.
2.
CoIDE will pop up a dialog to remind you which components can be downloaded or
updated.
3.
The right side of repository view shows the components can be updated (or
downloaded) with the state Update (or Download).
4.
7.2 Examples
CoIDE integrates many infrastructure components, in order to allow users to use these
components more easily, each component can be corresponded to multiple sample code
fragments, you can view them and add them to your project, you also could upload your
own examples to the internet.
7.2.1
1.
Viewing example
Click the component which shows "with x example(s)" in the Component View of CoIDE.
2.
The example view will appear and display all the code snippets of the selected
component.
3.
4.
5.
You can click "More Example for xxx" to view more example for the selected chip.
6.
Other examples will show in more example view based on the component classification.
7.
Click the example name can open the example in the edit view.
7.2.2
1.
2.
A dialog will pop up to tell you where the example will be located. Click "yes".
3.