Arduino编程参考手册 - jimaobian/DFRobotWikiCn GitHub Wiki

int buttonPin = 3;

void setup()
{
  Serial.begin(9600); //初始化串口
  pinMode(buttonPin, INPUT); //设置3号引脚为输入模式
}

void loop()
{
  if (digitalRead(buttonPin) == HIGH)
    serialWrite('H');
  else
    serialWrite('L');

  delay(1000);
}

if (value > 50)
{
  // 这里加入你的代码
}

if (x > 120) digitalWrite(LEDpin, HIGH);

if (x > 120)
digitalWrite(LEDpin, HIGH);

if (x > 120){ digitalWrite(LEDpin, HIGH); }

if (x > 120){
  digitalWrite(LEDpin1, HIGH);
  digitalWrite(LEDpin2, HIGH);
}                                 // 都是正确的

if (pinFiveInput < 500)
{
  // 动作A
}
else
{
  // 动作B
}

if (pinFiveInput < 500)
{
  // 执行动作A
}
else if (pinFiveInput >= 1000)
{
  // 执行动作B
}
else
{
  // 执行动作C
}

for (初始化部分; 条件判断部分; 数据递增部分) {
//语句块
。。。
}

//使用一个PWM引脚使LED灯闪烁
int PWMpin = 10; // LED在10号引脚串联一个470欧姆的电阻

void setup()
{
  //这里无需设置
}

void loop()
{
   for (int i=0; i <= 255; i++){
      analogWrite(PWMpin, i);
      delay(10);
   }
}

for(int x = 2; x < 100; x = x * 1.5){
    println(x);
}

void loop()
{
   int x = 1;
   for (int i = 0; i > -1; i = i + x){
      analogWrite(PWMpin, i);
      if (i == 255) x = -1;             // 在峰值切换方向
      delay(10);
   }
}

   switch (var) {
    case 1:
      //当var等于1执行这里
      break;
    case 2:
      //当var等于2执行这里
      break;
    default:
      // 如果没有匹配项，将执行此缺省段
      // default段是可选的
  }

 switch (var) {
  case label:
    // statements
    break;
  case label:
    // statements
    break;
  default:
    // statements
}

 while(expression){
  // statement(s)
}

var = 0;
 while(var < 200){
   // 做两百次重复的事�
   var++;
 }

do
{
    // 语句块
} while (测试条件);

do
{
  delay(50);          // 等待传感器稳定
  x = readSensors();  // 检查传感器的值

} while (x < 100);

 for (x = 0; x < 255; x ++)
{
    digitalWrite(PWMpin, x);
    sens = analogRead(sensorPin);
    if (sens > threshold){      // bail out on sensor detect
       x = 0;
       break;
    }
    delay(50);
}

for (x = 0; x < 255; x ++)
{
    if (x > 40 && x < 120){      // create jump in values
        continue;
    }

    digitalWrite(PWMpin, x);
    delay(50);
}

return;
return value; // both forms are valid

//一个函数，用于对一个传感器输入与一个阈值进行比较

 int checkSensor(){
    if (analogRead(0) > 400) {
        return 1;
    else{
        return 0;
    }
}

void loop(){

//在此测试代码是个好想法

return;

// 这里是功能不正常的代码
// 这里的代码永远也不会执行
}

label:
goto label; // sends program flow to the label

 for(byte r = 0; r < 255; r++){
    for(byte g = 255; g > -1; g--){
        for(byte b = 0; b < 255; b++){
            if (analogRead(0) > 250){ goto bailout;}
            // 其它语句。。。
        }
    }
}
bailout:

    int a = 13;

//函数
   void myfunction(datatype argument){
    statements(s)
  }



//循环
   while (boolean expression)
  {
     statement(s)
  }

  do
  {
     statement(s)
  } while (boolean expression);

  for (initialisation; termination condition; incrementing expr)
  {
     statement(s)
  }



//条件语句

  if (boolean expression)
  {
     statement(s)
  }

  else if (boolean expression)
  {
     statement(s)
  }
  else
  {
     statement(s)
  }

  x = 5;  //这是一个单行注释。此斜线后的任何内容都是注释
         //直到该行的结尾

/* 这是多行注释 - 用它来注释掉整个代码块
if (gwb == 0){   //在多行注释中使用单行注释是没有问题的
x = 3;           /* 但是其中不可以使用另一个多行注释 - 这是不合法的 */
}


//别忘了加上“关闭”注释符 - 它们必须是平衡的
*/

#define constantName value

#define ledPin 3
// 编译器在编译时会将任何提及ledPin的地方替换成数值3。

#define ledPin 3;    // this is an error

#define ledPin  = 3  // this is also an error

#include <avr/pgmspace.h>

prog_uint16_t myConstants[] PROGMEM = {0, 21140, 702  , 9128,  0, 25764, 8456,
0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500};

  int sensVal;                  //声明一个名为sensVal的整型变量
 senVal = analogRead(0);       //存储（数字的）0号模拟引脚的输入电压值到sensVal

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

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

result = dividend % divisor

x = 7 % 5;   // x now contains 2
x = 9 % 5;   // x now contains 4
x = 5 % 5;   // x now contains 0
x = 4 % 5;   // x now contains 4

 /* update one value in an array each time through a loop */

int values[10];
int i = 0;

void setup() {}

void loop()
{
  values[i] = analogRead(0);
  i = (i + 1) % 10;   // modulo operator rolls over variable
}

if (someVariable > 50)
{
  // do something here
}

if (x > 120) digitalWrite(LEDpin, HIGH);

if (x > 120)
digitalWrite(LEDpin, HIGH);

if (x > 120){ digitalWrite(LEDpin, HIGH); }

if (x > 120){
  digitalWrite(LEDpin1, HIGH);
  digitalWrite(LEDpin2, HIGH);
}                                 // all are correct

 x == y (x is equal to y)
 x != y (x is not equal to y)
 x <  y (x is less than y)
 x >  y (x is greater than y)
 x <= y (x is less than or equal to y)
 x >= y (x is greater than or equal to y)

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

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

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

 if (a >= 10 && a <= 20){}   // true if a is between 10 and 20

    0  0  1  1    operand1
    0  1  0  1    operand2
    ----------
    0  0  0  1    (operand1 & operand2) - returned result

    int a =  92;    // in binary: 0000000001011100
    int b = 101;    // in binary: 0000000001100101
    int c = a & b;  // result:    0000000001000100, or 68 in decimal.

    0  0  1  1    operand1
    0  1  0  1    operand2
    ----------
    0  1  1  1    (operand1 | operand2) - returned result

    int a =  92;    // in binary: 0000000001011100
    int b = 101;    // in binary: 0000000001100101
    int c = a | b;  // result:    0000000001111101, or 125 in decimal.

int i;     // counter variable
int j;

void setup(){
DDRD = DDRD | B11111100; // set direction bits for pins 2 to 7, leave 0 and 1 untouched (xx | 00 == xx)
// same as pinMode(pin, OUTPUT) for pins 2 to 7
Serial.begin(9600);
}

void loop(){
for (i=0; i<64; i++){

PORTD = PORTD & B00000011;  // clear out bits 2 - 7, leave pins 0 and 1 untouched (xx & 11 == xx)
j = (i << 2);               // shift variable up to pins 2 - 7 - to avoid pins 0 and 1
PORTD = PORTD | j;          // combine the port information with the new information for LED pins
Serial.println(PORTD, BIN); // debug to show masking
delay(100);
   }
}

    0  0  1  1    operand1
    0  1  0  1    operand2
    ----------
    0  1  1  0    (operand1 ^ operand2) - returned result

    int x = 12;     // binary: 1100
    int y = 10;     // binary: 1010
    int z = x ^ y;  // binary: 0110, or decimal 6

// Blink_Pin_5
// demo for Exclusive OR
void setup(){
DDRD = DDRD | B00100000; // set digital pin five as OUTPUT
Serial.begin(9600);
}

void loop(){
PORTD = PORTD ^ B00100000;  // invert bit 5 (digital pin 5), leave others untouched
delay(100);
}

    0  1    operand1

   ----------
    1  0   ~ operand1

    int a = 103;    // binary:  0000000001100111
    int b = ~a;     // binary:  1111111110011000 = -104

variable << number_of_bits

variable >> number_of_bits

参数


*variable - (byte, int, long) number_of_bits integer <= 32 



示例：

    <pre style="color:green">
    int a = 5;        // binary: 0000000000000101
    int b = a << 3;   // binary: 0000000000101000, or 40 in decimal
    int c = b >> 3;   // binary: 0000000000000101, or back to 5 like we started with

    int a = 5;        // binary: 0000000000000101
    int b = a << 14;  // binary: 0100000000000000 - 101中的第一个1被丢弃

    1 <<  0  ==    1
    1 <<  1  ==    2
    1 <<  2  ==    4
    1 <<  3  ==    8
    ...
    1 <<  8  ==  256
    1 <<  9  ==  512
    1 << 10  == 1024
    ...

    int x = -16;     // binary: 1111111111110000
    int y = x >> 3;  // binary: 1111111111111110

    int x = -16;                   // binary: 1111111111110000
    int y = (unsigned int)x >> 3;  // binary: 0001111111111110

    int x = 1000;
    int y = x >> 3;   // 1000除以8，得y = 125.

自加++
i++; //相当于 i = i + 1;
自减--
i--; //相当于 i = i - 1;
复合加+=
i+=5; //相当于 i = i + 5;
复合减-=
i-=5; //相当于 i = i - 5;
复合乘*=
i*=5; //相当于 i = i * 5;
复合除/=
i/=5; //相当于 i = i / 5;
复合与&=
i&=5; //相当于 i = i & 5;
复合或|=
i|=5; //相当于 i = i | 5;

#define     HIGH   0x1
            高电平
#define     LOW   0x0
            低电平
#define     INPUT   0x0
            输入
#define     OUTPUT   0x1
            输出
#define     true   0x1
            真
#define     false   0x0
            假
#define     PI   3.14159265
            PI.
#define     HALF_PI   1.57079
            二分之一PI
#define     TWO_PI   6.283185
            二倍PI
#define     DEG_TO_RAD   0.01745329
            弧度转角度
#define     RAD_TO_DEG   57.2957786
            角度转弧度

进制          例子      格式      备注
10（十进制）     123         �
2（二进制）  B1111011    前缀'B'   只适用于8位的值（0到255）字符0-1有效
8（八进制）  0173        前缀”0”   字符0-7有效
16（十六进制）    0x7B        前缀”0x”  字符0-9，A-F，A-F有效

101  //和十进制5等价 （1*2^2 + 0*2^1 + 1*2^0）

myInt = (B11001100 * 256) + B10101010;    // B11001100 作为高位。

0101    // 等同于十进制数65   ((1 * 8^2) + (0 * 8^1) + 1)

0x101   // 等同于十进制257   ((1 * 16^2) + (0 * 16^1) + 1)

浮点数     被转换为        被转换为
10.0        10
2.34E5      2.34 * 10^5     234000
67E-12      67.0 * 10^-12   0.000000000067

//功能在“setup”和“loop”被执行
//但没有数据被返回到高一级的程序中

void setup()
{
// ...
}

void loop()
{
// ...
}

int LEDpin = 5;       // LED与引脚5相连
int switchPin = 13;   // 开关的一个引脚连接引脚13，另一个引脚接地。

boolean running = false;

void setup()
{
  pinMode(LEDpin, OUTPUT);
  pinMode(switchPin, INPUT);
  digitalWrite(switchPin, HIGH);      // 打开上拉电阻
}

void loop()
{
  if (digitalRead(switchPin) == LOW)
  {  // 按下开关 - 使引脚拉向高电势
    delay(100);                        // 通过延迟，以滤去开关抖动产生的杂波
    running = !running;                // 触发running变量
    digitalWrite(LEDpin, running)      //点亮LED
    }
  }

  char myChar = 'A';
  char myChar = 65;      // both are equivalent

    unsigned char myChar = 240;

    byte b = B10010;  // "B" 是二进制格式（B10010等于十进制18）

int ledPin = 13;

int var = val;

   int x
   x = -32,768;
   x = x - 1;       // x 现在是 32,767。

   x = 32,767;
   x = x + 1;       // x 现在是 -32,768。

unsigned int ledPin = 13;

unsigned int var = val;

   unsigned int x
       x = 0;
   x = x - 1;       //x现在等于65535--向负数方向滚回
   x = x + 1;       //x现在等于0--滚回

    word w = 10000;

long speedOfLight = 186000L; //参见整数常量‘L’的说明

long var = val;

unsigned long time;

void setup()
{
     Serial.begin(9600);
}

void loop()
{
  Serial.print("Time: ");
  time = millis();
//程序开始后一直打印时间
  Serial.println(time);
//等待一秒钟，以免发送大量的数据
     delay(1000);
}

unsigned long var = val;

    float myfloat;
    float sensorCalbrate = 1.117;

float var = val;

   int x;
   int y;
   float z;

   x = 1;
   y = x / 2;         // Y为0，因为整数不能容纳分数
   z = (float)x / 2.0;   // Z为0.5（你必须使用2.0做除数，而不是2）

  char Str1[15];
  char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
  char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
  char Str4[ ] = "arduino";
  char Str5[8] = "arduino";
  char Str6[15] = "arduino";

char* myStrings[]={
  "This is string 1", "This is string 2", "This is string 3",
  "This is string 4", "This is string 5","This is string 6"};

void setup(){
  Serial.begin(9600);
}

void loop(){
  for (int i = 0; i < 6; i++){
    Serial.println(myStrings[i]);
    delay(500);
  }
}

  myInts [6];
  myPins [] = {2，4，8，3，6};
  mySensVals [6] = {2，4，-8，3，2};
  char message[6] = "hello";

mySensVals [0] == 2，mySensVals [1] == 4，

  int myArray[10] = {9,3,2,4,3,2,7,8,9,11};
  // myArray[9]的数值为11
  // myArray[10]，该索引是无效的，它将会是任意的随机信息（内存地址）

  mySensVals [0] = 10;

  X = mySensVals [4];

  int i;
  for (i = 0; i < 5; i = i + 1) {
  Serial.println(myPins[i]);
  }

char(x)

byte(x)

int(x)

word(x)
word(h, l)

long(x)

float(x)

int gPWMval;  // 任何函数都可以调用此变量

void setup()
{
  // ...
}

void loop()
{
  int i;    // "i" 只在 "loop" 函数内可用
  float f;  // "f" 只在 "loop" 函数内可用
  // ...

  for (int j = 0; j <100; j++){
    //变量j只能在循环括号内访问
  }
}

/* RandomWalk
* Paul Badger 2007
* RandomWalk函数在两个终点间随机的上下移动
* 在一个循环中最大的移动由参数“stepsize”决定
*一个静态变量向上和向下移动一个随机量
*这种技术也被叫做“粉红噪声”或“醉步”
*/

#define randomWalkLowRange -20
#define randomWalkHighRange 20

int stepsize;

INT thisTime;
int total;

void setup()
{
     Serial.begin(9600);
}

void loop()
{        //  测试randomWalk 函数
  stepsize = 5;
  thisTime = randomWalk(stepsize);
serial.println（thisTime）;
   delay(10);
}

int randomWalk(int moveSize){
  static int  place;     // 在randomwalk中存储变量
                         // 声明为静态因此它在函数调用之间能保持数据，但其他函数无法改变它的值

  place = place + (random(-moveSize, moveSize + 1));

  if (place < randomWalkLowRange){                    //检查上下限
    place = place + (randomWalkLowRange - place);     // 将数字变为正方向
}
  else if(place > randomWalkHighRange){
    place = place - (place - randomWalkHighRange);     // 将数字变为负方向
}

  return place;
}

//当中断引脚改变状态时，开闭LED

int pin = 13;
volatile int state = LOW;

void setup()
{
  pinMode(pin, OUTPUT);
  attachInterrupt(0, blink, CHANGE);
}

void loop()
{
  digitalWrite(pin, state);
}

void blink()
{
  state = !state;
}

const float pi = 3.14;
float x;

// ....

x = pi * 2;    // 在数学表达式中使用常量不会报错

pi = 7;        // 错误的用法 - 你不能修改常量值，或给常量赋值。

sizeof(variable)

char myStr[] = "this is a test";
int i;

void setup(){
  Serial.begin(9600);
}

{0}void{/0}{1} {/1}{2}loop{/2}{1}() {{/1}
  for (i = 0; i < sizeof(myStr) - 1; i++){
    Serial.print(i, DEC);
    Serial.print(" = ");
    Serial.println(myStr[i], BYTE);
  }
}

for (i = 0; i < (sizeof(myInts)/sizeof(int)) - 1; i++) {
  //用myInts[i]来做些事
}

代码  字符  代码  字符  代码  字符  代码  字符
0       32  [空格]    64  @   96  `
1       33  !   65  A   97  a
2       34  "   66  B   98  b
3       35  #   67  C   99  c
4       36  $   68  D   100 d
5       37  %   69  E   101 e
6       38  &   70  F   102 f
7       39  '   71  G   103 g
8       40  (   72  H   104 h
9       41  )   73  I   105 i
10      42  *   74  J   106 j
11      43  +   75  K   107 k
12      44  ,   76  L   108 l
13      45  -   77  M   109 m
14      46  .   78  N   110 n
15      47  /   79  O   111 o
16      48  0   80  P   112 p
17      49  1   81  Q   113 q
18      50  2   82  R   114 r
19      51  3   83  S   115 s
20      52  4   84  T   116 t
21      53  5   85  U   117 u
22      54  6   86  V   118 v
23      55  7   87  W   119 w
24      56  8   88  X   120 x
25      57  9   89  Y   121 y
26      58  :   90  Z   122 z
27      59  ;   91  [   123 {
28      60  <   92  \   124 |
29      61  =   93  ]   125 }
30      62  >   94  ^   126 ~
31      63  ?   95  _   127

void pinMode (uint8_t pin, uint8_t mode)

int ledPin = 13;                 // LED connected to digital pin 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // sets the LED on
  delay(1000);                  // waits for a second
  digitalWrite(ledPin, LOW);    // sets the LED off
  delay(1000);                  // waits for a second
}

void digitalWrite (uint8_t pin, uint8_t value)

int ledPin = 13;                 // LED connected to digital pin 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // 点亮LED
  delay(1000);                  // 等待1秒
  digitalWrite(ledPin, LOW);    // 关
  delay(1000);                  // waits for a second
}

int digitalRead (uint8_t pin)

int ledPin = 13; // LED connected to digital pin 13
int inPin = 7;   // pushbutton connected to digital pin 7
int val = 0;     // variable to store the read value

void setup()
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin 13 as output
  pinMode(inPin, INPUT);      // sets the digital pin 7 as input
}

void loop()
{
  val = digitalRead(inPin);   // read the input pin
  digitalWrite(ledPin, val);    // sets the LED to the button's value
}

void analogReference (uint8_t type)

int analogRead (uint8_t pin)

int analogPin = 3;     // potentiometer wiper (middle terminal) connected to analog pin 3
                       // outside leads to ground and +5V
int val = 0;           // variable to store the value read

void setup()
{
  Serial.begin(9600);          //  setup serial
}

void loop()
{
  val = analogRead(analogPin);    // read the input pin
  Serial.println(val);             // debug value
}

void analogWrite (uint8_t pin, int value)

int ledPin = 9;      // LED connected to digital pin 9
int analogPin = 3;   // potentiometer connected to analog pin 3
int val = 0;         // variable to store the read value

void setup()
{
  pinMode(ledPin, OUTPUT);   // sets the pin as output
}

void loop()
{
  val = analogRead(analogPin);   // read the input pin
  analogWrite(ledPin, val / 4);  // analogRead values go from 0 to 1023, analogWrite values from 0 to 255
}

void shiftOut (uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, byte val)

unsigned long pulseIn (uint8_t pin, uint8_t state, unsigned long timeout)

int pin = 7;
unsigned long duration;

void setup()
{
  pinMode(pin, INPUT);
}

void loop()
{
  duration = pulseIn(pin, HIGH);
}

unsigned long millis (void)

void delay (unsigned long ms)

int ledPin = 13;                 // LED connected to digital pin 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // sets the LED on
  delay(1000);                  // waits for a second
  digitalWrite(ledPin, LOW);    // sets the LED off
  delay(1000);                  // waits for a second
}

void delayMicroseconds (unsigned int us)

int outPin = 8;                 // digital pin 8

void setup()
{
  pinMode(outPin, OUTPUT);      // sets the digital pin as output
}

void loop()
{
  digitalWrite(outPin, HIGH);   // sets the pin on
  delayMicroseconds(50);        // pauses for 50 microseconds
  digitalWrite(outPin, LOW);    // sets the pin off
  delayMicroseconds(50);        // pauses for 50 microseconds
}

#define min(a, b) ((a)<(b)?(a):(b))

sensVal = min(sensVal, 100); // assigns sensVal to the smaller of sensVal or 100
                             // ensuring that it never gets above 100.

#define max(a, b) ((a)>(b)?(a):(b))

sensVal = max(senVal, 20); // assigns sensVal to the larger of sensVal or 20
                           // (effectively ensuring that it is at least 20)

abs(x)   ((x)>0?(x):-(x))

#define constrain(amt, low, high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt)))

sensVal = constrain(sensVal, 10, 150);
// limits range of sensor values to between 10 and 150

long map  ( long  x,
  long  in_min,
  long  in_max,
  long  out_min,
  long  out_max
 )

// Map an analog value to 8 bits (0 to 255)
void setup() {}

void loop()
{
  int val = analogRead(0);
  val = map(val, 0, 1023, 0, 255);
  analogWrite(9, val);
}

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

double  pow (float base, float exponent)
指数函数 

double  sqrt (double x)
//开平方

float sin (float rad)
//正弦函数
float cos (float rad)
//余弦函数
float tan (float rad)
//正切函数

void randomSeed  ( unsigned int  seed   )

long random (long howbig)

#define  lowByte(w)   ((w) & 0xff)
  //取低字节

#define  highByte(w)   ((w) >> 8)
  //取高字节

#define  bitRead(value, bit)   (((value) >> (bit)) & 0x01)
  //读一个bit

#define  bitWrite(value, bit, bitvalue)   (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
  //写一个bit

#define  bitSet(value, bit)   ((value) |= (1UL << (bit)))
  //设置一个bit

#define  bitClear(value, bit)   ((value) &= ~(1UL << (bit)))
  //清空一个bit

#define  bit(b)   (1 << (b))
  //生成相应bit

void attachInterrupt (uint8_t interruptNum, void(*)(void)userFunc, int mode)

int pin = 13;
volatile int state = LOW;

void setup()
{
  pinMode(pin, OUTPUT);
  attachInterrupt(0, blink, CHANGE);
}

void loop()
{
  digitalWrite(pin, state);
}

void blink()
{
  state = !state;
}

void detachInterrupt (uint8_t interruptNum)

#define interrupts() sei()

void setup() {}

void loop()
{
  noInterrupts();
  // critical, time-sensitive code here
  interrupts();
  // other code here
}

#define noInterrupts() cli()

void setup() {}

void loop()
{
  noInterrupts();
  // critical, time-sensitive code here
  interrupts();
  // other code here
}

void HardwareSerial::begin  (long speed)

Serial.available()

int incomingByte = 0;   // for incoming serial data

void setup() {
        Serial.begin(9600);     // opens serial port, sets data rate to 9600 bps
}

void loop() {

        // send data only when you receive data:
        if (Serial.available() > 0) {
                // read the incoming byte:
                incomingByte = Serial.read();

                // say what you got:
                Serial.print("I received: ");
                Serial.println(incomingByte, DEC);
        }
}

void setup() {
  Serial.begin(9600);
  Serial1.begin(9600);

}

void loop() {
  // read from port 0, send to port 1:
  if (Serial.available()) {
    int inByte = Serial.read();
    Serial1.print(inByte, BYTE);

  }
  // read from port 1, send to port 0:
  if (Serial1.available()) {
    int inByte = Serial1.read();
    Serial.print(inByte, BYTE);
  }
}

Serial.read()

int incomingByte = 0;   // 用于存储从串口读到的数据

void setup() {
        Serial.begin(9600);     // 打开串吕，设置速率为9600 bps
}

void loop() {

        // 只在收到数据时发送数据
        if (Serial.available() > 0) {
                // 读取传入的字节
                incomingByte = Serial.read();

                // 指示你收到的数据
                Serial.print("I received: ");
                Serial.println(incomingByte, DEC);
        }
}

    Serial.print(78) 发送 "78"
    Serial.print(1.23456) 发送 "1.23"
    Serial.print('N') 发送 "N"
    Serial.print("Hello world.") 发送 "Hello world."

    Serial.print(78, BIN) gives "1001110"
    Serial.print(78, OCT) gives "116"
    Serial.print(78, DEC) gives "78"
    Serial.print(78, HEX) gives "4E"
    Serial.println(1.23456, 0) gives "1"
    Serial.println(1.23456, 2) gives "1.23"
    Serial.println(1.23456, 4) gives "1.2346"

    Serial.print(F(“Hello World”))

Serial.print(val)
Serial.print(val, format)

/*
Uses a FOR loop for data and prints a number in various formats.
*/
int x = 0;    // variable

void setup() {
  Serial.begin(9600);      // open the serial port at 9600 bps:
}

void loop() {
  // print labels
  Serial.print("NO FORMAT");       // prints a label
  Serial.print("\t");              // prints a tab

  Serial.print("DEC");
  Serial.print("\t");

  Serial.print("HEX");
  Serial.print("\t");

  Serial.print("OCT");
  Serial.print("\t");

  Serial.print("BIN");
  Serial.print("\t");

  for(x=0; x< 64; x++){    // only part of the ASCII chart, change to suit

    // print it out in many formats:
    Serial.print(x);       // print as an ASCII-encoded decimal - same as "DEC"
    Serial.print("\t");    // prints a tab

    Serial.print(x, DEC);  // print as an ASCII-encoded decimal
    Serial.print("\t");    // prints a tab

    Serial.print(x, HEX);  // print as an ASCII-encoded hexadecimal
    Serial.print("\t");    // prints a tab

    Serial.print(x, OCT);  // print as an ASCII-encoded octal
    Serial.print("\t");    // prints a tab

    Serial.println(x, BIN);  // print as an ASCII-encoded binary
    //                             then adds the carriage return with "println"
    delay(200);            // delay 200 milliseconds
  }
  Serial.println("");      // prints another carriage return
}

Serial.write(val)
Serial.write(str)
Serial.write(buf, len)

void setup(){
  Serial.begin(9600);
}

void loop(){
  Serial.write(45); //以二进制形式发送数字45

   int bytesSent = Serial.write(“hello”); //发送字符串“hello” 并返回该字符串的长度。
}

void serialEvent(){
//statements
}

Arduino Mega only:
void serialEvent1(){
//statements
}

void serialEvent2(){
//statements
}

void serialEvent3(){
//statements
}