Monitor en tiempo real de BitCoin Price con matriz de LED Arduino y 1Sheeld (3 / 4 paso)

Paso 3: Sketch de Arduino

En primer lugar he intentado acceder a un API de BitCoin en sitio de blockchain. Usted encontrará un código de ejemplo que obtiene la respuesta cada 10 segundos y mostrar en la pantalla terminal.

 #include <OneSheeld.h> HttpRequest request ("https://blockchain.info/stats?format=json"); void setup() { OneSheeld.begin(); request.getResponse().setOnJsonResponse(&onJson); request.setOnFinish(&onFinish); Internet.performGet(request); } void loop() { } void onFinish() { request.getResponse()["market_price_usd"].query(); } void onJson (JsonKeyChain & hell,char * res) { Terminal.println(res); OneSheeld.delay(10000); Internet.performGet(request); } 

El siguiente paso es agregar la parte de la matriz de LCD. Todas las matrices definidas en la primera son los marcos para obtener el número con su ubicación en el precio del Bitcoin. Sé que suena para ser tan confuso pero nos discus pero si tienes tu propia matriz de LED en alguien se puede utilizar, usted puede simplemente omitir esta parte.

Una cosa importante, si va a tratar este proyecto de Arduino UNO con este LED matrix y 1Sheeld, debería comentar algunos escudos de la biblioteca de 1Sheeld como se muestra aquí ya que la memoria será completa.

 #include <OneSheeld.h> #include <SoftwareSerial.h> byte zeroone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xF0, 0x3F, 0xE0, 0x1F, 0xCF, 0xCF, 0xDC, 0xEF, 0xCF, 0xCF, 0xE0, 0x1F, 0xF0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x63}; byte zerotwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xF0, 0x3F, 0xE0, 0x1F, 0xCF, 0xCF, 0xDC, 0xEF, 0xCF, 0xCF, 0xE0, 0x1F, 0xF0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x73}; byte zerothree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xF0, 0x3F, 0xE0, 0x1F, 0xCF, 0xCF, 0xDC, 0xEF, 0xCF, 0xCF, 0xE0, 0x1F, 0xF0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x43}; byte zerofive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xF0, 0x3F, 0xE0, 0x1F, 0xCF, 0xCF, 0xDC, 0xEF, 0xCF, 0xCF, 0xE0, 0x1F, 0xF0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x23}; byte zerosix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xF0, 0x3F, 0xE0, 0x1F, 0xCF, 0xCF, 0xDC, 0xEF, 0xCF, 0xCF, 0xE0, 0x1F, 0xF0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x33}; byte oneone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xFF, 0xFF, 0xF7, 0xEF, 0xE7, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x40}; byte onetwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xFF, 0xFF, 0xF7, 0xEF, 0xE7, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x50}; byte onethree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xFF, 0xFF, 0xF7, 0xEF, 0xE7, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x60}; byte onefive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xFF, 0xFF, 0xF7, 0xEF, 0xE7, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x00}; byte onesix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xFF, 0xFF, 0xF7, 0xEF, 0xE7, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x10}; byte twoone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xEF, 0x8F, 0xCF, 0x0F, 0xDE, 0x6F, 0xDC, 0xEF, 0xD9, 0xEF, 0xC3, 0xCF, 0xE7, 0xCF, 0xFF, 0xFF, 0x00, 0x00, 0x60}; byte twotwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xEF, 0x8F, 0xCF, 0x0F, 0xDE, 0x6F, 0xDC, 0xEF, 0xD9, 0xEF, 0xC3, 0xCF, 0xE7, 0xCF, 0xFF, 0xFF, 0x00, 0x00, 0x70}; byte twothree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xEF, 0x8F, 0xCF, 0x0F, 0xDE, 0x6F, 0xDC, 0xEF, 0xD9, 0xEF, 0xC3, 0xCF, 0xE7, 0xCF, 0xFF, 0xFF, 0x00, 0x00, 0x40}; byte twofive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xEF, 0x8F, 0xCF, 0x0F, 0xDE, 0x6F, 0xDC, 0xEF, 0xD9, 0xEF, 0xC3, 0xCF, 0xE7, 0xCF, 0xFF, 0xFF, 0x00, 0x00, 0x20}; byte twosix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xEF, 0x8F, 0xCF, 0x0F, 0xDE, 0x6F, 0xDC, 0xEF, 0xD9, 0xEF, 0xC3, 0xCF, 0xE7, 0xCF, 0xFF, 0xFF, 0x00, 0x00, 0x30}; byte threeone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xEF, 0xDF, 0xCF, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x60}; byte threetwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xEF, 0xDF, 0xCF, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x70}; byte threethree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xEF, 0xDF, 0xCF, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x40}; byte threefive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xEF, 0xDF, 0xCF, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x20}; byte threesix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xEF, 0xDF, 0xCF, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x30}; byte fourone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xFC, 0xFF, 0xF8, 0xFF, 0xF2, 0xFF, 0xE6, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFE, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x41}; byte fourtwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xFC, 0xFF, 0xF8, 0xFF, 0xF2, 0xFF, 0xE6, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFE, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x51}; byte fourthree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xFC, 0xFF, 0xF8, 0xFF, 0xF2, 0xFF, 0xE6, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFE, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x61}; byte fourfive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xFC, 0xFF, 0xF8, 0xFF, 0xF2, 0xFF, 0xE6, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFE, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x01}; byte foursix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xFC, 0xFF, 0xF8, 0xFF, 0xF2, 0xFF, 0xE6, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xFE, 0xEF, 0xFF, 0xFF, 0x00, 0x00, 0x11}; byte fiveone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xC1, 0xDF, 0xC1, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDC, 0x0F, 0xDE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x60}; byte fivetwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xC1, 0xDF, 0xC1, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDC, 0x0F, 0xDE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x70}; byte fivethree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xC1, 0xDF, 0xC1, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDC, 0x0F, 0xDE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x40}; byte fivefive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xC1, 0xDF, 0xC1, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDC, 0x0F, 0xDE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x20}; byte fivesix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xC1, 0xDF, 0xC1, 0xCF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDC, 0x0F, 0xDE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x30}; byte sixone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xF0, 0x1F, 0xE0, 0x0F, 0xCD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xFC, 0x0F, 0xFE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x60}; byte sixtwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xF0, 0x1F, 0xE0, 0x0F, 0xCD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xFC, 0x0F, 0xFE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x70}; byte sixthree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xF0, 0x1F, 0xE0, 0x0F, 0xCD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xFC, 0x0F, 0xFE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x40}; byte sixfive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xF0, 0x1F, 0xE0, 0x0F, 0xCD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xFC, 0x0F, 0xFE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x20}; byte sixsix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xF0, 0x1F, 0xE0, 0x0F, 0xCD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xFC, 0x0F, 0xFE, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x30}; byte sevenone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xCF, 0xFF, 0xCF, 0xFF, 0xDF, 0x0F, 0xDE, 0x0F, 0xDC, 0xFF, 0xC1, 0xFF, 0xC3, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x70}; byte seventwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xCF, 0xFF, 0xCF, 0xFF, 0xDF, 0x0F, 0xDE, 0x0F, 0xDC, 0xFF, 0xC1, 0xFF, 0xC3, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x60}; byte seventhree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xCF, 0xFF, 0xCF, 0xFF, 0xDF, 0x0F, 0xDE, 0x0F, 0xDC, 0xFF, 0xC1, 0xFF, 0xC3, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x50}; byte sevenfive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xCF, 0xFF, 0xCF, 0xFF, 0xDF, 0x0F, 0xDE, 0x0F, 0xDC, 0xFF, 0xC1, 0xFF, 0xC3, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x30}; byte sevensix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xCF, 0xFF, 0xCF, 0xFF, 0xDF, 0x0F, 0xDE, 0x0F, 0xDC, 0xFF, 0xC1, 0xFF, 0xC3, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x20}; byte eightone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xE2, 0x1F, 0xC0, 0x0F, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x62}; byte eighttwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xE2, 0x1F, 0xC0, 0x0F, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x72}; byte eightthree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xE2, 0x1F, 0xC0, 0x0F, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x42}; byte eightfive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xE2, 0x1F, 0xC0, 0x0F, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x22}; byte eightsix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xE2, 0x1F, 0xC0, 0x0F, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xC0, 0x0F, 0xE2, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x32}; byte nineone[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x00, 0xE3, 0xFF, 0xC1, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xCF, 0xC0, 0x1F, 0xE0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x70}; byte ninetwo[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x10, 0xE3, 0xFF, 0xC1, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xCF, 0xC0, 0x1F, 0xE0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x60}; byte ninethree[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x20, 0xE3, 0xFF, 0xC1, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xCF, 0xC0, 0x1F, 0xE0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x50}; byte ninefive[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x40, 0xE3, 0xFF, 0xC1, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xCF, 0xC0, 0x1F, 0xE0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x30}; byte ninesix[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x50, 0xE3, 0xFF, 0xC1, 0xEF, 0xDD, 0xEF, 0xDD, 0xEF, 0xDD, 0xCF, 0xC0, 0x1F, 0xE0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0x20}; byte point[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x30, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCF, 0xFF, 0xCF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x60}; byte space[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x30}; byte u[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x70, 0xC0, 0x1F, 0xC0, 0x0F, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xEF, 0xC0, 0x0F, 0xC0, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0x30}; byte s[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x80, 0xE7, 0x9F, 0xC3, 0x8F, 0xD9, 0xEF, 0xDD, 0xEF, 0xDC, 0xEF, 0xC6, 0x0F, 0xE7, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0xE2}; byte d[] = {0xCC ,0x00, 0x01, 0x89, 0x15, 0x01, 0x90, 0xDF, 0xEF, 0xC0, 0x0F, 0xC0, 0x0F, 0xDF, 0xEF, 0xCF, 0xCF, 0xE0, 0x1F, 0xF0, 0x3F, 0xFF, 0xFF, 0x00, 0x00, 0xF0}; SoftwareSerial mySerial(10, 11); // RX, TX HttpRequest request ("https://blockchain.info/stats?format=json"); void setup() { OneSheeld.begin(); request.getResponse().setOnJsonResponse(&onJson); request.setOnFinish(&onSuccess); mySerial.begin(38400); Internet.performGet(request); }void loop() { }void send_point() { mySerial.write(point, sizeof(point)); }void send_usd() { mySerial.write(space, sizeof(space)); delay(15); mySerial.write(u, sizeof(u)); delay(15); mySerial.write(s, sizeof(u)); delay(15); mySerial.write(d, sizeof(u)); }void onSuccess() { request.getResponse()["market_price_usd"].query(); } void onJson (JsonKeyChain & hell,char * res) { test( res[0] , 1); OneSheeld.delay(15); test( res[1] ,2); OneSheeld.delay(15); test( res[2] ,3); OneSheeld.delay(15); send_point(); OneSheeld.delay(15); test( res[4] ,5); OneSheeld.delay(15); test( res[5] ,6); OneSheeld.delay(15); send_usd(); OneSheeld.delay(100); OneSheeld.delay(10000); Internet.performGet(request); } void test(char num, byte index) { switch (num) { case '0': switch (index) { case 1: mySerial.write(zeroone, sizeof(zeroone)); break; case 2: mySerial.write(zerotwo, sizeof(zerotwo)); break; case 3: mySerial.write(zerothree, sizeof(zerothree)); break; case 5: mySerial.write(zerofive, sizeof(zerofive)); break; case 6: mySerial.write(zerosix, sizeof(zerosix)); break; } break; case '1': switch (index) { case 1: mySerial.write(oneone, sizeof(oneone)); break; case 2: mySerial.write(onetwo, sizeof(onetwo)); break; case 3: mySerial.write(onethree, sizeof(onethree)); break; case 5: mySerial.write(onefive, sizeof(onefive)); break; case 6: mySerial.write(onesix, sizeof(onesix)); break; } break; case '2': switch (index) { case 1: mySerial.write(twoone, sizeof(twoone)); break; case 2: mySerial.write(twotwo, sizeof(twotwo)); break; case 3: mySerial.write(twothree, sizeof(twothree)); break; case 5: mySerial.write(twofive, sizeof(twofive)); break; case 6: mySerial.write(twosix, sizeof(twosix)); break; } break; case '3': switch (index) { case 1: mySerial.write(threeone, sizeof(threeone)); break; case 2: mySerial.write(threetwo, sizeof(threetwo)); break; case 3: mySerial.write(threethree, sizeof(threethree)); break; case 5: mySerial.write(threefive, sizeof(threefive)); break; case 6: mySerial.write(threesix, sizeof(threesix)); break; } break; case '4': switch (index) { case 1: mySerial.write(fourone, sizeof(fourone)); break; case 2: mySerial.write(fourtwo, sizeof(fourtwo)); break; case 3: mySerial.write(fourthree, sizeof(fourthree)); break; case 5: mySerial.write(fourfive, sizeof(fourfive)); break; case 6: mySerial.write(foursix, sizeof(foursix)); break; } break; case '5': switch (index) { case 1: mySerial.write(fiveone, sizeof(fiveone)); break; case 2: mySerial.write(fivetwo, sizeof(fivetwo)); break; case 3: mySerial.write(fivethree, sizeof(fivethree)); break; case 5: mySerial.write(fivefive, sizeof(fivefive)); break; case 6: mySerial.write(fivesix, sizeof(fivesix)); break; } break; case '6': switch (index) { case 1: mySerial.write(sixone, sizeof(sixone)); break; case 2: mySerial.write(sixtwo, sizeof(sixtwo)); break; case 3: mySerial.write(sixthree, sizeof(sixthree)); break; case 5: mySerial.write(sixfive, sizeof(sixfive)); break; case 6: mySerial.write(sixsix, sizeof(sixsix)); break; } break; case '7': switch (index) { case 1: mySerial.write(sevenone, sizeof(sevenone)); break; case 2: mySerial.write(seventwo, sizeof(seventwo)); break; case 3: mySerial.write(seventhree, sizeof(seventhree)); break; case 5: mySerial.write(sevenfive, sizeof(sevenfive)); break; case 6: mySerial.write(sevensix, sizeof(sevensix)); break; } break; case '8': switch (index) { case 1: mySerial.write(eightone, sizeof(eightone)); break; case 2: mySerial.write(eighttwo, sizeof(eighttwo)); break; case 3: mySerial.write(eightthree, sizeof(eightthree)); break; case 5: mySerial.write(eightfive, sizeof(eightfive)); break; case 6: mySerial.write(eightsix, sizeof(eightsix)); break; } break; case '9': switch (index) { case 1: mySerial.write(nineone, sizeof(nineone)); break; case 2: mySerial.write(ninetwo, sizeof(ninetwo)); break; case 3: mySerial.write(ninethree, sizeof(ninethree)); break; case 5: mySerial.write(ninefive, sizeof(ninefive)); break; case 6: mySerial.write(ninesix, sizeof(ninesix)); break; } break; } } 

Artículos Relacionados

Monitor en tiempo real Web basado hogar energía uso

Monitor en tiempo real Web basado hogar energía uso

un monitor de uso de energía del hogar basado en la web en tiempo real detalles de este Instructable. El resultado final es un cuadro vivo de una página web que se actualiza cada 10 segundos con el uso de potencia instantánea para toda mi casa. La co
Plotly + Atlas científico: gráfica en tiempo real disuelto oxígeno con frambuesa Pi

Plotly + Atlas científico: gráfica en tiempo real disuelto oxígeno con frambuesa Pi

Atlas científico hace una increíble suite de sensores de monitorización ambiental grado científico que tiene una sinergia perfecta con la plataforma de visualización de datos Plotly.Este Instructable le mostrará cómo conectar un sensor de oxígeno dis
Controlador de matriz de Led Arduino 8 * 8 con registros de 2 * 74HC595 shift

Controlador de matriz de Led Arduino 8 * 8 con registros de 2 * 74HC595 shift

Compré una matriz de Led 8 x 8 incluye un tablero de conductor con un chip MAX7219CNG. Por desgracia, este chip no estaba funcionando correctamente. Así que decidí construir mi propio controlador con la ayuda de 2 registros de desplazamiento 74HC595.
Controlador de matriz de LED Arduino 8 x 8 RGB con Shift 4 registros y Sensor de temperatura

Controlador de matriz de LED Arduino 8 x 8 RGB con Shift 4 registros y Sensor de temperatura

La primera mitad de este video instructivo muestra que un proyecto terminado de un Arduino con 4 registros de desplazamiento (74HC595) utilizado para controlar y 8 x 8 matriz de LED RGB. También hay un sensor de temperatura DS18B20 utilizado para mos
Alimentación bricolaje mañana con matriz de LED

Alimentación bricolaje mañana con matriz de LED

Te despiertas en la mañana. Estás aturdido. Agarrar el teléfono perezosamente y comenzar a navegar. Comprobar el tiempo, sus acciones, su instagram. Sin darte cuenta, estás corriendo tarde! ¿Tus mañanas parecen esto demasiado? Hemos estado allí! Hemo
Recinto de impresora 3D con pantalla de LED Arduino

Recinto de impresora 3D con pantalla de LED Arduino

Hola, adquirió recientemente una impresora 3d y desde entonces he sido impresión casi sin parar. Sin embargo cuando me trajo la impresora a la escuela se convirtió en un reto para imprimir con seguridad en mi dormitorio pequeño sin abs la respiración
Pong con matriz de Led 8 x 8 en Arduino

Pong con matriz de Led 8 x 8 en Arduino

juego Pong creado con 8 x 8 Led matriz el Arduino Diecimila (microcontrolador Atmel ATMega 168). Para más del informaciones http://blog.bsoares.com.br/arduino/ping-pong-with-8x8-led-matrix-on-arduino
Matriz de LED Arduino con el Wii Nunchuck Control

Matriz de LED Arduino con el Wii Nunchuck Control

vídeo principal:Documentación
Arduino Nano y Visuino: 7 segmentos Display Clock con el MAX7219 y DS1307 en tiempo Real Clock(RTC)

Arduino Nano y Visuino: 7 segmentos Display Clock con el MAX7219 y DS1307 en tiempo Real Clock(RTC)

Reloj de tiempo Real DS1307 son módulos de RTC I2C de bajo costo ampliamente disponibles. Vienen con un reloj y una pequeña batería y cuando esté conectado a Arduino, puede realizar un seguimiento de tiempo real incluso cuando no se alimenta la placa
Arduino Nano: Clock(RTC) de tiempo Real DS1307 con Visuino

Arduino Nano: Clock(RTC) de tiempo Real DS1307 con Visuino

Reloj de tiempo Real DS1307 son módulos de RTC I2C de bajo costo ampliamente disponibles. Vienen con un reloj y una pequeña batería y cuando esté conectado a Arduino, puede realizar un seguimiento de tiempo real incluso cuando no se alimenta la placa
Arduino Nano: Clock(RTC) de tiempo Real DS1302 con Visuino

Arduino Nano: Clock(RTC) de tiempo Real DS1302 con Visuino

Reloj de tiempo Real DS1302 son módulos RTC de bajo costo ampliamente disponibles. Vienen con un reloj y una pequeña batería y cuando esté conectado a Arduino, puede realizar un seguimiento de tiempo real incluso cuando no se alimenta la placa Arduin
Arduino Ping pong con matriz de punto de 8 * 8 y Max7219

Arduino Ping pong con matriz de punto de 8 * 8 y Max7219

Hay un montón de tutorial de Arduino ping pong por internet. Pero la mayoría de ellos son para dos jugadores. Como no queda otra que jugar conmigo así que me encontrar un tutorial que es para un solo jugador. Por suerte he encontrado uno pero es no q
Reloj en tiempo real (RTC) con LinkIt uno

Reloj en tiempo real (RTC) con LinkIt uno

¿Alguna vez atascado con un proyecto que necesita un reloj de tiempo real (un reloj que te indica la fecha y hora y no sólo cuántos segundos (milli) transcurrido desde que se conectó al poder)?Tienes 2 opciones:Uso de GPS y obtener el tiempo allíInte
Registro de temperatura en tiempo real con Arduino, NodeJS y Plotly!

Registro de temperatura en tiempo real con Arduino, NodeJS y Plotly!

La motivación para este proyecto surgió después de leer sobre el deseo de Zuckerberg para crear una casa inteligente para uno de sus proyectos de 2016. Siendo yo había intrigado, quería tratar de implementar una aplicación de registro de temperatura