标签: teensy

It may be apparent by now, a lot of my current hobby projects --such as my Inamorata Prognostication Engine and my BADASS Display --are based on NeoPixel rings and strips from Adafruit.com   In turn, Adafruit's NeoPixels are based on the WS2812 integrated light source from Worldsemi . This is an incredible little device that is only 5x5 mm square (and about 1 mm thick). Each WS2812 includes a tiny constant-current driver chip, along with three incredibly bright red, green, and blue (RGB) LEDs.     One area of potential confusion is that you sometimes hear people saying WS2811 or WS2812 when referring to these elements. In fact, WS2811 refers to the driver chip, while WS2812 refers to the larger package containing the WS2811 driver chip along with the RGB LEDs.   The great thing about these devices is that they can be daisy chained together, and the entire chain can be controlled using a single digital output pin on your microcontroller. Each WS2812 has four terminals: 5 V (power), 0 V (ground), data in, and data out. When you use your MCU to output a stream of data to the chain, each WS2811 accepts the first 24 bits it sees (eight bits for each RGB color channel) and then buffers and retransmits the remainder of the data stream to the next WS2811 in the chain.   Now, one of the things I really like about the NeoPixels from Adafruit is that they come equipped with an Arduino library and some really easy-to-use examples. You can literally be up and running within a couple of minutes. Let's use some simple pseudo-code examples. First, we instantiate a chain of NeoPixels:   NeoPixel myChain = NeoPixel(60, 6);   In this example, the first parameter (60) is the number of pixels we have in our chain. The second parameter (6) is the digital I/O pin we wish to use to drive the chain. If we wish to set the color values associated with one of the pixels in the chain, we might use a function call like the following:   myChain.setPixelColor(i, c);   In this case, the first parameter ('i') is an integer between 0 and 59 that specifies the pixel of interest. The second parameter ('c') is a 24-bit value comprising three eight-bit fields to define the RGB values to be associated with this pixel.   Of course, we could use loops and other control structures to specify the values of multiple pixels. The important thing to note here is that the "setPixelColor()" function doesn't actually modify the physical pixels. When we originally instantiated myChain, we created an array of 60x24-bit elements in the Arduino's memory. When we use the "setPixelColor()" function, all this does is change a value in the memory array. When we are ready to rock and roll, we use the "show()" function as follows:   myChain.show();   One other thing I really like is the fact that Adafruit's NeoPixel library allows you to instantiate multiple chains. Suppose I decided to use eight chains, each containing 60 pixels. A pseudo-code version of this might be as follows:   NeoPixel myChain0 = NeoPixel(60, 6); NeoPixel myChain1 = NeoPixel(60, 7); NeoPixel myChain2 = NeoPixel(60, 8); NeoPixel myChain3 = NeoPixel(60, 9); NeoPixel myChain4 = NeoPixel(60, 10); NeoPixel myChain5 = NeoPixel(60, 11); NeoPixel myChain6 = NeoPixel(60, 12); NeoPixel myChain7 = NeoPixel(60, 13);   Now, I love working with NeoPixels, but there are some downsides. For example, the timing requirements to upload data to a NeoPixel chain are so stringent that Adafruit implemented things using assembly code that runs only on 16MHz Arduino Unos and Megas, both of which are eight-bit machines.   Another small gotcha is that, when you call the "show()" function, it disables the Arduino's interrupts. The CPU is totally dedicated to outputting the data to the chain. Now, suppose we have instantiated multiple chains as shown above. Consider what happens if we do the following:   myChain0.show(); myChain1.show(); myChain2.show(); :   Though this might be advantageous for organizing, visualizing, and controlling a display, it doesn't confer any speed advantages. Each chain is processed one after the other. Apart from anything else, this might result in some unwanted visual artifacts if we are driving long pixel chains.   All of which leads me to some interesting information I discovered while chatting with Paul Stoffregen, one of the founders and owners of PJRC.com . One of PJRC's products is the Teensy 3.1 Arduino-compatible development board, which is an incredible bargain at only $19.80 fully assembled (wow).     The Teensy 3.1 is based on a Kinetis MCU chip from Freescale. The Kinetis boasts a 32-bit ARM Cortex-M4 processor core running at 72 MHz. The core in the Teensy features 256 KB of Flash and 64 KB of SRAM.   Of particular interest to us here is the fact that the Kinetis also has an eight-bit dynamic memory access (DMA) capability. This leads us to PJRC's OctoWS2811 display library , which works with Adafruit's NeoPixels and all other WS2811/2812-based addressable LEDs.   Using the Kinetis DMA capability, the OctoWS2811 can drive eight chains in parallel, which means it can update everything eight times faster. Minimal CPU impact and double buffering allows for complex animations that cannot be achieved using traditional Arduino-compatible platforms and libraries. Consider this video , which features 2,000 LEDs controlled by two Teensy controllers.   Did you notice my saying "minimal CPU impact?" This is actually really exciting. When you use the OctoWS2811 library to upload the data to your LED chains, the CPU hands control of this task over to the DMA engine without disabling any of the interrupts or anything like that. This leaves the CPU free to perform other tasks (like the FFT for my BADASS Display ).   Here are some links to videos of a few projects that have used the combination of Teensy boards and the OctoWS2811 library to drive thousands of LEDs to great effect. We have the Wall of Light , the Penrose Triangle , the Skyline LED Wall Booth , and the CrashSpace Light Show .   Well, what can I say? I am very, very impressed. This certainly looks like a strong contender to drive a future incarnation of my BADASS Display. Also, Paul has been telling me about an amazing audio library he's been working on, but we will leave that for a future column. In the meantime, what do you think of the Teensy 3.1 and the OctoWS2811 library?

As you will doubtlessly notice, a lot of my current hobby projects --such as my Infinity Mirror and my BADASS Display --are based on NeoPixel rings and strips from Adafruit.com   In turn, Adafruit's NeoPixels are based on the WS2812 integrated light source from Worldsemi . This is an incredible little device that is only 5x5 mm square (and about 1 mm thick). Each WS2812 includes a tiny constant-current driver chip, along with three incredibly bright red, green, and blue (RGB) LEDs.     One area of potential confusion is that you sometimes hear people saying WS2811 or WS2812 when referring to these elements. In fact, WS2811 refers to the driver chip, while WS2812 refers to the larger package containing the WS2811 driver chip along with the RGB LEDs.   The great thing about these devices is that they can be daisy chained together, and the entire chain can be controlled using a single digital output pin on your microcontroller. Each WS2812 has four terminals: 5 V (power), 0 V (ground), data in, and data out. When you use your MCU to output a stream of data to the chain, each WS2811 accepts the first 24 bits it sees (eight bits for each RGB color channel) and then buffers and retransmits the remainder of the data stream to the next WS2811 in the chain.   Now, one of the things I really like about the NeoPixels from Adafruit is that they come equipped with an Arduino library and some really easy-to-use examples. You can literally be up and running within a couple of minutes. Let's use some simple pseudo-code examples. First, we instantiate a chain of NeoPixels:   NeoPixel myChain = NeoPixel(60, 6);   In this example, the first parameter (60) is the number of pixels we have in our chain. The second parameter (6) is the digital I/O pin we wish to use to drive the chain. If we wish to set the color values associated with one of the pixels in the chain, we might use a function call like the following:   myChain.setPixelColor(i, c);   In this case, the first parameter ('i') is an integer between 0 and 59 that specifies the pixel of interest. The second parameter ('c') is a 24-bit value comprising three eight-bit fields to define the RGB values to be associated with this pixel.   Of course, we could use loops and other control structures to specify the values of multiple pixels. The important thing to note here is that the "setPixelColor()" function doesn't actually modify the physical pixels. When we originally instantiated myChain, we created an array of 60x24-bit elements in the Arduino's memory. When we use the "setPixelColor()" function, all this does is change a value in the memory array. When we are ready to rock and roll, we use the "show()" function as follows:   myChain.show();   One other thing I really like is the fact that Adafruit's NeoPixel library allows you to instantiate multiple chains. Suppose I decided to use eight chains, each containing 60 pixels. A pseudo-code version of this might be as follows:   NeoPixel myChain0 = NeoPixel(60, 6); NeoPixel myChain1 = NeoPixel(60, 7); NeoPixel myChain2 = NeoPixel(60, 8); NeoPixel myChain3 = NeoPixel(60, 9); NeoPixel myChain4 = NeoPixel(60, 10); NeoPixel myChain5 = NeoPixel(60, 11); NeoPixel myChain6 = NeoPixel(60, 12); NeoPixel myChain7 = NeoPixel(60, 13);   Now, I love working with NeoPixels, but there are some downsides. For example, the timing requirements to upload data to a NeoPixel chain are so stringent that Adafruit implemented things using assembly code that runs only on 16MHz Arduino Unos and Megas, both of which are eight-bit machines.   Another small gotcha is that, when you call the "show()" function, it disables the Arduino's interrupts. The CPU is totally dedicated to outputting the data to the chain. Now, suppose we have instantiated multiple chains as shown above. Consider what happens if we do the following:   myChain0.show(); myChain1.show(); myChain2.show(); :   Though this might be advantageous for organizing, visualizing, and controlling a display, it doesn't confer any speed advantages. Each chain is processed one after the other. Apart from anything else, this might result in some unwanted visual artifacts if we are driving long pixel chains.   All of which leads me to some interesting information I discovered while chatting with Paul Stoffregen, one of the founders and owners of PJRC.com . One of PJRC's products is the Teensy 3.1 Arduino-compatible development board, which is an incredible bargain at only $19.80 fully assembled (wow).     The Teensy 3.1 is based on a Kinetis MCU chip from Freescale. The Kinetis boasts a 32-bit ARM Cortex-M4 processor core running at 72 MHz. The core in the Teensy features 256 KB of Flash and 64 KB of SRAM.   Of particular interest to us here is the fact that the Kinetis also has an eight-bit dynamic memory access (DMA) capability. This leads us to PJRC's OctoWS2811 display library , which works with Adafruit's NeoPixels and all other WS2811/2812-based addressable LEDs.   Using the Kinetis DMA capability, the OctoWS2811 can drive eight chains in parallel, which means it can update everything eight times faster. Minimal CPU impact and double buffering allows for complex animations that cannot be achieved using traditional Arduino-compatible platforms and libraries. Consider this video , which features 2,000 LEDs controlled by two Teensy controllers.     Did you notice my saying "minimal CPU impact?" This is actually really exciting. When you use the OctoWS2811 library to upload the data to your LED chains, the CPU hands control of this task over to the DMA engine without disabling any of the interrupts or anything like that. This leaves the CPU free to perform other tasks (like the FFT for my BADASS Display ).   Below we see videos of a few projects that have used the combination of Teensy boards and the OctoWS2811 library to drive thousands of LEDs to great effect. From top to bottom, these are the Wall of Light , the Penrose Triangle , the Skyline LED Wall Booth , and the CrashSpace Light Show .           Well, what can I say? I am very, very impressed. This certainly looks like a strong contender to drive a future incarnation of my BADASS Display. Also, Paul has been telling me about an amazing audio library he's been working on, but we will leave that for a future column. In the meantime, what do you think of the Teensy 3.1 and the OctoWS2811 library?

介绍一款WIZ820io + SD卡适配器，来自PJRC。 (WIZ820io是什么？) smallTeensy 3.1, Pins, 和 WIZ820io 分别出售。/small 这个适配器可携带 上G的SD卡一个WIZnet WIZ820io以太网模块（带Teensy 3.0/3.1）. 对于喜爱WIZnet WIZ820io这款产品的用户，这无疑带来便利！ 下面就看一下装配步骤： 1. 将排针置于一块面包板或其他固定装置上，使其在正确位置上保持水平。 将适配器 置于引脚上。 2. 修剪WIZ820 板上的第12个引脚。 3. 焊接28个排针到WIZ820_SD_ADAPTOR上。 4. 焊接第12个 WIZ820io 引脚到WIZ820_SD_ADAPTOR上 或者, WIZ820io 引脚可以置于插座中，并将插座跟WIZ820_SD_ADAPTOR焊接上, 可允许WIZ820io 被移除。 5. 把28个引脚焊接到Teensy 3.1.上 或者, 排针可以置于插座中， 将插座和 Teensy 3.1.焊接。 装配完成：   更多信息

开源平台中以太网连接方案里W5100是众所周知的，W5200正在此领域越来越受欢迎。这个测试结果是在Arduino Due(Atmel CortexM3-84Mhz), Maple(ST CortexM3-72Mhz) 和 Teensy 3.0(Freescale Cortex M4-96Mhz) 上执行的并显示出外围设备,DMA、中断、I2C和SPI的性能测试。以太网的性能是基于W5200的，你可以看到性能取决于SPI吞吐量。 Platform SPI speed UDP TCP Arduino Due 28Mhz 15.6Mbps 12.9Mbps Maple 16Mhz 9.2Mbps 8.4Mbps Teensy3.0 24Mhz 14.2Mbps 11.8Mbps 更多信息   感谢关注! 与我们联系： WIZnet邮箱：wiznetbj@wiznet.co.kr WIZnet中文主页：http://www.iwiznet.co.kr WIZnet企业微博：http://e.weibo.com/wiznet2012

 开源平台中以太网连接方案里W5100是众所周知的，W5200正在此领域越来越受欢迎。这个测试结果是在 Arduino Due (Atmel CortexM3-84Mhz),  Maple (ST CortexM3-72Mhz) 和  Teensy 3.0 (Freescale Cortex M4-96Mhz) 上执行的并显示出外围设备,DMA、中断、I2C和SPI的性能测试。以太网的性能是基于W5200的，你可以看到性能取决于SPI吞吐量。 Platform SPI speed UDP TCP Arduino Due 28Mhz 15.6Mbps 12.9Mbps Maple 16Mhz 9.2Mbps 8.4Mbps Teensy3.0 24Mhz 14.2Mbps 11.8Mbps 更多信息   感谢关注! 与我们联系： WIZnet邮箱：wiznetbj@wiznet.co.kr WIZnet中文主页：http://www.iwiznet.co.kr WIZnet企业微博：http://e.weibo.com/wiznet2012