Description描述

Unsigned long variables are extended size variables for number storage, and store 32 bits (4 bytes). Unlike standard longs unsigned longs won't store negative numbers, making their range from 0 to 4,294,967,295 (2^32 - 1).
Unsigned long variables是用于储存数值的变量的一种扩展方式，可以储存32 bits (4bytes)。Unsigned long特别之处在于不能储存负值，其储存的值的范围是0 到 4,294,967,295。

Example范例

unsigned long time;
void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print("Time: ");
time = millis();
//prints time since program started
  // 在程序开始后返回时间。
Serial.println(time);
// wait a second so as not to send massive amounts of data
  // 延迟1秒，以便发送大量的数据。
delay(1000);
}

Syntax语法

    unsigned long var = val;

• var - your long variable name 变量名
• val - the value you assign to that variable 分配给变量的值

See Also

• byte
• int
• unsigned int
• long

Description描述

Long variables are extended size variables for number storage, and store 32 bits (4 bytes), from -2,147,483,648 to 2,147,483,647.
Long变量是更大范围的数值储存方式，可以储存32位（4字节），从-2,147,483,648 到 2,147,483,647之间的数值。

Example范例

long time;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("Time: ");
time = millis();
//prints time since program started
 // 得到从程序开始正常运行的时间
Serial.println(time);
// wait a second so as not to send massive amounts of data
 // 延迟1秒，以便发送大量的数据。
delay(1000);
}

Syntax语法

    long var = val;

• var - your long variable name 你的长整数变量名
• val - the value you assign to that variable 你指定给这个变量的值

See Also

• byte
• int
• unsigned int
• unsigned long

Description

Returns the number of milliseconds since the Arduino board began running the current program.
返回Arduino卡开始正常运行程序后的毫秒数。

Parameters参数

None 无

Returns返回

The number of milliseconds since the current program started running, as an unsigned long. This number will overflow (go back to zero), after approximately 9 hours.
返回自从当前程序开始运行后的毫秒数，这是一个无符号的长整数。如果这个值超过了大约9小时，会产生数据溢出（返回到0）。

Examples范例

long time;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("Time: ");
time = millis();
//prints time since program started
 // 得到从程序开始正常运行的时间
Serial.println(time);
// wait a second so as not to send massive amounts of data
 // 延迟1秒，以便发送大量的数据。
delay(1000);
}
/* Frequency Test
   频率测试
*  Paul Badger 2007
*  Program to empirically determine the time delay to generate the
*  proper frequency for a an  Infrared (IR) Remote Control Receiver module
*  These modules typically require 36 - 52 khz communication frequency
*  depending on specific device.
   程序为一个红外（IR）遥控接受装置试验地决定延迟时间，以便产生适当的频率。这个模块最典型的要求是36 - 52 khz的频率。
*/
int tdelay;
unsigned long i, hz;
unsigned long time;
int outPin = 11;
void setup(){
pinMode(outPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
for (tdelay = 1; tdelay < 12; tdelay++){     
                   // scan across a range of time delays to find the right frequency
time = millis();               // get start time of inner loop
for (i = 0; i < 100000; i++){  // time 100,000 cycles through the loop
digitalWrite(outPin, HIGH);
delayMicroseconds(tdelay);
digitalWrite(outPin, LOW);
delayMicroseconds(tdelay);
}
time = millis() - time;      // compute time through inner loop in milliseconds
hz = (1 /((float)time / 100000000.0));   // divide by 100,000 cycles and 1000 milliseconds per second
// to determine period, then take inverse to convert to hertz
Serial.print(tdelay, DEC);
Serial.print("   ");
Serial.println(hz, DEC);
}
}

See also

• delay
• delayMicroseconds

Description描述

Unsigned ints (unsigned integers) are the same as ints in that they store a 2 byte value. Instead of storing negative numbers however they only store positive values, yielding a useful range of 0 to 65,535 (2^16) - 1).
Unsigned ints（无符号整数）和 ints一样都可以储存2byte的值。它将用于储存负数的空间用来储存正数，因此，它们能储存0 到 65,535的正值。

The difference between unsigned ints and (signed) ints, lies in the way the highest bit, sometimes refered to as the "sign" bit, is interpreted. In the Arduino int type (which is signed), if the high bit is a "1", the number is interpreted as a negative number, and the other 15 bits are interpreted with 2's complement math.

Example范例

    int ledPin = 13;

Syntax语法

    int var = val;

• var - your int variable name 你的变量名
• val - the value you assign to that variable 你指定给变量的值

Coding Tip编码提示

When variables are made to exceed their maximum capacity they "roll over" back to their minimum capacitiy, note that this happens in both directions
当变量值超过其最大取值范围，它会“翻转”到它的最小值，注意它在两个方向都可能发生。

   unsigned int x
x = 0;
x = x - 1;       // x now contains 65535 - rolls over in neg direction
                    // x现在为65535-翻转到它的反方向。
x = x + 1;       // x now contains 0 - rolls over
                    //x现在为0-翻转到它的反方向。

See Also另见

• byte
• int
• long
• unsigned long

Description描述

Integers are your primary datatype for number storage, and store a 2 byte value. This yields a range of -32,768 to 32,767 (minimum value of -2^15 and a maximum value of (2^15) - 1).
整数是你最初级的数据储存类型，可以储存 2 byte的值。它可以表现 -32,768到 32,767 (最小值 -2^15 最大值 (2^15) - 1)。

Int's store negative numbers with a technique called 2's complement math. The highest bit, sometimes refered to as the "sign" bit, flags the number as a negative number. The rest of the bits are inverted and 1 is added.
整数储存负数的技巧请见2's complement math。

The Arduino takes care of dealing with negative numbers for you, so that arithmetic operations work transparently in the expected manner. There can be an unexpected complication in dealing with the bitshift right operator (>>) however.

Example范例

    int ledPin = 13;

Syntax语法

    int var = val;

• var - your int variable name 你的整数变量名
• val - the value you assign to that variable 你设定的变量值

Coding Tip代码技巧

When variables are made to exceed their maximum capacity they "roll over" back to their minimum capacitiy, note that this happens in both directions.
当变量的值超过了它的最大值后会“翻转”到它们的最小值，注意，在两个方向都可能发生。

   int x
x = -32,768;
x = x - 1;       // x now contains 32,767 - rolls over in neg. direction
                   // x现在为 32,767-翻转到反方向。
x = 32,767;
x = x + 1;       // x now contains -32,768 - rolls over
                    // x现在为 -32,767-翻转到反方向。

See Also

• byte
• unsigned int
• long
• unsigned long

Description描述

Bytes store an 8-bit number, from 0 to 255. byte is an unsigned data type, meaning that it does not store negative numbers.
Bytes可以储存8-bit的数字，从0到255.它是无符号的数据类型，这意味着它不能储存负数。

Example范例

    byte b = B10010;  // "B" is the binary formatter (18 decimal)

                      //"B"是二进制的格式化程序（十进制值为18）

See also另见

• int
• unsigned int
• long
• unsigned long
• integer constants
• Serial.println

Description描述

Perform a mathematical operation on a variable with another constant or variable. The += (et al) operators are just a convenient shorthand for the expanded syntax, listed below.
对一个变量和另一个参数或变量完成一个数学运算。+=（以及其他）可以缩短语法长度。

Syntax语法

x += y;   // equivalent to the expression x = x + y;
          // 等价于 x = x + y;
x -= y;   // equivalent to the expression x = x - y; 
          // 等价于 x = x - y;
x *= y;   // equivalent to the expression x = x * y; 
          // 等价于 x = x * y;
x /= y;   // equivalent to the expression x = x / y; 
          // 等价于 x = x / y;

Parameters参数

x: any variable type
x：任何变量类型

y: any variable type or constant
y：任何变量类型或常数

Examples范例

x = 2;
x += 4;      // x now contains 6
             // x现在为6
x -= 3;      // x now contains 3
             // x现在为3
x *= 10;     // x now contains 30
             // x现在为30
x /= 2;      // x now contains 15
             // x现在为15

Description描述

Increment or decrement a variable
增加或消耗变量

Syntax语法

x++;  // increment x by one and returns the old value of x

      // 将x的值加1并返回原来的x的值。    
++x;  // increment x by one and returns the new value of x
      // 将x的值加1并返回现在的x的值。   

x-- ;   // decrement x by one and returns the old value of x 
      // 将x的值减1并返回原来的x的值。   

--x ;   // decrement x by one and returns the new value of x  
      // 将x的值减1并返回现在的x的值。

Parameters参数

x: an integer or long (possibly unsigned)
x：一个整数或长整数（可以无符号）

Returns返回

The original or newly incremented / decremented value of the variable.
返回变量原始值或增加/消耗后的新值。

Examples范例

x = 2;
y = ++x;      // x now contains 3, y contains 3
              // x现在为3，y为3
y = x--;      // x contains 2 again, y still contains 3
              // x现在仍然为2，y将为3

See also另见

+=
-=

These can be used inside the condition of an if statement.
它们可以在条件或条件语句中使用。

&& (logical and逻辑和)

True only if both operands are true, e.g.
仅两个操作符都为真时才为真，例如：

if (digitalRead(2) == 1  && digitalRead(3) == 1) { // read two switches
// ...
}

is true only if x is 1, 2, 3, or 4.

|| (logical or逻辑与)

True if either operand is true, e.g.
如果任意一个为真，就为真，例如：

if (x > 0 || y > 0) {
// ...
}

is true if either x or y is greater than 0.
只要x或y任意一个大于0，就为真。

! (not非)

True if the operand is false, e.g.
如果操作符为假时，就为真，例如：

if (!x) {
// ...
}

is true if x is false (i.e. if x equals 0).
如果x为假时（例如x为0），就为真。

Warning警告

Make sure you don't mistake the boolean AND operator, && (double ampersand) for the bitwise AND operator & (single ampersand). They are entirely different beasts.
确定你没有错误的使用逻辑和操作符&&和位操作符&，它们是完全不同的。

Similarly, do not confuse the boolean || (double pipe) operator with the bitwise or operator | (single pipe).
同样的，确定你没有错误的使用逻辑与操作符||和位操作符|。

The bitwise not ~ (tilde) looks much different than the boolean not ! (exclamation point or "bang" as the programmers say) but you still have to be sure which one you want where.
位操作符非~看起来和逻辑非操作符！（感叹号或程序员常说的 "bang"）非常不同，但你仍然需要知道哪一个才是这里需要的。

Examples范例

if (a >= 10 && a <= 20){}   // true if a is between 10 and 20
// a在10到20之间时为真

See also另见

• & (bitwise AND)
• | (bitwise or)
• ~ (bitwise NOT
• if

Description描述

These operators return the sum, difference, product, or quotient (respectively) of the two operands. The operation is conducted using the data type of the operands, so, for example, 9 / 4 gives 2 since 9 and 4 are ints. This also means that the operation can overflow if the result is larger than that which can be stored in the data type. If the operands are of different types, the "larger" type is used for the calculation.
这些函数将返回两个操作数值的计算结果。采用操作数的数据类型进行计算，例如， 9 / 4将返回2，因为9和4是整数。这也意味着如果结果超出了数据类型的储存范围将会导致数据溢出。如果操作数的数据类型不同，那么，较多的数据类型将被计算采用。

If one of the numbers (operands) are of the type float or of type double, floating point math will be used for the calculation.
如果操作数的数据类型是 float或者 double，那么就会以浮点来进行计算。

Examples范例

y = y + 3;
x = x - 7;
i = j * 6;
r = r / 5;

Syntax语法

result = value1 + value2;
result = value1 - value2;
result = value1 * value2;
result = value1 / value2;

Parameters:

value1: any variable or constant
value1:任意变量或常数。

value2: any variable or constant
value2:任意变量或常数。

Programming Tips:技巧

• Choose variable sizes that are large enough to hold the largest results from your calculations
  增加变量长度，以便保存更长的计算结果

   

• Know at what point your variable will "roll over" and also what happens in the other direction e.g. (0 - 1) or (0 - - 32768)
  明白为什么你的变量会产生“翻转”，或偶然发生方向改变。例如（0 - 1）或（0 - - 32768）。

   

• For math that requires fractions, use float variables, but be aware of their drawbacks: large size, slow computation speeds
  如果数学计算需要分数，那么就要使用浮点变量，但也要知道它的缺点：体积大，计算速度慢。

   

• Use the cast operator e.g. (int)my Float to convert one variable type to another on the fly.