Basra控制板

Windows系统的电脑

/*

  Blink

  Turns an LED on for one second, then off for one second, repeatedly.

  Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO

  it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to

  the correct LED pin independent of which board is used.

  If you want to know what pin the on-board LED is connected to on your Arduino

  model, check the Technical Specs of your board at:

  https://www.arduino.cc/en/Main/Products

  modified 8 May 2014

  by Scott Fitzgerald

  modified 2 Sep 2016

  by Arturo Guadalupi

  modified 8 Sep 2016

  by Colby Newman

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/Blink

*/

// the setup function runs once when you press reset or power the board

void setup() {

  // initialize digital pin LED_BUILTIN as an output.

  pinMode(LED_BUILTIN, OUTPUT);

}

// the loop function runs over and over again forever

void loop() {

  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)

  delay(1000);                       // wait for a second

  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW

  delay(1000);                       // wait for a second

}

/*

  Serial Event example

  When new serial data arrives, this sketch adds it to a String.

  When a newline is received, the loop prints the string and clears it.

  A good test for this is to try it with a GPS receiver that sends out

  NMEA 0183 sentences.

  NOTE: The serialEvent() feature is not available on the Leonardo, Micro, or

  other ATmega32U4 based boards.

  created 9 May 2011

  by Tom Igoe

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/SerialEvent

*/

String inputString = "";         // a String to hold incoming data

bool stringComplete = false;   // whether the string is complete

void setup() {

  // initialize serial:

  Serial.begin(9600);

  // reserve 200 bytes for the inputString:

  inputString.reserve(200);

}

void loop() {

  // print the string when a newline arrives:

  if (stringComplete) {

    Serial.println(inputString);

    // clear the string:

    inputString = "";

    stringComplete = false;

  }

}

/*

  SerialEvent occurs whenever a new data comes in the hardware serial RX. This

  routine is run between each time loop() runs, so using delay inside loop can

  delay response. Multiple bytes of data may be available.

*/

void serialEvent() {

  while (Serial.available()) {

    // get the new byte:

    char inChar = (char)Serial.read();

    // add it to the inputString:

    inputString += inChar;

    // if the incoming character is a newline, set a flag so the main loop can

    // do something about it:

    if (inChar == '\n') {

      stringComplete = true;

    }

  }

}

String inputString = "";         // a string to hold incoming data

boolean stringComplete = false;   // whether the string is complete

void setup() {

  // initialize serial:

  Serial.begin(9600);

  // reserve 200 bytes for the inputString:

  inputString.reserve(200);

}

void loop()

{

  if(stringComplete)   //判断是否有数据输入

  {

    stringComplete = false;

    Serial.println((String)(calculate()));   //打印结果

  }

}

/******************************************

函数名称：calculate

函数功能：对输入数据进行四则运算

函数参数：无

返 回 值：运算结果

******************************************/

int calculate()

{

  char case_deal;

  int a, b, result, location;

  String tmp;

  inputString.trim(); //去掉回车

  Serial.print(inputString + '=');

//运算符号判断

  if((location = (inputString.indexOf('+'))) > 0)

  {

      case_deal = 1;

  }

  else if((location = (inputString.indexOf('-'))) > 0)

  {

      case_deal = 2;

  }

  else if((location = (inputString.indexOf('*'))) > 0)

  {

      case_deal = 3;

  }

  else if((location = (inputString.indexOf('/'))) > 0)

  {

      case_deal = 4;

  }

  else

  {

    Serial.println("error");   //错误处理

    return -1;

  }

  tmp = inputString.substring(0, location); //解析第一个数字

  a = tmp.toInt();   //将字符串转换成数字

  tmp = inputString.substring(location+1);   //解析第二个数字

  b = tmp.toInt();   //将字符串转换成数字

  switch (case_deal)   //运算处理

  {

       case 1:

         result = a + b;

         break;

       case 2:

         result = a - b;

         break;

       case 3:

          result = a * b;

          break;

       case 4:

          result = a / b;

          break;

       default:

          result = -1;

   }

  inputString = ""; //输入清空，不然下次读入出错

  return result;

}

void serialEvent()

{

  while (Serial.available()) {

    // get the new byte:

    char inChar = (char)Serial.read();

    // add it to the inputString:

    inputString += inChar;

    // if the incoming character is a newline, set a flag

    // so the main loop can do something about it:

    if (inChar == '\n') {

      stringComplete = true;

    }

  }

}

序号

计算器小程序源代码

* EEPROM Clear

*

* Sets all of the bytes of the EEPROM to 0.

* Please see eeprom_iteration for a more in depth

* look at how to traverse the EEPROM.

*

* This example code is in the public domain.

*/

#include <EEPROM.h>

void setup() {

  // initialize the LED pin as an output.

  pinMode(13, OUTPUT);

  /***

    Iterate through each byte of the EEPROM storage.

    Larger AVR processors have larger EEPROM sizes, E.g:

    - Arduno Duemilanove: 512b EEPROM storage.

    - Arduino Uno:        1kb EEPROM storage.

    - Arduino Mega:       4kb EEPROM storage.

    Rather than hard-coding the length, you should use the pre-provided length function.

    This will make your code portable to all AVR processors.

  ***/

  for (int i = 0 ; i < EEPROM.length() ; i++) {

    EEPROM.write(i, 0);

  }

  // turn the LED on when we're done

  digitalWrite(13, HIGH);

}

void loop() {

  /** Empty loop. **/

}

/*

* EEPROM Read

*

* Reads the value of each byte of the EEPROM and prints it

* to the computer.

* This example code is in the public domain.

*/

#include <EEPROM.h>

// start reading from the first byte (address 0) of the EEPROM

int address = 0;

byte value;

void setup() {

  // initialize serial and wait for port to open:

  Serial.begin(9600);

  while (!Serial) {

    ; // wait for serial port to connect. Needed for native USB port only

  }

}

void loop() {

  // read a byte from the current address of the EEPROM

  value = EEPROM.read(address);

  Serial.print(address);

  Serial.print("\t");

  Serial.print(value, DEC);

  Serial.println();

  /***

    Advance to the next address, when at the end restart at the beginning.

    Larger AVR processors have larger EEPROM sizes, E.g:

    - Arduno Duemilanove: 512b EEPROM storage.

    - Arduino Uno:        1kb EEPROM storage.

    - Arduino Mega:       4kb EEPROM storage.

    Rather than hard-coding the length, you should use the pre-provided length function.

    This will make your code portable to all AVR processors.

  ***/

  address = address + 1;

  if (address == EEPROM.length()) {

    address = 0;

  }

  /***

    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an

    EEPROM address is also doable by a bitwise and of the length - 1.

    ++address &= EEPROM.length() - 1;

  ***/

  delay(500);

}

/*

* EEPROM Write

*

* Stores values read from analog input 0 into the EEPROM.

* These values will stay in the EEPROM when the board is

* turned off and may be retrieved later by another sketch.

*/

#include <EEPROM.h>

/** the current address in the EEPROM (i.e. which byte we're going to write to next) **/

int addr = 0;

void setup() {

  /** Empty setup. **/

}

void loop() {

  /***

    Need to divide by 4 because analog inputs range from

    0 to 1023 and each byte of the EEPROM can only hold a

    value from 0 to 255.

  ***/

  int val = analogRead(0) / 4;

  /***

    Write the value to the appropriate byte of the EEPROM.

    these values will remain there when the board is

    turned off.

  ***/

  EEPROM.write(addr, val);

  /***

    Advance to the next address, when at the end restart at the beginning.

    Larger AVR processors have larger EEPROM sizes, E.g:

    - Arduno Duemilanove: 512b EEPROM storage.

    - Arduino Uno:        1kb EEPROM storage.

    - Arduino Mega:       4kb EEPROM storage.

    Rather than hard-coding the length, you should use the pre-provided length function.

    This will make your code portable to all AVR processors.

  ***/

  addr = addr + 1;

  if (addr == EEPROM.length()) {

    addr = 0;

  }

  /***

    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an

    EEPROM address is also doable by a bitwise and of the length - 1.

    ++addr &= EEPROM.length() - 1;

  ***/

  delay(100);

}

union data{

    float a;

    byte b[4];

};

#include <EEPROM.h>

union data

{

  float a;

  byte b[4];

};

data col;

int addr = 0;

int led = 13;

void setup()

{

  for(int i=0;i<4;i++)

  col.b[i]=EEPROM.read(i);

  Serial.begin(9600);     

}

void loop()

{

  //输出

  Serial.println(col.a);

  delay(1000);   

}

#include <EEPROM.h>

union data

{

  float a;

  byte b[4];

};

data col;

int addr = 0;

int led = 13;

void setup()

{

  col.a=987.65;

  for(int i=0;i<4;i++)

  EEPROM.write(i, col.b[i]);

  pinMode(led, OUTPUT);     

}

void loop()

{

  //LED闪烁，提示任务已完成

  digitalWrite(led, HIGH);

  delay(1000);

  digitalWrite(led, LOW);

  delay(1000);   

}

data col;

序号

写入浮点数例程源代码

练习题参考答案源代码

void setup(){

  cli();////关闭全局中断

  //设置定时器0为10kHz(100us)

  TCCR0A = 0;//将整个TCCR0A寄存器设置为0

  TCCR0B = 0;//将整个TCCR0B寄存器设置为0

  TCNT0   = 0;//将计数器值初始化为0

  //设置计数器为10kHZ，即100us

  OCR0A = 24;//比较匹配寄存器= [16,000,000Hz /（预分频器*所需中断频率）] - 1

             //比较匹配寄存器=24,中断间隔=100us即中断频率10khz

  TCCR0A |= (1 << WGM01);//打开CTC模式

  TCCR0B |= (1 << CS01) | (1 << CS00); //设置CS01位为1(8倍预分频)   

  TIMSK0 |= (1 << OCIE0A);//启用定时器比较中断

  //设置定时器1为1kHz

  TCCR1A = 0;//将整个TCCR1A寄存器设置为0

  TCCR1B = 0;//将整个TCCR1B寄存器设置为0

  TCNT1   = 0;//将计数器值初始化为0

  //设置计数器为10kHZ，即1ms

  OCR1A = 199;// = (16*10^6)/(1000*8) - 1 (must be <65536)

  TCCR1B |= (1 << WGM12);//打开CTC模式

  TCCR1B |= (1 << CS11);//设置CS11位为1(8倍预分频)

  TIMSK1 |= (1 << OCIE1A);

  //设置定时器2为8kHz

  TCCR2A = 0;// set entire TCCR2A register to 0

  TCCR2B = 0;// same for TCCR2B

  TCNT2   = 0;//initialize counter value to 0

  // set compare match register for 8khz increments

  OCR2A = 249;// = (16*10^6) / (8000*8) - 1 (must be <256)

  // turn on CTC mode

  TCCR2A |= (1 << WGM21);//打开CTC模式

  // Set CS21 bit for 8 prescaler

  TCCR2B |= (1 << CS21);   

  // enable timer compare interrupt

  TIMSK2 |= (1 << OCIE2A);

  sei();//打开全局中断

}

//中断0服务函数

ISR（TIMER0_COMPA_vect）{

//产生频率为2kHz / 2 = 1kHz的脉冲波（全波切换为两个周期，然后切换为低）

  if（toggle0）{

    digitalWrite（8，HIGH）;

    toggle0 = 0;

  }

  else{

    digitalWrite（8，LOW）;

    toggle0 = 1;

  }

}

ISR（TIMER1_COMPA_vect）{// timer1中断1Hz切换引脚13（LED）

//产生频率为1Hz / 2 = 0.5kHz的脉冲波（全波切换为两个周期，然后切换为低）

  if（toggle1）{

    digitalWrite（13，HIGH）;

    toggle1 = 0;

  }

  else{

    digitalWrite（13，LOW）;

    toggle1 = 1;

  }

}

ISR（TIMER2_COMPA_vect）{// timer1中断8kHz切换引脚9

//产生频率为8kHz / 2 = 4kHz的脉冲波（全波切换为两个周期，然后切换为低）

  if（toggle2）{

    digitalWrite（9，HIGH）;

    toggle2 = 0;

  }

  else{

    digitalWrite（9，LOW）;

    toggle2 = 1;

  }

}

void loop（）{

}

// Switch on LED on pin 13 each second

void flash() {

  static boolean output = HIGH;

  digitalWrite(13, output);

  output = !output;

}

void setup() {

  pinMode(13, OUTPUT);

  MsTimer2::set(500, flash); // 500ms period

  MsTimer2::start();

}

void loop() {

}

序号

MsTimer2扩展库

Basra主控板（兼容Arduino Uno）‍

Bigfish2.1扩展板‍

序号

程序源代码

序号

ServoTimer2库