Arduino物联网-延时闪灯、模拟量测量、串口、flash 闪存 内存 rom 内存读写等实现

最新推荐文章于 2024-05-12 18:35:04 发布
最新推荐文章于 2024-05-12 18:35:04 发布
阅读量206 收藏
点赞数
分类专栏： Linux基础 嵌入式开发 物联网 文章标签： 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RuanJian_GC/article/details/132417379
版权

programming_arduino_ed2

IO

延时闪灯

void setup()
{
  pinMode(13, OUTPUT);
}

void loop()
{
 digitalWrite(13, HIGH);
 delay(500);
 digitalWrite(13, LOW);
 delay(500);
}

// sketch 03-02 加入变量====
int ledPin = 13;
int delayPeriod = 500;

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
 digitalWrite(ledPin, HIGH);
 delay(delayPeriod);
 digitalWrite(ledPin, LOW);
 delay(delayPeriod);
}

// sketch 03-03  快闪--->满闪=====
int ledPin = 13;
int delayPeriod = 100;

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
 digitalWrite(ledPin, HIGH);
 delay(delayPeriod);
 digitalWrite(ledPin, LOW);
 delay(delayPeriod);
 delayPeriod = delayPeriod + 100;
}


// sketch 03-06    快闪--->满闪-->快闪--->满闪---循环
int ledPin = 13;
int delayPeriod = 100;

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(delayPeriod);
  digitalWrite(ledPin, LOW);
  delay(delayPeriod);
  delayPeriod = delayPeriod + 100; // 闪烁变慢
  if (delayPeriod > 1000) // 循环===回到初始状态
  {
    delayPeriod = 100; 
  }
}


// sketch 03-08   ===== for循环 闪灯
int ledPin = 13;
int delayPeriod = 250;

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  for (int i = 0; i < 20; i ++)
  {
   digitalWrite(ledPin, HIGH);
   delay(delayPeriod);
   digitalWrite(ledPin, LOW);
   delay(delayPeriod);
  }
 delay(3000);
}


// sketch 03-09  带有休息时段的 常数闪灯=====
int ledPin = 13;
int delayPeriod = 100;
int count = 0;

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
 digitalWrite(ledPin, HIGH);
 delay(delayPeriod);
 digitalWrite(ledPin, LOW);
 delay(delayPeriod);
 count ++;
 if (count == 20)
 {
   count = 0;
   delay(3000);  // 闪烁20次，定时休息
 }
}

// sketch 04-04==========带有休息时段的 常数闪灯 const static变量=====
const int ledPin = 13;
const int delayPeriod = 250;

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  static int count = 0;
  digitalWrite(ledPin, HIGH);
  delay(delayPeriod);
  digitalWrite(ledPin, LOW);
  delay(delayPeriod);
  count ++;
  if (count == 20)
  {
    count = 0;
    delay(3000);
  }
}


// sketch 04-01   for 循环实现闪灯  闪灯程序打包成函数====
const int ledPin = 13;
const int delayPeriod = 250;

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  for (int i = 0; i < 20; i ++)
  {//  for 循环实现闪灯
    flash();
  }
 delay(3000);
}

// 闪灯程序打包成函数
void flash()
{
   digitalWrite(ledPin, HIGH);
   delay(delayPeriod);
   digitalWrite(ledPin, LOW);
   delay(delayPeriod);
}



// sketch 04-02=============进一步包装闪灯程序
const int ledPin = 13;
const int delayPeriod = 250;

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  flash(20, delayPeriod);
  delay(3000);
}

void flash(int numFlashes, int d)
{
  for (int i = 0; i < numFlashes; i ++)
  {
    digitalWrite(ledPin, HIGH);
    delay(d);
    digitalWrite(ledPin, LOW);
    delay(d);
  }
}


// sketch 05-02   闪灯延时指定 时间  数组=====================
const int ledPin = 13;
int durations[] = {200, 200, 200, 500, 500, 500, 200, 200, 200};

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop() 
{
  for (int i = 0; i < 9; i++)
  {
    flash(durations[i]);
  }
  delay(1000);
}

void flash(int duration)
{
   digitalWrite(ledPin, HIGH);
   delay(duration);
   digitalWrite(ledPin, LOW);
   delay(duration);
}



//sketch 06-04  ======= io 口 控制 灯开关 ==========
const int inputPin = 5;
const int ledPin = 13;

void setup()
{
  pinMode(ledPin, OUTPUT);
  pinMode(inputPin, INPUT_PULLUP);
}

void loop()
{
  int switchOpen = digitalRead(inputPin);
  digitalWrite(ledPin, !switchOpen);
}


//sketch 06-05    =====低电平触发 闪灯===============
const int inputPin = 5;
const int ledPin = 13;
int ledValue = LOW;
void setup() 
{
  pinMode(inputPin, INPUT_PULLUP);// 上拉
  pinMode(ledPin, OUTPUT);
}
void loop() 
{
  if (digitalRead(inputPin) == LOW) //低电平触发 闪灯 
  {
     ledValue = !ledValue;
     digitalWrite(ledPin, ledValue);
     delay(500);
  }
}



//sketch 06-07   ===== 按键消抖 控制灯闪烁======
#include <Bounce2.h>  // 按键消抖 库 
const int inputPin = 5;
const int ledPin = 13;
int ledValue = LOW;
Bounce bouncer = Bounce(); 

void setup() 
{
  pinMode(inputPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
  bouncer.attach(inputPin);
 // bouncer.interval(50); // interval in ms
}

void loop() 
{
  if (bouncer.update() && bouncer.read() == LOW)  // 按键消抖
  {
   ledValue = ! ledValue;
   digitalWrite(ledPin, ledValue);
   // delay(500);
  }
}



//sketch 07-04  ===端口中断===改变闪灯节奏===

const int interruptPin = 2;
const int ledPin = 13;
int period = 500;

void setup()
{
  pinMode(ledPin, OUTPUT);
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(0, goFast, FALLING);// 端口中断 下降沿中断
}

void loop() 
{
  digitalWrite(ledPin, HIGH);
  delay(period);
  digitalWrite(ledPin, LOW);
  delay(period);  
}

// 端口中断函数 改变闪灯节奏
void goFast()
{
  period = 100;
}

模拟量测量

//sketch 06-08

const int analogPin = 0;

void setup()
{
  Serial.begin(9600);
}
void loop()
{
  int reading = analogRead(analogPin); // 模拟量测量
  float voltage = reading / 204.6;// 转换成电压
  Serial.print("Reading=");
  Serial.print(reading);
  Serial.print("\t\tVolts=");
  Serial.println(voltage);
  delay(500);
}

Arduino音乐键盘tone函数

//sketch 07-03
void setup()
{
  tone(4, 500);
}
void loop() {}

串口


// sketch 03-04
void setup()
{
  Serial.begin(9600);
  int a = 2;
  int b = 2;
  int c = a + b;
  Serial.println(c); 
  Serial.println("Hello");
}
void loop()
{}

// sketch 5-04 ===============打印字符串数组========
char message[] = "Hello";

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

void loop()
{
  Serial.println(message);
  delay(1000);
}



// sketch 03-05   串口 华氏度 摄氏度 转换=====
void setup()
{
  Serial.begin(9600);
  int degC = 20;
  int degF;
  degF = degC * 9 / 5 + 32;
  Serial.println(degF); 
}
void loop()
{}


    
// sketch 05-01   串口打印数组================
int durations[] = {200, 200, 200, 500, 500, 500, 200, 200, 200};

void setup()
{
  Serial.begin(9600);  
  for (int i = 0; i < 9; i++)
  {
    Serial.println(durations[i]);
  }
}

void loop() {}




// sketch 5-05  ======= 串口和闪灯混合，串口字符控制闪灯节奏=======

const int ledPin = 13;
const int dotDelay = 200;

char* letters[] = {
  ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..",    // A-I
  ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.",  // J-R
  "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."          // S-Z
};

char* numbers[] = {
  "-----", ".----", "..---", "...--", "....-", ".....", "-....", "--...", "---..", "----."};

void setup()                 
{
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop()                    
{
  char ch;
  if (Serial.available() > 0)
  {
    ch = Serial.read();
    if (ch >= 'a' && ch <= 'z')
    {
      flashSequence(letters[ch - 'a']);
    }
    else if (ch >= 'A' && ch <= 'Z')
    {
      flashSequence(letters[ch - 'A']);
    }
    else if (ch >= '0' && ch <= '9')
    {
      flashSequence(numbers[ch - '0']);
    }
    else if (ch == ' ')
    {
      delay(dotDelay * 4);  // gap between words  
    }
  }
}

void flashSequence(char* sequence)
{
  int i = 0;
  while (sequence[i] != NULL)
  {
    flashDotOrDash(sequence[i]);
    i++;
  }
  delay(dotDelay * 3);    // gap between letters
}

void flashDotOrDash(char dotOrDash)
{
  digitalWrite(ledPin, HIGH);
  if (dotOrDash == '.')
  {
    delay(dotDelay);           
  }
  else // must be a dash
  {
    delay(dotDelay * 3);           
  }
  digitalWrite(ledPin, LOW);    
  delay(dotDelay); // gap between flashes
}




// sketch 8-01 ====内存拷贝=====串口控制=====

const int ledPin = 13;
const int dotDelay = 200;

const int maxLen = 6; // including null on the end

PROGMEM const char letters[26][maxLen] = {
  ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..",    // A-I
  ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.",  // J-R
  "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."          // S-Z
};


PROGMEM const char numbers[10][maxLen] = {
  "-----", ".----", "..---", "...--", "....-", ".....", "-....", "--...", "---..", "----."
};

void setup()                 
{
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop()                    
{
  char ch;
  char sequence[maxLen];
  if (Serial.available() > 0)
  {
    ch = Serial.read();
    if (ch >= 'a' && ch <= 'z')
    {
      memcpy_P(&sequence, letters[ch - 'a'], maxLen);// 内存拷贝
      flashSequence(sequence);
    }
    else if (ch >= 'A' && ch <= 'Z')
    {
      memcpy_P(&sequence, letters[ch - 'A'], maxLen);
      flashSequence(sequence);
    }
    else if (ch >= '0' && ch <= '9')
    {
      memcpy_P(&sequence, numbers[ch - '0'], maxLen);
      flashSequence(sequence);
    }
    else if (ch == ' ')
    {
      delay(dotDelay * 4);  // gap between words  
    }
  }
}

void flashSequence(char* sequence)
{
  int i = 0;
  while (sequence[i] != NULL)
  {
    flashDotOrDash(sequence[i]);
    i++;
  }
  delay(dotDelay * 3);    // gap between letters
}

void flashDotOrDash(char dotOrDash)
{
  digitalWrite(ledPin, HIGH);
  if (dotOrDash == '.')
  {
    delay(dotDelay);           
  }
  else // must be a dash
  {
    delay(dotDelay * 3);           
  }
  digitalWrite(ledPin, LOW);    
  delay(dotDelay); // gap between flashes
}






//sketch 6-01    =======串口控制 灯 开关====
const int outPin = 3;

void setup()
{
  pinMode(outPin, OUTPUT);
  Serial.begin(9600);
  Serial.println("Enter 1 or 0");
}

void loop()
{
  if (Serial.available() > 0)
  {
    char ch = Serial.read();
    if (ch == '1')
    {
      digitalWrite(outPin, HIGH);
    }
    else if (ch == '0')
    {
      digitalWrite(outPin, LOW);
    }
  }
}


//sketch 06-02  ===== =====读取io状态，并串口打印=========
const int inputPin = 5;
void setup()
{
  pinMode(inputPin, INPUT);
  Serial.begin(9600);
}

void loop()
{
  int reading = digitalRead(inputPin); // 普通输入，默认 低电平
  Serial.println(reading);
  delay(1000);
}

//sketch 06-03 =====上拉输入，默认为 高电平 打印 io口状态=========
const int inputPin = 5;

void setup()
{
  pinMode(inputPin, INPUT_PULLUP);  // 上拉输入，默认为 高电平
  Serial.begin(9600);
}

void loop()
{
  int reading = digitalRead(inputPin);
  Serial.println(reading);
  delay(1000);
}



//sketch 07-01  === 打印随机数==========
void setup()
{
  Serial.begin(9600);
  randomSeed(analogRead(0)); // 随机数种子
}

void loop()
{
  int number = random(1, 7);
  Serial.println(number);
  delay(500); 
}

flash 闪存 内存 rom 内存读写

// sketch 08-02  ==== 串口读数据 写入内存=======
#include <EEPROM.h>
int addr = 0;
char ch;
void setup()                 
{
  Serial.begin(9600);
  ch = EEPROM.read(addr);
}
void loop()                    
{
  if (Serial.available() > 0)
  {
    ch = Serial.read();   // 串口读数据
    EEPROM.write(0, ch);  // 写入内存 单个字节数据
    Serial.println(ch);
  }
  Serial.println(ch);
  delay(1000);
}


// sketch 08-06 ========清空内存数据=================
#include <EEPROM.h>
void setup()                 
{
  Serial.begin(9600);
  Serial.println("Clearing EEPROM");
  for (int i = 0; i < 1024; i++)
  {
    EEPROM.write(i, 0);
  }
  Serial.println("EEPROM Cleared");
}
void loop() {}


// sketch 08-03 ====== 向内存 读写 多字节数据
#include <avr/eeprom.h>
void setup() 
{
  Serial.begin(9600);
  int i1 = 123;
  eeprom_write_block(&i1, 0, 2); // 写2个字节长度的数据
  int i2 = 0;
  eeprom_read_block(&i2, 0, 2);
  Serial.println(i2);
}
void loop() {}


// sketch 08-04 ======== 写 浮点数===========
#include <avr/eeprom.h>
void setup() 
{
  Serial.begin(9600);
  float f1 = 1.23;
  eeprom_write_block(&f1, 0, 4);// 4字节
  float f2 = 0;
  eeprom_read_block(&f2, 0, 4);
  Serial.println(f2);
}
void loop() {}


//sketch 08-07  =========浮点数扩大后(量化) 以一个字节数据 进行存储
#include <EEPROM.h>
void setup()
{
  float tempFloat = 20.75;
  byte tempByte = (int)(tempFloat * 4); // 浮点数扩大后(量化)
  EEPROM.write(0, tempByte); // 以一个字节数据 进行存储
  
  byte tempByte2 = EEPROM.read(0); // 以一个字节数据 进行读取
  float temp2 = (float)(tempByte2) / 4; // 反量化
  Serial.begin(9600);
  Serial.println("\n\n\n");
  Serial.println(temp2);
}
void loop(){}


// sketch 08-05 =============内存存储 字符串 密码数组
#include <avr/eeprom.h>
const int maxPasswordSize = 20; // 数组长度
char password[maxPasswordSize]; // 字符串 密码数组

void setup() 
{
  eeprom_read_block(&password, 0, maxPasswordSize);
  Serial.begin(9600);
}

void loop() 
{
  Serial.print("Your password is:");
  Serial.println(password);
  Serial.println("Enter a NEW password");     
  while (!Serial.available()) {};
  int n = Serial.readBytesUntil('\n', password, maxPasswordSize);
  password[n] = '\0';
  eeprom_write_block(password, 0, maxPasswordSize);  // 写 字符串 密码数组
  Serial.print("Saved Password: ");
  Serial.println(password);
}

显示屏

// sketch 09-01 USB Message Board   LCD==============================
#include <LiquidCrystal.h>
//            lcd(RS E  D4 D5 D6 D7) // 各端口=====
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
/*
其他接口形式
 LiquidCrystal(rs, rw, enable, d4, d5, d6, d7)
 LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
 LiquidCrystal(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)
*/
int numRows = 2;
int numCols = 16;
/*
begin()——定义LCD的长宽（n列×n行），格式lcd.begin(cols, rows)
 clear()——清空LCD，格式lcd.clear()
 home()——把光标移回左上角，即从头开始输出，格式lcd.home()
 setCursor()——移动光标到特定位置，格式lcd.setCursor(col, row)
 write()——在屏幕上显示内容（必须是一个变量，如”Serial.read()”），格式lcd.write(data)
 print()——在屏幕上显示内容（字母、字符串，等等），格式lcd.print(data)
 lcd.print(data, BASE)
 cursor()——显示光标（一条下划线），格式lcd.cursor()
 noCursor()——隐藏光标，格式lcd.noCursor()
 blink()——闪烁光标，格式lcd.blink()
 noBlink()——光标停止闪烁，格式lcd.noBlink()
 display()——（在使用noDisplay()函数关闭显示后）打开显示（并恢复原来内容），格式lcd.display()
 noDisplay()——关闭显示，但不会丢失原来显示的内容，格式为lcd.noDisplay()
 scrollDisplayLeft()——把显示的内容向左滚动一格，格式lcd.scrollDisplayLeft()
 scrollDisplayRight()——把显示的内容向右滚动一格，格式为lcd.scrollDisplayRight()
 autoscroll()——打开自动滚动，这使每个新的字符出现后，原有的字符都移动一格：如果字符一开始从左到右（默认），那么就往左移动一格，否则就向右移动，格式lcd.autoscroll()
 noAutoscroll()——关闭自动滚动，格式lcd.noAutoscroll()
 leftToRight()——从左往右显示，也就是说显示的字符会从左往右排列（默认），但屏幕上已经有的字符不受影响，格式lcd.leftToRight()
 rightToLeft()——从右往左显示，格式lcd.rightToLeft()
 createChar()——自造字符，最多5×8像素，编号0-7，字符的每个像素显示与否由数组里的数（0-不显示，1-显示）决定，格式lcd.createChar(num, data)，有点难理解，可以看一个例子
*/
void setup()
{
  Serial.begin(9600);
  
  lcd.begin(numRows, numCols);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Arduino");
  lcd.setCursor(0,1);
  lcd.print("Rules");
}

void loop()
{
  if (Serial.available() > 0) 
  {
    char ch = Serial.read();
    if (ch == '#')
    {
      lcd.clear();
    }
    else if (ch == '/')
    {
      // new line
      lcd.setCursor(0, 1);
    }
    else
    {
      lcd.write(ch);
    }
  }
}


// sketch 09_02 ====I2C(SSD1306)驱动0.96寸12864 OLED========

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Adafruit_SSD1306 display(4); // pick an unused pin

void setup()   
{                
  display.begin(SSD1306_SWITCHCAPVCC, 0x3c);  // may need to change this
  display.setTextSize(4);
  display.setTextColor(WHITE);
}

void loop() 
{
  static int count = 0;
  display.clearDisplay();
  display.drawRoundRect(0, 0, 127, 63, 8, WHITE);
  display.setCursor(20,20);
  display.print(count);
  display.display();
  count ++;
  if (count > 9999)
  {
    count = 0;
  }
  delay(1000);
}

物联网专题 Ethernet（以太网）

// sketch 10-01 DHCP ==================动态ip访问======
#include <SPI.h>
#include <Ethernet.h>
// MAC address just has to be unique. This should work
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

EthernetServer server(80);

void setup()
{
  Serial.begin(9600);
  Ethernet.begin(mac);
  server.begin();
  Serial.print("Server started on: ");
  Serial.println(Ethernet.localIP());
}

void loop()
{
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) 
  {
    while (client.connected()) 
    {
      // send a standard http response header
      client.println("HTTP/1.1 200 OK");
      client.println("Content-Type: text/html");
      client.println();
      
      // send the body
      client.println("<html><body>");
      client.println("<h1>Arduino Server</h1>");
      client.print("<p>A0="); 
      client.print(analogRead(0)); 
      client.println("</p>"); 
      client.print("<p>millis="); 
      client.print(millis()); 
      client.println("</p>"); 
      client.println("</body></html>");
      client.stop();
    }
    delay(1);
  }
}


// sketch 10-01 Static IP  ====== 静态ip访问=================================
#include <SPI.h>
#include <Ethernet.h>
// MAC address just has to be unique. This should work
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
// The IP address will be dependent on your local network:
byte ip[] = { 192, 168, 1, 30 };

EthernetServer server(80);

void setup()
{
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.begin(9600);
}

void loop()
{
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) 
  {
    while (client.connected()) 
    {
      // send a standard http response header
      client.println("HTTP/1.1 200 OK");
      client.println("Content-Type: text/html");
      client.println();
      
      // send the body
      client.println("<html><body>");
      client.println("<h1>Arduino Server</h1>");
      client.print("<p>A0="); 
      client.print(analogRead(0)); 
      client.println("</p>"); 
      client.print("<p>millis="); 
      client.print(millis()); 
      client.println("</p>"); 
      client.println("</body></html>");
      client.stop();
    }
    delay(1);
  }
}



// sketch 10-02 Web Controlled Arduino   动态IP WEB远程控制 终端arduino

#include <SPI.h>
#include <Ethernet.h>

// MAC address just has to be unique. This should work
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

EthernetServer server(80);

int numPins = 5;
int pins[] = {3, 4, 5, 6, 7};
int pinState[] = {0, 0, 0, 0, 0};
char line1[100];

void setup()
{
  for (int i = 0; i < numPins; i++)
  {
     pinMode(pins[i], OUTPUT);
  }
  Serial.begin(9600);
  Ethernet.begin(mac);
  server.begin();
  Serial.print("Server started on: ");
  Serial.println(Ethernet.localIP());
}

void loop()
{
  EthernetClient client = server.available();
  if (client) 
  {
    while (client.connected()) 
    {
      readHeader(client);
      if (! pageNameIs("/"))
      {
        client.stop();  
        return;
      }
      client.println("HTTP/1.1 200 OK");
      client.println("Content-Type: text/html");
      client.println();

      // send the body
      client.println("<html><body>");
      client.println("<h1>Output Pins</h1>");
      client.println("<form method='GET'>");  
      setValuesFromParams();
      setPinStates();
      for (int i = 0; i < numPins; i++)
      {
         writeHTMLforPin(client, i);
      }
      client.println("<input type='submit' value='Update'/>");
      client.println("</form>");
      client.println("</body></html>");

      client.stop();            
    }
  }
}

void writeHTMLforPin(EthernetClient client, int i)
{
  client.print("<p>D");
  client.print(pins[i]);  
  client.print(" <select name='");
  client.print(i);
  client.println("'>");
  client.print("<option value='0'");
  if (pinState[i] == 0)
  {
    client.print(" selected");
  }
  client.println(">Off</option>");
  client.print("<option value='1'");
  if (pinState[i] == 1)
  {
    client.print(" selected");
  }
  client.println(">On</option>");
  client.println("</select></p>");  
}

void setPinStates()
{
  for (int i = 0; i < numPins; i++)
  {
     digitalWrite(pins[i], pinState[i]);
  }
}

void setValuesFromParams()
{
  for (int i = 0; i < numPins; i++)
  {
    pinState[i] = valueOfParam(i + '0');
  }
}

void readHeader(EthernetClient client)
{
  // read first line of header
  char ch;
  int i = 0;
  while (ch != '\n')
  {
    if (client.available())
    {
      ch = client.read();
      line1[i] = ch;
      i ++;
    }
  }
  line1[i] = '\0'; 
  Serial.println(line1);
}

boolean pageNameIs(char* name)
{
   // page name starts at char pos 4
   // ends with space
   int i = 4;
   char ch = line1[i];
   while (ch != ' ' && ch != '\n' && ch != '?')
   {
     if (name[i-4] != line1[i])
     {
       return false;
     }
     i++;
     ch = line1[i];
   }
   return true;
}

int valueOfParam(char param)
{
  for (int i = 0; i < strlen(line1); i++)
  {
    if (line1[i] == param && line1[i+1] == '=')
    {
      return (line1[i+2] - '0');
    }
  }
  return 0;
}



// sketch 10-02 Internet Pins ====== 静态ip web远程控制 终端 arduino==============

#include <SPI.h>
#include <Ethernet.h>

// MAC address just has to be unique. This should work
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
// The IP address will be dependent on your local network:
byte ip[] = { 192, 168, 1, 30 };
EthernetServer server(80);

int numPins = 5;
int pins[] = {3, 4, 5, 6, 7};
int pinState[] = {0, 0, 0, 0, 0};
char line1[100];

void setup()
{
  for (int i = 0; i < numPins; i++)
  {
     pinMode(pins[i], OUTPUT);
  }
  Serial.begin(9600);
  Ethernet.begin(mac, ip);
  server.begin();
}

void loop()
{
  EthernetClient client = server.available();
  if (client) 
  {
    while (client.connected()) 
    {
      readHeader(client);
      if (! pageNameIs("/"))
      {
        client.stop();  
        return;
      }
      client.println("HTTP/1.1 200 OK");
      client.println("Content-Type: text/html");
      client.println();

      // send the body
      client.println("<html><body>");
      client.println("<h1>Output Pins</h1>");
      client.println("<form method='GET'>");  
      setValuesFromParams();
      setPinStates();
      for (int i = 0; i < numPins; i++)
      {
         writeHTMLforPin(client, i);
      }
      client.println("<input type='submit' value='Update'/>");
      client.println("</form>");
      client.println("</body></html>");

      client.stop();            
    }
  }
}

void writeHTMLforPin(EthernetClient client, int i)
{
  client.print("<p>D");
  client.print(pins[i]);  
  client.print(" <select name='");
  client.print(i);
  client.println("'>");
  client.print("<option value='0'");
  if (pinState[i] == 0)
  {
    client.print(" selected");
  }
  client.println(">Off</option>");
  client.print("<option value='1'");
  if (pinState[i] == 1)
  {
    client.print(" selected");
  }
  client.println(">On</option>");
  client.println("</select></p>");  
}

void setPinStates()
{
  for (int i = 0; i < numPins; i++)
  {
     digitalWrite(pins[i], pinState[i]);
  }
}

void setValuesFromParams()
{
  for (int i = 0; i < numPins; i++)
  {
    pinState[i] = valueOfParam(i + '0');
  }
}

void readHeader(EthernetClient client)
{
  // read first line of header
  char ch;
  int i = 0;
  while (ch != '\n')
  {
    if (client.available())
    {
      ch = client.read();
      line1[i] = ch;
      i ++;
    }
  }
  line1[i] = '\0'; 
  Serial.println(line1);
}

boolean pageNameIs(char* name)
{
   // page name starts at char pos 4
   // ends with space
   int i = 4;
   char ch = line1[i];
   while (ch != ' ' && ch != '\n' && ch != '?')
   {
     if (name[i-4] != line1[i])
     {
       return false;
     }
     i++;
     ch = line1[i];
   }
   return true;
}

int valueOfParam(char param)
{
  for (int i = 0; i < strlen(line1); i++)
  {
    if (line1[i] == param && line1[i+1] == '=')
    {
      return (line1[i+2] - '0');
    }
  }
  return 0;
}

无线网模块

// sketch 10-03. Node MCU Basic Web Server

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

const char* ssid = "my-network-name"; // 无线网名称
const char* password = "my_password"; // 无线网密码

ESP8266WebServer server(80);

void handleRoot()
{
  String message = "<html><body>\n";
  message += "<h1>Arduino Server</h1>\n";
  message += "<p>A0="; 
  message += analogRead(A0); 
  message += "</p>"; 
  message += "<p>millis="; 
  message += millis(); 
  message += "</p>"; 
  message += "</html></body>\n";
  server.send(200, "text/html", message);
}

void connectToWiFi()
{
  Serial.print("\n\nConnecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");  
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void setup()
{
  Serial.begin(115200);
  connectToWiFi();

  server.on("/", handleRoot);

  server.begin();
  Serial.println("HTTP server started");
}

void loop()
{
  server.handleClient();
}




// sketch 10-04 Web Controlled Node MCU ==== 无线网 控制终端 arduino==========

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

const char* ssid = "my-network-name";
const char* password = "my_password";

int numPins = 5;
char* pinNames[] = {"D5", "D6", "D7", "D8", "D9"};
int pins[] = {D5, D6, D7, D8, D9};
int pinState[] = {0, 0, 0, 0, 0};

ESP8266WebServer server(80);

void setPinStates()
{
  for (int i = 0; i < numPins; i++)
  {
     digitalWrite(pins[i], pinState[i]);
  }
}

void setValuesFromParams()
{
  for (int i = 0; i < numPins; i++)
  {
    pinState[i] = server.arg(i).toInt();
  }
}

void connectToWiFi()
{
  Serial.print("\n\nConnecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");  
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void handleRoot()
{
  char buff[1000];
  Serial.println("Got a Request");
  setValuesFromParams();
  setPinStates();
  
  strcat(buff, "<html><body>\n");
  strcat(buff, "<h1>Output Pins</h1>\n");
  strcat(buff, "<form method='GET'>\n"); 
  for (int i = 0; i < numPins; i++)
  {
    strcat(buff, "<p>");
    strcat(buff, pinNames[i]);
    strcat(buff, " <select name='");
    char indexStr[10];
    sprintf(indexStr, "%d", i);
    strcat(buff, indexStr);
    strcat(buff, "'><option value='0'");
    if (pinState[i] == 0)
    {
      strcat(buff, " selected");
    }
    strcat(buff, ">Off</option>");
    strcat(buff, "<option value='1'");
    if (pinState[i] == 1)
    {
      strcat(buff, " selected");
    }
    strcat(buff, ">On</option></select></p>\n");
  }
  strcat(buff, "<input type='submit' value='Update'/>");
  strcat(buff, "</form></html></body>\n");
  server.send(200, "text/html", buff);
}


void setup()
{
  for (int i = 0; i < numPins; i++)
  {
     pinMode(pins[i], OUTPUT);
  }
  Serial.begin(115200);
  
  connectToWiFi();
  
  server.on("/", handleRoot);

  server.begin();
  Serial.println("HTTP server started");
}

void loop()
{
  server.handleClient();
}

IFTTT 表示如果在“this”上发生了某些事情，那么我们需要在“that”上做一些事情。

// sketch 10-05 IFTTT
#include <SPI.h>
#include <Ethernet.h>


// MAC address just has to be unique. This should work
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

const char* key = "c1AsQq_qsQVTSO5-6NASqg";
const char* host = "maker.ifttt.com";
const int httpPort = 80;
const long sendPeriod = 60000L; // 1 minute

EthernetClient client;

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

void sendToIFTTT(int reading)
{
  client.stop(); // for second time around the loop
  Serial.print("connecting to ");
  Serial.println(host);
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }
  
  String url = "/trigger/arduino_spoke/with/key/";
  url += key;
  url += "?value1=" + String(reading);

  String req = String("GET ") + url + " HTTP/1.1\r\n" +  
               "Host: " + host + "\r\n" +
               "Connection: close\r\n\r\n";
  Serial.println(req);
  client.print(req);
}

void loop() 
{
  static long lastReadingTime = 0;
  long now = millis();
  if (now > lastReadingTime + sendPeriod)
  {
    int reading = analogRead(A0);
    sendToIFTTT(reading);
    lastReadingTime = now;
  }
  if (client.available())
  {
    Serial.write(client.read());
  }
}



// sketch 10_06=======wifi连接IFTTT=================

#include <ESP8266WiFi.h>

const char* ssid = "my-network-name";
const char* password = "my_password";
const char* key = "c1AsQq_qsQVTSO5-6NASqg";
const char* host = "maker.ifttt.com";
const int httpPort = 80;
const long sendPeriod = 10000L; // 1 minute

WiFiClient client;

void connectToWiFi()
{
  Serial.print("\n\nConnecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");  
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void sendToIFTTT(int reading)
{
  Serial.print("connecting to ");
  Serial.println(host);

  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }
  
  String url = "/trigger/arduino_spoke/with/key/";
  url += key;
  url += "?value1=" + String(reading);

  String req = String("GET ") + url + " HTTP/1.1\r\n" +  
               "Host: " + host + "\r\n" +
               "Connection: close\r\n\r\n";
  Serial.println(req);
  client.print(req);
}

void setup() 
{
  Serial.begin(115200);
  connectToWiFi();
}

void loop() 
{
  static long lastReadingTime = 0;
  long now = millis();
  if (now > lastReadingTime + sendPeriod)
  {
    int reading = analogRead(A0);
    sendToIFTTT(reading);
    lastReadingTime = now;
  }
  if (client.available())
  {
    Serial.write(client.read());
  }
}
唐先生的博客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Arduino延时灯
ljsz36的博客
02-05 2286
实物连接图： 电路图： 代码： ​ void setup() { Serial.begin(9600); pinMode(2, INPUT); pinMode(5, OUTPUT); } bool va1; int va2 = 0; //灯是否亮 void loop() { va1 = digitalRead(2); Serial.println(va1); if (va1 == 0) { // 如果读到按钮按下(接到低电位),输出高电平 dig..
Arduino延时控制
m0_52539320的博客
04-02 5339
Arduino延时控制 这个功能应该主要是用到time的库，具体的功能有： 前面两个是计数器，后面两个是延时的函数，第一个单位是毫秒，第二个单位是微秒。
【Arduino】delay()、millis() 时间函数
最新发布
物联网爱好者
05-12 618
如果使用delay进行延时，将导致整个程序阻塞，影响此后的其他操作。对于处理稍微复杂的程序，很容易导致程度卡顿。推荐使用milis（）函数，获取当前时间，根据不同的时间执行不同的操作，实现同样的定时、等待功能。在前面，我们使用delay()函数实现的LED的的间隔点亮，但是使用delay() 函数缺点：会堵塞整个loop，不能同时执行多个任务。运行延时函数时，会等待指定的时间，再运行此后的程序。两个函数都可以获取运行时间，也就是单片机开机至今的时间。micros(),微秒数，大约70分钟后溢出，回到零。
Arduino 通过millis()函数实现延时
perseverance51博客
09-26 6812
Arduino 通过millis()函数实现延时
【雕爷学编程】Arduino 手册之时间函数 delay()
雕爷学编程
09-03 2880
如果你想了解更多关于 Arduino 的信息，你可以访问 Arduino 的官方网站，那里有丰富的资源和教程供你参考。1）delay()函数会阻塞程序的执行，也就是说，在delay()函数执行期间，Arduino无法响应其他的输入或输出信号。因此，在使用delay()函数时，要尽量避免使用过长的延时时间，或者使用其他的非阻塞方式来实现延时效果，例如millis()函数。通过使用millis()函数获取当前时间，并比较与上次执行定时任务的时间差，当时间差达到指定的间隔时，切换LED的状态。
099_Arduino延时控制
小灰笔记
04-20 1万+
这个功能应该主要是用到time的库，具体的功能有： 前面两个是计数器，后面两个是延时的函数，第一个单位是毫秒，第二个单位是微秒。前面两个已经测试过了，后面的这个或许可以这么测试： 初始化串口，打印一个数字； 使用两个延时，通过串口监控上的时间戳做一下对比。 可以测试多个时间间隔。 测试代码1： void setup() { // put ...
arduino-iot-js:Arduino 物联网云 - Javascript SDK
08-04
arduino-iot-js 介绍 此 NPM 模块提供与 Arduino IoT Cloud MQTT 代理的交互。 它可以在浏览器和 node.js 中使用 该模块的主要特点是： 使用 WebSocket 连接/断开与 Arduino IoT Cloud Broker 的连接 发送物联网云...
带有SAP HANA云平台的Arduino物联网-项目开发
03-30
标题中的“带有SAP HANA云平台的Arduino物联网-项目开发”揭示了本主题的核心，即如何使用SAP HANA云平台与Arduino硬件相结合，构建一个物联网(IoT)项目。SAP HANA是一个高性能的数据处理和分析平台，而Arduino则是...
使用ESP8266-01和Arduino的物联网-项目开发
03-30
在本项目中，我们将探索如何使用ESP8266-01模块与Arduino进行物联网（IoT）开发，实现远程设备控制。ESP8266因其低廉的价格和强大的功能，已经成为许多DIY爱好者和开发者首选的WiFi模块。下面将详细介绍这个项目的几...
物联网-智慧传输-基于Arduino平台的测试开发效率提升.pdf
07-06
"物联网-智慧传输-基于Arduino平台的测试开发效率提升" 本文主要研究了基于Arduino平台的测试开发效率提升，通过分析Arduino平台的特点和优势，提出了一种基于Arduino平台的测试开发方法，旨在提高测试效率和降低...
Arduino--ESP8266物联网WIFI模块（贝壳物联）--数据上传服务器（单数据接口）
07-01
**Arduino与ESP8266：开启物联网之旅** 在当今的智能硬件领域，Arduino和ESP8266的组合已经成为物联网(IoT)项目中的热门选择。Arduino是一种开放源码的电子原型平台，易于上手，适合初学者和专业开发者。而ESP8266...
Arduino使用 millis()延时实现
Utai的博客
05-04 1万+
unsigned long previousMillis = 0; boolean delayState = false; void setup() { pinMode(7, INPUT_PULLUP); Serial.begin(115200); } void loop() { ///////////////////////按键引脚触发延时///////////////////...
Arduino——把变量放到flash
CSDN博客
05-10 5309
如果arduino程序莫名不能运行、重启，莫名的问题，内存不够，内存溢出，如果还不能搞定arduino内存不够用，也许可以通过把变量定义到Flash来解决。PROGMEM关键字可以帮你把放在ram里面的变量，存到flash上面去，释放内存的占用。 比如： 原来这样定义，放到ram中，占用内存宝贵的6个字节。 unsigned int charSet[] = {1,2,3}; 改成这样：放到flash中，占用廉价的flash6个字节，释放出内存6个字节。 PROGMEMprog_uint16_...
Arduino 单片机程序中处理时间戳、时间溢出和延时问题
刻[苦] 的 blog
05-28 2823
这个话题对其他单片机也适用，就是用来计时的变量万一溢出了该怎么整，类似那个经典的千年虫问题。实际上这个问题在日常生活中也很常见，比如，时钟上的小时最大值为23，从0 开始，每过24 小时归零一次，只按时钟上的小时数来记录时间，最多只能计24 小时。时间超过最大值后归零就是所谓的溢出问题。一种常见的设计是用比较时间戳的方法来预约一个延时任务，比如在1 点整的时候开始一个2 小时的延时任务，1 + 2 = 3，所以任务预约在3 点执行，当前时间大于3 时这个任务就该执行了。
Arduino框架下ESP32/8266使用PROGMEM功能将数据存储到flash中的使用规范
perseverance51博客
09-12 4158
Arduino框架下ESP32/8266使用PROGMEM功能将数据存储到flash中的使用规范
arduino 读取模拟值
xinshuwei的博客
10-04 2169
int potpin=0;//指定模拟端口A0 int ledpin=13;//指定LED端口 13 int val=0;//声明临时变量 void setup() { pinMode(ledpin,OUTPUT);//设置端口13为输出模式 Serial.begin(9600);//设置串口波特率为9600 } void loop() { digitalWrite(ledpin,HIGH);//拉高端口13，LED点亮 delay(50);//延时0.05秒 digitalWrite(
Arduino：将数据存入片内FLASH解决…
热门推荐
arenascat的博客
03-08 1万+
Arduino 的IDE默认都是将一些字符串，数组存储在RAM中，而RAM虽然速度快但是328p只有区区2K，很多时候完全不够用。类似字符数组，还有自定义的LCD文字，这类对存取速度没有太高要求的数据，我们可以储存在328p的FLASH中，FLASH有32K，足够应付大多情况 要使用FLASH首先需要包括头文件： #include 之后便可以使用PROGMEM来定义 比如有一段定义128
Arduino UNO模拟量采集
zwwang2014的博客
04-13 3320
Arduino UNO模拟量采集环境准备打开arduino开发环境观察输出结果 环境准备 准备一个滑动变阻器，Arduino uno 板一块，接线图如下： 打开arduino开发环境 编写程序代码如下 void setup() { //设置串口波特率为9600bps Serial.begin(9600); } void loop() { //延时1秒 delay(100); ...
Arduino 模拟信号的读入并转化,map函数将PotBuffer的取值范围改为（0～255）或 为0-5V电压,esp32c3 pwm输出,读取模拟量,按钮测试
m0_52539320的博客
09-26 921
Arduino 模拟信号的读入并转化为0-5V电压
Arduino物联网开发入门v0.6.pdf
03-01
"Arduino物联网开发入门，讲解如何利用Arduino进行物联网设备开发，重点介绍WiFi模块在Arduino上的应用，推荐使用WiFiduino-8266开发板，并提及ESP8266和ESP32芯片及其优势。" 物联网(IoT)技术通过网络将各类设备...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

唐先生的博客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值