月度归档： 2020 年 12 月

BrainCraft HAT：树莓派机器学习扩展板

最近Adafruit出了一款名叫BrainCraft的带屏幕扩展版，配上树莓派摄像头和扬声器。可以让树莓派机器学习演示起来简单不少。​

比如，你可以在这个组合上跑个Tensorflow Lite，然后做成物品识别装置。识别万物，语音表达。

当然，既然涉及AI计算，散热风扇肯定不能少。

目前该扩展板在境外的售价大概是39.95美元，大约折合人民币261.30元。

相关微博视频链接：

https://weibo.com/5408421566/JB3xhirVU?from=page_1005055408421566_profile&wvr=6&mod=weibotime&type=comment

如果不知道怎么操作和安装这个组合，可以访问：

https://learn.adafruit.com/running-tensorflow-lite-on-the-raspberry-pi-4/display-setup

让鸿蒙智能家居开发板与AWS IoT云完美连通

本期直播简介：

使用鸿蒙智能家居开发板连通AWS IoT云平台


直播课程大纲：

1、AWS IoT平台介绍

2、AWS IoT SDK介绍

3、移植AWS IoT SDK到HarmonyOS

4、实现HarmonyOS接入AWS IoT

三大隐藏福利：

1、讲师在线答疑互动

2、一个小时两轮抽奖

3、进群掌握一手资讯

讲师介绍：

连志安——广州旗点智能科技有限公司创始人

从事物联网行业开发，擅长物联网、嵌入式、Linux、HarmonyOS、RTOS等技术。

书籍《物联网——嵌入式开发实战》

直播抽奖：

免费报名+到会看直播，赢取HarmonyOS官方联名T恤、HarmonyOS官方开发板（HiSpark Wi-Fi IoT 智能家居套件）

（中奖用户所填写收件人姓名、电话、地址需为真实信息，信息仅用于工作人员联系用户发放奖品。）

适合人群：

想要学习以下知识的人群：

1、HarmonyOS网络通信

2、利用HarmonyOS连接云平台

3、AWS IoT平台接入

扫码进群：

扫描下方二维码，加入AWS技术交流群

（如无法进群，请添加小助手微信：xiao51cto，备注“AWS加群”）

触碰即盛放的“宝莲灯”——Arduino创意作品

编者注：这是一个名叫JiříPraus的外国小哥实现的Arduino创意作品，实际上是“郁金香”，但看着太像中国神话故事里的“宝莲灯”了。

轻轻抚摸就会绽放，它的六个花瓣将缓慢打开并照耀出彩虹般的光。当花瓣闭合时，它们会产生令人难以置信的带有叶子图案的光。

所需材料：

Arduino Nano R3
SG90微型伺服电机
TTP223触摸传感器
1mm黄铜丝
2mm黄铜管
0.3mm绝缘铜线
WS2812 5050 NeoPixel LED灯 x 7
白色SMD 1206 LED x 30

附注：如何焊接黄铜

https://davidneat.wordpress.com/2015/05/03/a-quick-guide-to-soldering-brass/amp/

推杆如何与花瓣一起运动

当推杆向上移动时，它将连杆和花瓣向下拉。当它向下移动时，它拖着连杆，将花瓣闭合。

单片花瓣的构成：

花瓣由黄铜细条组成，花瓣内有5个白色LED和同一根导线构成的“静脉”结构。

相同的花瓣，一共要做6个。否则它们在关闭时不会构成漂亮的郁金香形状，甚至会卡住。

相关代码：


#include <Adafruit_TiCoServo.h>
#include "SoftPWM.h"

#define NEOPIXEL_PIN A0
#define TOUCH_SENSOR_PIN 2

#define SERVO_PIN 9
//#define SERVO_OPEN 1750
#define SERVO_OPEN 1650
#define SERVO_SAFE_MIDDLE 1000
#define SERVO_CLOSED 775

#define RED 0
#define GREEN 1
#define BLUE 2

float currentRGB[] = {0, 0, 0};
float changeRGB[] = {0, 0, 0};
byte newRGB[] = {0, 0, 0};

#define MODE_SLEEPING 0
#define MODE_BLOOM 3
#define MODE_BLOOMING 4
#define MODE_BLOOMED 5
#define MODE_FADE 6
#define MODE_FADING 7
#define MODE_FADED 8
#define MODE_FALLINGASLEEP 9

#define MODE_RAINBOW 90

byte mode = MODE_FADED;

byte petalPins[] = {3, 4, 5, 6, 10, 11};

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(7, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ400);
Adafruit_TiCoServo servo;

int servoChange = 1; // open
int servoPosition = SERVO_SAFE_MIDDLE;

void setup() {
  Serial.begin(115200);
  pixels.begin();
  servo.attach(SERVO_PIN, SERVO_CLOSED, SERVO_OPEN);

  pinMode(TOUCH_SENSOR_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(TOUCH_SENSOR_PIN), _touchISR, RISING);

  randomSeed(analogRead(A7));
  SoftPWMBegin();

  pixelsUnifiedColor(pixels.Color(0, 0, 0));
  //pixelsUnifiedColor(pixels.Color(255, 70, 0));

  prepareCrossFade(140, 70, 0, 140);
  servo.write(servoPosition);
}

int counter = 0;
byte speed = 15;

void loop() {
  boolean done = true;
  switch (mode) {
    case MODE_BLOOM:
      prepareCrossFadeBloom(500);
      changeMode(MODE_BLOOMING);
      break;

    case MODE_BLOOMING:
      done = crossFade() && done;
      done = openPetals() && done;
      done = petalsBloom(counter) && done;
      if (done) {
        changeMode(MODE_BLOOMED);
      }
      break;

    case MODE_FADE:
      //prepareCrossFade(0, 0, 0, 800);
      changeMode(MODE_FADING);
      break;

    case MODE_FADING:
      done = crossFade() && done;
      done = closePetals() && done;
      done = petalsFade(counter) && done;
      if (done) {
        changeMode(MODE_FADED);
      }
      break;

    case MODE_FADED:
      //prepareCrossFade(140, 70, 0, 140);
      changeMode(MODE_FALLINGASLEEP);
      break;

    case MODE_FALLINGASLEEP:
      done = crossFade() && done;
      done = closePetals() && done;
      if (done) {
        changeMode(MODE_SLEEPING);
      }
      break;

    case MODE_RAINBOW:
      rainbow(counter);
      break;
  }

  counter++;
  delay(speed);
}

void changeMode(byte newMode) {
  if (mode != newMode) {
    mode = newMode;
    counter = 0;
  }
}

void _touchISR() {
  if (mode == MODE_SLEEPING) {
    changeMode(MODE_BLOOM);
  }
  else if (mode == MODE_BLOOMED) {
    changeMode(MODE_FADE);
  }
}

// petals animations

boolean petalsBloom(int j) {
  if (j < 250) {
    return false; // delay
  }
  if (j > 750) {
    return true;
  }
  int val = (j - 250) / 2;
  for (int i = 0; i < 6; i++) {
    SoftPWMSet(petalPins[i], val);
  }
  return false;
}

boolean petalsFade(int j) {
  if (j > 510) {
    return true;
  }
  for (int i = 0; i < 6; i++) {
    SoftPWMSet(petalPins[i], (510 - j) / 2);
  }
  return false;
}

// animations

void prepareCrossFadeBloom(unsigned int duration) {
  byte color = random(0, 5);
  switch (color) {
    case 0: // white
      prepareCrossFade(140, 140, 140, duration);
      break;
    case 1: // red
      prepareCrossFade(140, 5, 0, duration);
      break;
    case 2: // blue
      prepareCrossFade(30, 70, 170, duration);
      break;
    case 3: // pink
      prepareCrossFade(140, 0, 70, duration);
      break;
    case 4: // orange
      prepareCrossFade(255, 70, 0, duration);
      break;
  }
}

void rainbow(int j) {
  uint16_t i;
  byte num = pixels.numPixels() - 1;
  pixels.setPixelColor(pixels.numPixels() - 1, 100, 100, 100);

  for (i = 0; i < num; i++) {
    pixels.setPixelColor(i, colorWheel(((i * 256 / num) + j) & 255));
  }
  pixels.show();
}

// servo function

boolean openPetals() {
  if (servoPosition >= SERVO_OPEN) {
    return true;
  }
  servoPosition ++;
  servo.write(servoPosition);
  return false;
}

boolean closePetals() {
  if (servoPosition <= SERVO_CLOSED) {
    return true;
  }
  servoPosition --;
  servo.write(servoPosition);
  return false;
}

// utility function

void pixelsUnifiedColor(uint32_t color) {
  for (unsigned int i = 0; i < pixels.numPixels(); i++) {
    pixels.setPixelColor(i, color);
  }
  pixels.show();
}

void prepareCrossFade(byte red, byte green, byte blue, unsigned int duration) {
  float rchange = red - currentRGB[RED];
  float gchange = green - currentRGB[GREEN];
  float bchange = blue - currentRGB[BLUE];

  changeRGB[RED] = rchange / (float) duration;
  changeRGB[GREEN] = gchange / (float) duration;
  changeRGB[BLUE] = bchange / (float) duration;

  newRGB[RED] = red;
  newRGB[GREEN] = green;
  newRGB[BLUE] = blue;

  Serial.print(newRGB[RED]);
  Serial.print(" ");
  Serial.print(newRGB[GREEN]);
  Serial.print(" ");
  Serial.print(newRGB[BLUE]);
  Serial.print(" (");
  Serial.print(changeRGB[RED]);
  Serial.print(" ");
  Serial.print(changeRGB[GREEN]);
  Serial.print(" ");
  Serial.print(changeRGB[BLUE]);
  Serial.println(")");
}

boolean crossFade() {
  if (currentRGB[RED] == newRGB[RED] && currentRGB[GREEN] == newRGB[GREEN] && currentRGB[BLUE] == newRGB[BLUE]) {
    return true;
  }
  for (byte i = 0; i < 3; i++) {
    if (changeRGB[i] > 0 && currentRGB[i] < newRGB[i]) {
      currentRGB[i] = currentRGB[i] + changeRGB[i];
    }
    else if (changeRGB[i] < 0 && currentRGB[i] > newRGB[i]) {
      currentRGB[i] = currentRGB[i] + changeRGB[i];
    }
    else {
      currentRGB[i] = newRGB[i];
    }
  }
  pixelsUnifiedColor(pixels.Color(currentRGB[RED], currentRGB[GREEN], currentRGB[BLUE]));
  /*
    Serial.print(currentRGB[RED]);
    Serial.print(" ");
    Serial.print(currentRGB[GREEN]);
    Serial.print(" ");
    Serial.print(currentRGB[BLUE]);
    Serial.println();
  */
  return false;
}

uint32_t colorWheel(byte wheelPos) {
  // Input a value 0 to 255 to get a color value.
  // The colours are a transition r - g - b - back to r.
  wheelPos = 255 - wheelPos;
  if (wheelPos < 85) {
    return pixels.Color(255 - wheelPos * 3, 0, wheelPos * 3);
  }
  if (wheelPos < 170) {
    wheelPos -= 85;
    return pixels.Color(0, wheelPos * 3, 255 - wheelPos * 3);
  }
  wheelPos -= 170;
  return pixels.Color(wheelPos * 3, 255 - wheelPos * 3, 0);
}
Credits

【有奖直播课】鸿蒙驱动框架调试总结——火热报名中！

鸿蒙系统的驱动框架被称为HDF（HarmonyOS Driver Foundation），包括驱动加载，驱动服务管理和驱动消息机制。

HDF的驱动加载机制，包括按需加载和按序加载。按需加载的意思是可以配置启动的过程中哪些驱动加载，哪些驱动不加载；按序加载，就是按照优先级的顺序加载。

驱动服务管理是指驱动程序是不是可以被使用，如果可以被使用，是只能被用户态使用，还是只能被内核态使用，还是两个同时可以被使用。上面两项机制可以通过hcs格式的配置文件来实现，相对来说比较简单。

驱动服务的消息机制是指如何在用户态程序和内核态程序之间进行通信，包括用户态应用发送信息到驱动程序和用户态程序接收驱动主动上报事件。

2020年12月10日（本周四）晚20：00，我将为大家做一场鸿蒙驱动框架开发讲解的直播，主题是《HarmonyOS鸿蒙驱动框架调试总结》。主要探讨的是消息机制，大体的过程如下图所示，供大家参考。

在此次直播中，我会给大家展示鸿蒙驱动框架的基本结构以及如何进行驱动的开发。

主要内容包括如何进行内核态驱动程序的编写，如何把内核态驱动程序添加到系统中去，

如何进行用户态程序的编写，以及如何编译、下载。

最后，我们会根据根据程序运行结果来验证我们编写的驱动程序。

直播结束后，我会将相关代码提供给大家，一起交流学习。

>>>点击免费报名<<<

课程大纲：

1、鸿蒙系统简介以及鸿蒙相关开发资料网站介绍

2、张飞实战电子南极洲开发板介绍

3、鸿蒙驱动框架介绍

4、编写内核驱动程序样例

5、把驱动源码放入内核

6、编写用户态程序APP

7、编译、烧写、调试

讲师介绍：

张角——嵌入式研发工程师 张飞实战电子鸿蒙系统、嵌入式实时操作系统以及Risc-V单片机课程主讲老师。 专注单片机程序开发，鸿蒙系统驱动及应用开发，linux系统驱动及应用开发，同时对硬件电路设计，开关电源设计以及电机驱动设计有浓厚的兴趣。

直播抽奖：

免费报名+到会看直播，赢取HarmonyOS官方联名T恤、HarmonyOS官方开发板（HiSpark Wi-Fi IoT 智能家居套件） （中奖用户所填写收件人姓名、电话、地址需为真实信息，信息仅用于工作人员联系用户发放奖品。）

适合人群：

对鸿蒙系统开发感兴趣的学生、工程师以及其他相关人员  

>>>点击免费报名<<<