Neuron C编程指南（英文版）：入门与安全须知

需积分: 10 174 浏览量更新于2024-07-29 收藏 1.39MB PDF 举报

"《Neuron C程序猿指南》是一本面向英文读者的专业编程手册，由Echelon Corporation编撰，主要聚焦于Neuron C语言。这本书是学习和开发基于LonWorks、LonMARK、NodeBuilder、LonTalk等Echelon公司技术平台的关键资源。它涵盖了Neuron C的详细语法、编程技巧以及与3120、3150、3170等硬件设备的交互方法，包括ShortStack和LonMaker这些专有的开发工具。在第078-0002-01H章节中，作者强调了Neuron C的适用范围，特别指出该语言并不适用于涉及人身健康、安全或可能导致财产损失的高风险设备控制系统。Echelon明确表示，使用Neuron芯片在这些场景中需谨慎，并且不承担任何责任。此外，书中提到的部分非Echelon供应商提供的组件仅用于示例，可能未经Echelon测试，用户需自行评估其在特定应用中的适用性。值得注意的是，Echelon提供的服务和产品，包括Neuron C，都不附带任何明示或默示的保证，如商品质量或适销性，这是通过法律声明明确排除的。用户在阅读和使用该指南时，应充分理解并承担相应的责任。总而言之，《Neuron C程序猿指南》为开发者提供了一个全面的参考框架，帮助他们掌握Neuron C语言的基础和高级特性，同时提请注意安全性和合规性的关键要点。对于那些希望在Echelon的 LonWorks生态系统中进行嵌入式系统设计的工程师来说，这是一本不可或缺的实用教程。"

4 Overview

Neuron C is designed to execute in the environment provided by the Neuron

system firmware. This firmware provides an

event-driven scheduling system

part of the Neuron C language’s run-time environment.

Neuron C also provides a lower-level

messaging service

integrated into the

language in addition to the network variable model, but the network variable

model has the advantage of being a standardized method of information

interchange, whereas the messaging service is not standardized (with the

exception of its usage by the L

ONWORKS file transfer protocol, LW-FTP). The use

of network variables, both standard types and user types, promotes

interoperability between multiple devices from multiple vendors. The lower-level

messaging service allows for proprietary solutions in addition to the file transfer

protocol.

Another Neuron C data object is the

timer

. Timers can be declared and

manipulated like variables. When a timer expires, the system firmware

automatically manages the timer events and notifies the program of those events.

Neuron C provides many built-in

I/O models

, which are instantiated as

I/O

objects

. These I/O models are standardized I/O “device drivers” for the Neuron

Chip or Smart Transceiver I/O hardware. Each I/O model fits into the event-

driven programming model. A function-call interface is provided to interact with

each I/O object.

Some I/O models, all I/O pins, and a dedicated, high-resolution system timer, can

also be used to trigger asynchronous interrupts.

The rest of this chapter discusses these various aspects of Neuron C in more

detail, and the remaining chapters cover these aspects in greater detail,

accompanied by many examples.

Neuron C Integer Constants

Negative constants are treated as a unary minus operation on a positive

constant, for example, -128 is a signed long, not a signed short. Likewise, -32768

is an unsigned long, not a signed long. To construct a signed short value of -128,

you must use a cast:

((signed short)(-128))

To construct a signed long value of –32768, you must also use a cast:

((signed long)(-32768))

Decimal integer constants have the following default types:

0 .. 127 signed short

128 .. 32767 signed long

32768 .. 65535 unsigned long

The default type can be modified with the u, U, l, and L suffixes. For example:

0L signed long

127U unsigned short

127UL unsigned long

256U unsigned long

Hexadecimal constants have the following default types, which can also be

modified as described above with the u, U, l, and L suffixes:

Neuron C Programmer’s Guide 5

0x0 .. 0x7F signed short

0x80 .. 0xFF unsigned short

0x100 .. 0x7FFF signed long

0x8000 .. 0xFFFF unsigned long

Octal constants have the following default types, which can also be modified as

described above with the u, U, l, and L suffixes:

0 .. 0177 signed short

0200 .. 0377 unsigned short

0400 .. 077777 signed long

0100000 .. 0177777 unsigned long

Binary constants have the following default types, which can also be modified as

described above with the u, U, l, and L suffixes:

0b0 .. 0b01111111 signed short

0b10000000 .. 0b11111111 unsigned short

0b0000000100000000 .. 0b0111111111111111 signed long

0b1000000000000000 .. 0b1111111111111111 unsigned long

Neuron C Variables

The following sections briefly discuss various aspects of variable declarations.

Data types affect what sort of data the variable represents. Storage classes affect

where the variable is stored, whether it can be modified (and if so, how often),

and whether there are any device interface aspects to modifying the data.

Neuron C Variable Types

Neuron C supports the following C variable types. The keywords shown in

square brackets are optional; if omitted, they are assumed by the Neuron C

language, per the rules of the ANSI C standard.

[signed] long [int] 16-bit quantity

unsigned long [int] 16-bit quantity

signed char 8-bit quantity

[unsigned] char 8-bit quantity

[signed] [short] [int] 8-bit quantity

unsigned [short] [int] 8-bit quantity

enum 8-bit quantity (int type)

Neuron C provides some predefined enum types. One example is shown below:

typedef enum {FALSE, TRUE} boolean;

Neuron C also provides predefined objects that, in many ways, provide the look

and feel of an ANSI C language variable. These objects include Neuron C timer

and I/O objects. See the

I/O Model Reference

for more details on I/O objects, and

see the

Timers

chapter in the

Neuron C Reference Guide

for more details on

timer objects.

The extended arithmetic library also defines float_type and s32_type for IEEE

754 and signed 32-bit integer data respectively. These types are discussed in

great detail in the

Functions

chapter of the

Neuron C Reference Guide

6 Overview

Neuron C Storage Classes

If no class is specified and the declaration is at file scope, the data or function is

global.

File scope

is that part of a Neuron C program that is not contained within

a function or a task. Global data (including all data declared with the static

keyword) is present throughout the entire execution of the program, starting

from the point where the symbol was declared. Declarations using extern

references can be used to provide forward references to variables, and function

prototypes must be declared to provide forward references to functions.

Upon power-up or reset of a Neuron Chip or Smart Transceiver, the global data

in RAM is initialized to its initial-value expression, if present, otherwise to zero

(variables declared with the eeprom or config class, as well as configuration

properties declared with the config_prop or cp_family keywords, are only

initialized when the application image is first loaded).

Neuron C supports the following ANSI C storage classes and type qualifiers:

auto Declares a variable of local scope. Typically, this would be within a

function body. This is the default storage class within a local scope

and the keyword is normally not specified. Variables of auto scope

that are not also static are not initialized upon entry to the local

scope. The value of the variable is not preserved once program

execution leaves the scope.

const Declares a value that cannot be modified by the application program.

Affects self-documentation (SD) data generated by the Neuron C

compiler when used in conjunction with the declaration of CP families

or configuration network variables.

extern Declares a data item or function that is defined in another module, in

a library, or in the system image.

static Declares a data item or function which is

not

to be made available to

other modules at link time. Furthermore, if the data item is local to a

function or to a when task, the data value is to be preserved between

invocations, and is not made available to other functions at compile

time.

In addition to the ANSI C storage classes, Neuron C provides the following

classes and class modifiers:

config Can be combined only with an input network variable declaration. A

config network variable is used for application configuration. It is

equivalent to const eeprom. Such a network variable is initialized

only when the application image is first loaded. The config class is

obsolete and is included only for legacy applications. The Neuron C

compiler does not generate self-documentation data for config-class

network variables. New applications should use the configuration

network variable syntax described Chapter

Using Configuration

Properties to Configure Device Behavior

, on page 83.

network Begins a network variable declaration. See Chapter

How Devices

Communicate Using Network Variables

, on page 43, for more details.

system Used in Neuron C solely to access the Neuron firmware function

library. Do not use this keyword for data or function declarations.

Neuron C Programmer’s Guide 7

uninit When combined with the eeprom keyword (see below), specifies that

the EEPROM variable is not initialized or altered on program load or

reload over the network.

The following Neuron C keywords allow you to direct portions of application code

and data to specific memory sections:

• eeprom

• far

• offchip (only for Neuron Chips and Smart Transceivers

with external memory)

• onchip

• ram (only for Neuron Chips and Smart Transceivers

with external memory)

These keywords are particularly useful on the Neuron 3150 Chip and 3150 Smart

Transceivers, because a majority of the address space for these parts is mapped

off chip. See

Using Neuron Chip Memory

on page 176 for a more detailed

description of memory usage and the use of these keywords.

Variable Initialization

Initialization of variables occurs at different times for different classes. The

const variables, except for network variables,

must

be initialized. Initialization

of const variables occurs when the application image is first loaded into the

Neuron Chip or Smart Transceiver. The const ram variables are placed in off-

chip RAM that must be non-volatile. Therefore, the eeprom and config variables

are also initialized at load time, except when the uninit class modifier is included

in these variable definitions.

Automatic variables cannot be declared const because Neuron C does not

implement initializers in declarations of automatic variables.

Global RAM variables are initialized at reset (that is, when the device is reset or

powered up). By default, all global RAM variables (including static variables) are

initialized to zero at this time. Initialization to zero costs no extra code space, as

it is a firmware feature.

Initialization of I/O objects, input network variables (except for eeprom, config,

config_prop, or const network variables), and timers also occurs at reset. Zero is

the default initial value for network variables and timers.

Local variables (except static ones) are not automatically initialized, nor are their

values preserved when the program execution leaves the local scope.

Neuron C Declarations

Both ANSI C and Neuron C support the declarations listed in Table 2.

Table 2. ANSI C and Neuron C Declarations

Declaration Example

Simple data items int a, b, c;

剩余267页未读，继续阅读

backu8000

粉丝: 0
资源: 4

Neuron C编程指南（英文版）：入门与安全须知

NEURON C PROGRAMMER'S GUIDE

Neuron C Reference Guide

Neuron C 编程&参考指南.rar

编程语言Neuron C

编程语言Neuron C的特征

ubuntu下打开neuron

怎么导入neuron模块

neuron框架安装

Dead Neuron

Neuron() takes no arguments

最新资源