【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812硬屏
2024-04-11 22:03:09
实验使用的硬件，软件平台使用Arduino IDE（见《【花雕体验】15 尝试搭建Beetle ESP32 C3之Arduino开发环境》）
WS2812B
是一个集控制电路与发光电路于一体的智能外控LED光源。其外型与一个5050LED灯珠相同，每个元件即为一个像素点。像素点内部包含了智能数字接口数据锁存信号整形放大驱动电路，还包含有高精度的内部振荡器和12V高压可编程定电流控制部分，有效保证了像素点光的颜色高度一致。数据协议采用单线归零码的通讯方式，像素点在上电复位以后，DIN端接受从控制器传输过来的数据，首先送过来的24bit数据被第一个像素点提取后，送到像素点内部的数据锁存器，剩余的数据经过内部整形处理电路整形放大后通过DO端口开始转发输出给下一个级联的像素点，每经过一个像素点的传输，信号减少24bit。像素点采用自动整形转发技术，使得该像素点的级联个数不受信号传送的限制，仅仅受限信号传输速度要求。
主要特点
● 智能反接保护，电源反接不会损坏IC。
● IC控制电路与LED点光源公用一个电源。
● 控制电路与RGB芯片集成在一个5050封装的元器件中，构成一个完整的外控像素点。
● 内置信号整形电路，任何一个像素点收到信号后经过波形整形再输出，保证线路波形畸变不会累加。
● 内置上电复位和掉电复位电路。
● 每个像素点的三基色颜色可实现256级亮度显示，完成16777216种颜色的全真色彩显示，扫描频率不低于400Hz/s。
● 串行级联接口，能通过一根信号线完成数据的接收与解码。
● 任意两点传传输距离在不超过5米时无需增加任何电路。
● 当刷新速率30帧/秒时，级联数不小于1024点。
● 数据发送速度可达800Kbps。
● 光的颜色高度一致，性价比高。
WS2812B典型应用电路
Beetle ESP32-C3是一款基于ESP32-C3 RISC-V 32位单核处理器芯片的主控板，专为物联网 (IoT) 设备而设计。Beetle ESP32-C3在仅硬币大小的体积上引出了多达13个IO口，制作项目时不必再担心IO口不够用的情况，同时主控板还集成锂电池充电管理功能，可以直接连接锂电池，不需要外围模块，同时保证应用体积和安全性。Beetle ESP32-C3配套的扩展板在未增加太大体积的情况下，引出了更多的电源，在制作项目时焊接更加方便，板载的GDI显示屏接口解决使用屏幕时的接线烦恼。实验使用的引脚为A0和D6。
8X32灯板采用独立电源供电，这里使用华为5V2A手机电源
打开Arduino IDE——工具——管理库，搜索Adafruit NeoPixel，并安装驱动库
【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板
实验程序一：逐一点亮256个绿色LED灯
/*【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板实验程序一：逐一点亮256个绿色LED灯
*/#include <Adafruit_NeoPixel.h>#define PIN 6
#define NUMPIXELS 256Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
int delayval = 60;void setup() {pixels.begin();
}void loop() {for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, pixels.Color(0, 30, 0));pixels.show();delay(delayval);}
}
实验场景图
动态图
http://bbs.eeworld.com.cn/data/attachment/forum/202207/08/190810vbrkt8zd1u5588ib.gif
【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板
实验程序二：简单的流水变幻彩虹灯
/*【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板实验程序二：简单的流水变幻彩虹灯
*/#include <Adafruit_NeoPixel.h>#define PIN 6
#define BRIGHTNESS 128Adafruit_NeoPixel strip = Adafruit_NeoPixel(BRIGHTNESS, PIN, NEO_GRB + NEO_KHZ800);void setup() {strip.setBrightness(BRIGHTNESS);strip.begin();strip.show();
}void loop() {colorWipe(strip.Color(40, 0, 0), 20); // RedcolorWipe(strip.Color(0, 40, 0), 20); // GreencolorWipe(strip.Color(0, 0, 50), 20); // BluecolorWipe(strip.Color(40, 40, 50), 20); // BlueWiterainbowCycle(1);}void colorWipe(uint32_t c, uint8_t wait) {for (uint16_t i = 0; i < strip.numPixels(); i++) {strip.setPixelColor(i, c);strip.show();delay(wait);}
}void rainbow(uint8_t wait) {uint16_t i, j;for (j = 0; j < 256; j++) {for (i = 0; i < strip.numPixels(); i++) {strip.setPixelColor(i, Wheel((i + j) & 255 ));}strip.show();delay(wait);}
}void rainbowCycle(uint8_t wait) {uint16_t i, j;for (j = 0; j < 256 * 5; j++) { // 5 cycles of all colors on wheelfor (i = 0; i < strip.numPixels(); i++) {strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));}strip.show();delay(wait);}
}uint32_t Wheel(byte WheelPos) {if (WheelPos < 85) {return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);} else if (WheelPos < 170) {WheelPos -= 85;return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);} else {WheelPos -= 170;return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);}
}
动态图
http://bbs.eeworld.com.cn/data/attachment/forum/202207/08/203214qfeq52s556iigmpj.gif
动态图
http://bbs.eeworld.com.cn/data/attachment/forum/202207/08/203534vcx2efoof6fyyein.gif
实验场景图
实验的视频记录（1分18秒）
https://v.youku.com/v_show/id_XNTg4NTQ2MDYyMA==.html?firsttime=0
【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板
实验程序三：256位多彩流水灯变幻彩虹灯
/*【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板实验程序三：256位多彩流水灯变幻彩虹灯
*/#include <Adafruit_NeoPixel.h>#define LED_PIN 6
#define LED_COUNT 256Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);void setup() {strip.setBrightness(30);strip.begin();strip.show();
}void loop() {// Fill along the length of the strip in various colors...colorWipe(strip.Color(255, 0, 0), 50); // RedcolorWipe(strip.Color( 0, 255, 0), 50); // GreencolorWipe(strip.Color( 0, 0, 255), 50); // Blue// Do a theater marquee effect in various colors...theaterChase(strip.Color(127, 127, 127), 50); // White, half brightnesstheaterChase(strip.Color(127, 0, 0), 50); // Red, half brightnesstheaterChase(strip.Color( 0, 0, 127), 50); // Blue, half brightnessrainbow(10); // Flowing rainbow cycle along the whole striptheaterChaseRainbow(50); // Rainbow-enhanced theaterChase variant
}// Some functions of our own for creating animated effects -----------------// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {for (int i = 0; i < strip.numPixels(); i++) { // For each pixel in strip...strip.setPixelColor(i, color); // Set pixel's color (in RAM)strip.show(); // Update strip to matchdelay(wait); // Pause for a moment}
}// Theater-marquee-style chasing lights. Pass in a color (32-bit value,
// a la strip.Color(r,g,b) as mentioned above), and a delay time (in ms)
// between frames.
void theaterChase(uint32_t color, int wait) {for (int a = 0; a < 10; a++) { // Repeat 10 times...for (int b = 0; b < 3; b++) { // 'b' counts from 0 to 2...strip.clear(); // Set all pixels in RAM to 0 (off)// 'c' counts up from 'b' to end of strip in steps of 3...for (int c = b; c < strip.numPixels(); c += 3) {strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'}strip.show(); // Update strip with new contentsdelay(wait); // Pause for a moment}}
}// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {// Hue of first pixel runs 5 complete loops through the color wheel.// Color wheel has a range of 65536 but it's OK if we roll over, so// just count from 0 to 5*65536. Adding 256 to firstPixelHue each time// means we'll make 5*65536/256 = 1280 passes through this outer loop:for (long firstPixelHue = 0; firstPixelHue < 5 * 65536; firstPixelHue += 256) {for (int i = 0; i < strip.numPixels(); i++) { // For each pixel in strip...// Offset pixel hue by an amount to make one full revolution of the// color wheel (range of 65536) along the length of the strip// (strip.numPixels() steps):int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());// strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or// optionally add saturation and value (brightness) (each 0 to 255).// Here we're using just the single-argument hue variant. The result// is passed through strip.gamma32() to provide 'truer' colors// before assigning to each pixel:strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));}strip.show(); // Update strip with new contentsdelay(wait); // Pause for a moment}
}// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {int firstPixelHue = 0; // First pixel starts at red (hue 0)for (int a = 0; a < 30; a++) { // Repeat 30 times...for (int b = 0; b < 3; b++) { // 'b' counts from 0 to 2...strip.clear(); // Set all pixels in RAM to 0 (off)// 'c' counts up from 'b' to end of strip in increments of 3...for (int c = b; c < strip.numPixels(); c += 3) {// hue of pixel 'c' is offset by an amount to make one full// revolution of the color wheel (range 65536) along the length// of the strip (strip.numPixels() steps):int hue = firstPixelHue + c * 65536L / strip.numPixels();uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGBstrip.setPixelColor(c, color); // Set pixel 'c' to value 'color'}strip.show(); // Update strip with new contentsdelay(wait); // Pause for a momentfirstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames}}
}
实验动态图
http://bbs.eeworld.com.cn/data/attachment/forum/202207/09/111559i52dyzmtwldwwy2i.gif
【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板
实验程序四：256位多彩火焰灯
/*【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板实验程序四：256位多彩火焰灯
*/#include <FastLED.h>#define LED_PIN 6
#define COLOR_ORDER GRB
#define CHIPSET WS2811
#define NUM_LEDS 256#define BRIGHTNESS 22
#define FRAMES_PER_SECOND 60bool gReverseDirection = false;CRGB leds[NUM_LEDS];// Fire2012 with programmable Color Palette
//
// This code is the same fire simulation as the original "Fire2012",
// but each heat cell's temperature is translated to color through a FastLED
// programmable color palette, instead of through the "HeatColor(...)" function.
//
// Four different static color palettes are provided here, plus one dynamic one.
//
// The three static ones are:
// 1. the FastLED built-in HeatColors_p -- this is the default, and it looks
// pretty much exactly like the original Fire2012.
//
// To use any of the other palettes below, just "uncomment" the corresponding code.
//
// 2. a gradient from black to red to yellow to white, which is
// visually similar to the HeatColors_p, and helps to illustrate
// what the 'heat colors' palette is actually doing,
// 3. a similar gradient, but in blue colors rather than red ones,
// i.e. from black to blue to aqua to white, which results in
// an "icy blue" fire effect,
// 4. a simplified three-step gradient, from black to red to white, just to show
// that these gradients need not have four components; two or
// three are possible, too, even if they don't look quite as nice for fire.
//
// The dynamic palette shows how you can change the basic 'hue' of the
// color palette every time through the loop, producing "rainbow fire".CRGBPalette16 gPal;void setup() {delay(3000); // sanity delayFastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );FastLED.setBrightness( BRIGHTNESS );// This first palette is the basic 'black body radiation' colors,// which run from black to red to bright yellow to white.gPal = HeatColors_p;// These are other ways to set up the color palette for the 'fire'.// First, a gradient from black to red to yellow to white -- similar to HeatColors_p// gPal = CRGBPalette16( CRGB::Black, CRGB::Red, CRGB::Yellow, CRGB::White);// Second, this palette is like the heat colors, but blue/aqua instead of red/yellow// gPal = CRGBPalette16( CRGB::Black, CRGB::Blue, CRGB::Aqua, CRGB::White);// Third, here's a simpler, three-step gradient, from black to red to white// gPal = CRGBPalette16( CRGB::Black, CRGB::Red, CRGB::White);}void loop()
{// Add entropy to random number generator; we use a lot of it.random16_add_entropy( random());// Fourth, the most sophisticated: this one sets up a new palette every// time through the loop, based on a hue that changes every time.// The palette is a gradient from black, to a dark color based on the hue,// to a light color based on the hue, to white.//// static uint8_t hue = 0;// hue++;// CRGB darkcolor = CHSV(hue,255,192); // pure hue, three-quarters brightness// CRGB lightcolor = CHSV(hue,128,255); // half 'whitened', full brightness// gPal = CRGBPalette16( CRGB::Black, darkcolor, lightcolor, CRGB::White);Fire2012WithPalette(); // run simulation frame, using palette colorsFastLED.show(); // display this frameFastLED.delay(1000 / FRAMES_PER_SECOND);
}// Fire2012 by Mark Kriegsman, July 2012
// as part of "Five Elements" shown here: http://youtu.be/knWiGsmgycY
// This basic one-dimensional 'fire' simulation works roughly as follows:
// There's a underlying array of 'heat' cells, that model the temperature
// at each point along the line. Every cycle through the simulation,
// four steps are performed:
// 1) All cells cool down a little bit, losing heat to the air
// 2) The heat from each cell drifts 'up' and diffuses a little
// 3) Sometimes randomly new 'sparks' of heat are added at the bottom
// 4) The heat from each cell is rendered as a color into the leds array
// The heat-to-color mapping uses a black-body radiation approximation.
//
// Temperature is in arbitrary units from 0 (cold black) to 255 (white hot).
//
// This simulation scales it self a bit depending on NUM_LEDS; it should look
// "OK" on anywhere from 20 to 100 LEDs without too much tweaking.
//
// I recommend running this simulation at anywhere from 30-100 frames per second,
// meaning an interframe delay of about 10-35 milliseconds.
//
// Looks best on a high-density LED setup (60+ pixels/meter).
//
//
// There are two main parameters you can play with to control the look and
// feel of your fire: COOLING (used in step 1 above), and SPARKING (used
// in step 3 above).
//
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames. More cooling = shorter flames.
// Default 55, suggested range 20-100
#define COOLING 55// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire. Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
#define SPARKING 120void Fire2012WithPalette()
{// Array of temperature readings at each simulation cellstatic uint8_t heat[NUM_LEDS];// Step 1. Cool down every cell a littlefor( int i = 0; i < NUM_LEDS; i++) {heat[i] = qsub8( heat[i], random8(0, ((COOLING * 10) / NUM_LEDS) + 2));}// Step 2. Heat from each cell drifts 'up' and diffuses a littlefor( int k= NUM_LEDS - 1; k >= 2; k--) {heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;}// Step 3. Randomly ignite new 'sparks' of heat near the bottomif( random8() < SPARKING ) {int y = random8(7);heat[y] = qadd8( heat[y], random8(160,255) );}// Step 4. Map from heat cells to LED colorsfor( int j = 0; j < NUM_LEDS; j++) {// Scale the heat value from 0-255 down to 0-240// for best results with color palettes.uint8_t colorindex = scale8( heat[j], 240);CRGB color = ColorFromPalette( gPal, colorindex);int pixelnumber;if( gReverseDirection ) {pixelnumber = (NUM_LEDS-1) - j;} else {pixelnumber = j;}leds[pixelnumber] = color;}
}
动态图
https://img.mydigit.cn/forum/202207/09/125333jydj0vwvvpjxpj5z.gif
【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板
实验程序五：FastLED的八种动态颜色的配色板
/*【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812灯板实验程序五：FastLED的八种动态颜色的配色板
*/#include <FastLED.h>#define LED_PIN 6
#define NUM_LEDS 256
#define BRIGHTNESS 22
#define LED_TYPE WS2811
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];#define UPDATES_PER_SECOND 100 //定义每秒更新数// This example shows several ways to set up and use 'palettes' of colors
// with FastLED.
//
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
//
// USING palettes is MUCH simpler in practice than in theory, so first just
// run this sketch, and watch the pretty lights as you then read through
// the code. Although this sketch has eight (or more) different color schemes,
// the entire sketch compiles down to about 6.5K on AVR.
//
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
//
// Some notes on the more abstract 'theory and practice' of
// FastLED compact palettes are at the bottom of this file.CRGBPalette16 currentPalette;
TBlendType currentBlending;extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;void setup() {delay( 3000 ); // power-up safety delayFastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );FastLED.setBrightness( BRIGHTNESS );currentPalette = RainbowColors_p;currentBlending = LINEARBLEND;
}void loop(){ChangePalettePeriodically();static uint8_t startIndex = 0;startIndex = startIndex + 1; /* motion speed */FillLEDsFromPaletteColors( startIndex);FastLED.show();FastLED.delay(1000 / UPDATES_PER_SECOND);
}void FillLEDsFromPaletteColors( uint8_t colorIndex)
{uint8_t brightness = 255;for( int i = 0; i < NUM_LEDS; ++i) {leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);colorIndex += 3;}
}// There are several different palettes of colors demonstrated here.
//
// FastLED provides several 'preset' palettes: RainbowColors_p, RainbowStripeColors_p,
// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
//
// Additionally, you can manually define your own color palettes, or you can write
// code that creates color palettes on the fly. All are shown here.void ChangePalettePeriodically()
{uint8_t secondHand = (millis() / 1000) % 60;static uint8_t lastSecond = 99;if( lastSecond != secondHand) {lastSecond = secondHand;if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; }if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }if( secondHand == 20) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }if( secondHand == 40) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }if( secondHand == 55) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }}
}// This function fills the palette with totally random colors.
void SetupTotallyRandomPalette()
{for( int i = 0; i < 16; ++i) {currentPalette[i] = CHSV( random8(), 255, random8());}
}// This function sets up a palette of black and white stripes,
// using code. Since the palette is effectively an array of
// sixteen CRGB colors, the various fill_* functions can be used
// to set them up.
void SetupBlackAndWhiteStripedPalette()
{// 'black out' all 16 palette entries...fill_solid( currentPalette, 16, CRGB::Black);// and set every fourth one to white.currentPalette[0] = CRGB::White;currentPalette[4] = CRGB::White;currentPalette[8] = CRGB::White;currentPalette[12] = CRGB::White;}// This function sets up a palette of purple and green stripes.
void SetupPurpleAndGreenPalette()
{CRGB purple = CHSV( HUE_PURPLE, 255, 255);CRGB green = CHSV( HUE_GREEN, 255, 255);CRGB black = CRGB::Black;currentPalette = CRGBPalette16(green, green, black, black,purple, purple, black, black,green, green, black, black,purple, purple, black, black );
}// This example shows how to set up a static color palette
// which is stored in PROGMEM (flash), which is almost always more
// plentiful than RAM. A static PROGMEM palette like this
// takes up 64 bytes of flash.
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
{CRGB::Red,CRGB::Gray, // 'white' is too bright compared to red and blueCRGB::Blue,CRGB::Black,CRGB::Red,CRGB::Gray,CRGB::Blue,CRGB::Black,CRGB::Red,CRGB::Red,CRGB::Gray,CRGB::Gray,CRGB::Blue,CRGB::Blue,CRGB::Black,CRGB::Black
};// Additional notes on FastLED compact palettes:
//
// Normally, in computer graphics, the palette (or "color lookup table")
// has 256 entries, each containing a specific 24-bit RGB color. You can then
// index into the color palette using a simple 8-bit (one byte) value.
// A 256-entry color palette takes up 768 bytes of RAM, which on Arduino
// is quite possibly "too many" bytes.
//
// FastLED does offer traditional 256-element palettes, for setups that
// can afford the 768-byte cost in RAM.
//
// However, FastLED also offers a compact alternative. FastLED offers
// palettes that store 16 distinct entries, but can be accessed AS IF
// they actually have 256 entries; this is accomplished by interpolating
// between the 16 explicit entries to create fifteen intermediate palette
// entries between each pair.
//
// So for example, if you set the first two explicit entries of a compact
// palette to Green (0,255,0) and Blue (0,0,255), and then retrieved
// the first sixteen entries from the virtual palette (of 256), you'd get
// Green, followed by a smooth gradient from green-to-blue, and then Blue.
实验的视频记录（67秒）
https://v.youku.com/v_show/id_XNTg4NTUzMzkwNA==.html?spm=a2hcb.playlsit.page.1
【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812硬屏相关推荐
- 【花雕体验】18 行空板点亮WS2812B的256位LED硬屏
手头有二块WS2812B硬屏板子 WS2812B主要特点 智能反接保护,电源反接不会损坏IC. IC控制电路与LED点光源公用一个电源. 控制电路与RGB芯片集成在一个5050封装的元器件中,构成一个 ...
- 【花雕体验】09 行空板硬件控制pinpong库的系列测试（之二）
行空板板身集成了光线传感器.麦克风.蜂鸣器.Wifi.蓝牙.加速度传感器.按键,正面配置有一块LCD彩屏,可实时呈现多种Python运行结果,包括文字.图片.视频,游戏画面,以及数据图表等. [花雕体 ...
- 【花雕体验】08 行空板硬件控制pinpong库的系列测试（之一）
行空板板身集成了光线传感器.麦克风.蜂鸣器.Wifi.蓝牙.加速度传感器.按键,正面配置有一块LCD彩屏,可实时呈现多种Python运行结果,包括文字.图片.视频,游戏画面,以及数据图表等. [花雕体 ...
- 【花雕体验】10 行空板硬件控制pinpong库的系列测试（之三）
6.基础GPIO使用 行空板引脚操作与pinpong通用语法相同. [花雕体验]01上手行空板 https://blog.csdn.net/weixin_41659040/article/detail ...
- 【花雕体验】05 搭建行空板开发环境之SSH连接与Jupyter编程
行空板支持多种编程软件,除了内置Jupyter编辑器,同时还支持IDLE,Thonny,VSCode等一切能输出py文件的编程软件,或者使用更极客的SSH命令行工具,以及还有Mind+的支持,也可以使 ...
- 物联网开发笔记（58）- 使用Micropython开发ESP32开发板之控制2.90寸电子墨水屏模块黑白套件
一.目的 这一节我们学习如何使用我们的ESP32开发板来控制2.90寸电子墨水屏模块(黑白套件). 二.环境 ESP32 + 2.90寸 电子墨水屏模块 + Thonny IDE + 几根杜邦线 接线 ...
- 【花雕体验】14 行空板pinpong库测试外接传感器模块
1.pinpong库是一套控制开源硬件主控板的Python库,基于Firmata协议并兼容MicroPython语法,5分钟即可让你上手使用Python控制开源硬件.借助于pinpong库,直接用Py ...
- 【花雕体验】02 行空板简单使用
早上起来,在看旺仔爸爸的视频时,偶然知道了行空板的主控芯片是福州一家企业生产的,作为福州人有点自豪了,看来还是有缘分的. [花雕体验]01上手行空板 https://blog.csdn.net/wei ...
- Micropython ESP32驱动CH455控制4位数码管
Micropython ESP32驱动CH455控制4位数码管 1.硬件 CH455驱动4位共阴数码管的原理图如下所示. ESP32-S模块,用GPIO4作为SCL和GPIO16作为SDA. 2.软件 ...
最新文章
- Cell子刊：粘上你-细菌生长素介导的植物根部细菌定殖
- ansys18安装以后打不开_Ubuntu18.04安装Python各个版本之后导致终端无法打开的解决办法...
- 关卡2-1 简单的模拟 1540 机器翻译
- idea好用的快捷键
- PHP电子合同对接流程,E签宝电子合同对接实战经验
- UI自动化测试POM设计之-maven工程
- com.sun.jersey.api.client.ClientHandlerException: java.net.ConnectException: Connection refused
- paper 134：结构张量structure tensor（二）
- 字符串题目 --- 递归和动态规划
- 阶段2 JavaWeb+黑马旅游网_15-Maven基础_第5节 使用骨架创建maven的java工程_11使用骨架创建maven的java工程...
- 教之初在线计算机考题,教之初计算机考试系统
- IOT [01] -- 物联网平台架构
- 网络设备商网管软件解决方案
- Exosip源码学习
- 求命题公式的真值表及主范式（栈实现）
- 手机WIFI拦截器简单实现
- 谈谈在创业公司的几点感触
- 基于大数据的音乐数据中心平台（附：源码 课件 项目部署文档）
- Windows10 安装软件时提示“ the error code is 2503/2502”错误解决办法
- win10去除桌面快捷方式小箭头