ChipKIT Uno32: Primeras impresiones y puntos de referencia
Después de Maker Faire, tuvimos unos días para caminar con el compilador y las placas chipKIT compatibles con Arduino de 32 bits de Digilent. Tenemos algunas cifras de rendimiento iniciales para informar, junto con impresiones del hardware y software.
Descargo de responsabilidad: Digilent proporcionó a Hack a Day las placas Uno32 y Max32 para su evaluación.
chipKIT no es el primer intento de extender el factor de forma Arduino a un núcleo de microcontrolador de 32 bits ... otros productos como Maple, Netduino o FEZ Domino han existido por más de un año ... pero las placas chipKIT son notables por el esfuerzo. Digilent se propuso crear una transición perfecta. El objetivo es crear una única herramienta unificada para las placas Arduino tradicionales de 8 bits y las de 32 bits de Digilent, donde el mismo IDE, el mismo código y una buena cantidad de los mismos escudos pueden funcionar a pesar de las diferentes subyacente. arquitecturas. De hecho, esperan que el proyecto Arduino acepte su método de integración como una forma oficial de agregar nuevo hardware al IDE de Arduino, no solo para su propio producto, sino también para que lo use cualquier otra persona.
Como se señaló en nuestro informe anterior, nos impresionó que parecieran estar cumpliendo esta promesa. La transición entre Arduinos "clásicos" y placas de 32 bits es bastante suave. Pero encontramos en esta etapa inicial que todavía hay algunas piezas en bruto por resolver. Entonces, por el momento, mantenemos tanto Arduino IDE como Mpide (el derivado multiplataforma de Digilent) instalados en el sistema de desarrollo; el segundo todavía no ha eliminado la necesidad del primero. Pero vemos cómo debería funcionar el concepto y nos gusta.
En su mayor parte, Mpide funciona según lo previsto como un IDE de plataforma dual. Simplemente seleccione el dispositivo apropiado en el menú Herramientas-> Tablero, vuelva a compilar y el código estará listo para el chip correspondiente. Pero algunas cosas nos mordieron en la espalda:
- El compilador AVR en Mpide no se optimiza completamente o las bibliotecas de diapositivas se crearon sin optimización ni nada. Esto descartó nuestros números de referencia al principio, ¡los resultados fueron terribles! Para mantener los números realistas, usamos el IDE estándar de Arduino para los puntos de referencia correspondientes. Para ser justos, nos advirtieron sobre este problema de rendimiento en persona en Maker Faire, pero hasta que se solucione, podrían ser más libres al respecto con alguna documentación o en la web ... de lo contrario, podría parecer que están tratando de tergiversar la comparación. normas. más a su favor.
- El constructor String () se genera cuando se manejan enteros. La siguiente línea se compila bien para chips AVR, pero es correcta con el compilador PIC32:
String foo = String(42);
Teniendo en cuenta que el IDE se finalizó literalmente horas antes de la publicación en línea y en Maker Faire, es comprensible que haya algunos cabos sueltos. Solo esté preparado como uno de los primeros en adoptar que esta no será una transición tan débil como pretenden. Lo mejor del código abierto es que podemos entrar allí, detectar esos problemas, ofrecer sugerencias y hacer correcciones ... la situación definitivamente mejorará con el tiempo.
Algunos puntos de referencia
Queríamos crear una demostración fractal similar a la que mostraron en Maker Faire. No teníamos a mano la elegante pantalla LCD en color SparkFun, por lo que tuvimos que conformarnos con una pantalla LCD en serie, la uLCD-144 de 4D Systems. Esto afecta un poco los números, como veremos.
Solo en MIPS, el chipKIT debería superar al Arduino por un factor de cinco. Luego está la característica nativa de 32 bits: cuando se trata de números más grandes, el procesador AVR en el núcleo del Arduino debe cambiar y fijar bits entre valores consecutivos de 8 bits para lograr resultados de 32 bits. Por lo tanto, el PIC32 debería mostrar una ventaja de rendimiento considerable más allá de MIPS solo. En la práctica, esto no siempre sucede.
El uLCD-144 es una pantalla LCD en color de 128 x 128 píxeles y 16 bits con una interfaz UART en serie que funciona a 115.200 bits por segundo. Los comandos de gráficos no son muy efectivos y es necesario enviar un paquete de cinco bytes por cada píxel dibujado. Esto incluye datos de coordenadas; no hay función de escritura en bloque en modo serial. Además, es fácil hablar con el chipKIT o la serie UART nativa de Arduino.
Aquí está el código para el boceto de Mandelbrot, usando matemáticas de diapositivas:
/* Simple Mandelbrot set renderer for Arduino vs. chipKIT benchmarking
w/floating-point math, via www.la-tecnologia.com. This example uses the
4D Systems uLCD-144(SGC) serial display module, wired as follows:
uLCD Pin: RES GND RX TX VIN
Arduino Pin: 2 GND 1 0 5V */
const int
pixelWidth = 128, // LCD dimensions
pixelHeight = 128,
iterations = 255; // Fractal iteration limit or 'dwell'
const float
centerReal = -0.6, // Image center point in complex plane
centerImag = 0.0,
rangeReal = 3.0, // Image coverage in complex plane
rangeImag = 3.0,
startReal = centerReal - rangeReal * 0.5,
startImag = centerImag + rangeImag * 0.5,
incReal = rangeReal / (float)pixelWidth,
incImag = rangeImag / (float)pixelHeight;
void setup()
{
pinMode(13,OUTPUT); // Arduino status LED
pinMode(2,OUTPUT); // LCD reset pin
digitalWrite(13,LOW); // LED off
Serial.begin(115200);
digitalWrite(2,LOW); // Reset LCD
delay(10);
digitalWrite(2,HIGH);
delay(2000); // Allow time for reset to complete
Serial.write(0x55); // Issue auto-baud command
while(Serial.read() != 0x06); // Wait for ACK
}
void loop()
{
unsigned char cmd[20]; // Serial packet for LCD commands
int x,y,n;
float a,b,a2,b2,posReal,posImag;
long startTime,elapsedTime;
Serial.write(0x45); // Clear screen
delay(100); // Brief pause, else 1st few pixels are lost
cmd[0] = 0x50; // 'Pixel' command is issued repeatedly
digitalWrite(13,HIGH); // LED on while rendering
startTime = millis();
posImag = startImag;
for(y = 0; y < pixelHeight; y++) {
cmd[2] = y; // Y coordinate of pixel
posReal = startReal;
for(x = 0; x < pixelWidth; x++) {
a = posReal;
b = posImag;
for(n = iterations; n > 0 ; n--) {
a2 = a * a;
b2 = b * b;
if((a2 + b2) >= 4.0) break;
b = posImag + a * b * 2.0;
a = posReal + a2 - b2;
}
cmd[1] = x; // X coordinate of pixel
cmd[3] = n * 29; // Pixel color MSB
cmd[4] = n * 67; // Pixel color LSB
Serial.write(cmd,5); // Issue LCD command
posReal += incReal;
}
posImag -= incImag;
}
elapsedTime = millis() - startTime;
digitalWrite(13,LOW); // LED off when done
// Set text to opaque mode
cmd[0] = 0x4f;
cmd[1] = 0x01;
Serial.write(cmd,2);
// Seems the chipKIT libs don't yet handle the String(long)
// constructor, hence this kludge. Working backward, convert
// each digit of elapsed time to a char, with " ms" at end
// and text command at head. Length is variable, so issue
// command from final determined head position.
cmd[19] = 0;
cmd[18] = 's';
cmd[17] = 'm';
cmd[16] = ' ';
n = 15;
do {
cmd[n--] = '0' + elapsedTime % 10;
elapsedTime /= 10;
} while(elapsedTime);
cmd[n--] = 0xff; // Color LSB
cmd[n--] = 0xff; // Color MSB
cmd[n--] = 0; // Use 5x7 font
cmd[n--] = 0; // Row
cmd[n--] = 0; // Column
cmd[n] = 0x73; // ASCII text command
Serial.write(&cmd[n],20-n);
delay(5000); // Stall a few seconds, then repeat
}
Y el tiempo resulta, en milisegundos, para Arduino (arriba) y chipKIT (abajo):
Arduino: 54,329 ms.
chipKIT: 12417 ms.
Para repetir (lo siento, juego de palabras), debido a algunos problemas de rendimiento, usamos el compilador Arduino tradicional, no el incluido en Mpide. Si tiene curiosidad, la salida de este compilador tomó un tiempo 8.5 minutos para realizar la tarea! Huf.
Entonces, alrededor de 4.4x de aceleración. No está mal, pero esperábamos una diferencia más dramática. Parte de esto se debe al problema inherente de la comunicación en serie con la pantalla LCD ... volveremos a eso en un momento. Otro factor limitante es que ambos chips imitan la matemática deslizante. Si podemos usar tipos de datos enteros de 32 bits, el PIC32 realmente debería brillar. Entonces, siguió un generador de Mandelbrot de punto fijo:
/* Simple Mandelbrot set renderer for Arduino vs. chipKIT benchmarking
w/fixed-point math, via www.la-tecnologia.com. This example uses the
4D Systems uLCD-144(SGC) serial display module, wired as follows:
uLCD Pin: RES GND RX TX VIN
Arduino Pin: 2 GND 1 0 5V */
const int
bits = 12, // Fractional resolution
pixelWidth = 128, // LCD dimensions
pixelHeight = 128,
iterations = 255; // Fractal iteration limit or 'dwell'
const float
centerReal = -0.6, // Image center point in complex plane
centerImag = 0.0,
rangeReal = 3.0, // Image coverage in complex plane
rangeImag = 3.0;
const long
startReal = (long)((centerReal - rangeReal * 0.5) * (float)(1 << bits)),
startImag = (long)((centerImag + rangeImag * 0.5) * (float)(1 << bits)),
incReal = (long)((rangeReal / (float)pixelWidth) * (float)(1 << bits)),
incImag = (long)((rangeImag / (float)pixelHeight) * (float)(1 << bits));
void setup()
{
pinMode(13,OUTPUT); // Arduino status LED
pinMode(2,OUTPUT); // LCD reset pin
digitalWrite(13,LOW); // LED off
Serial.begin(115200);
digitalWrite(2,LOW); // Reset LCD
delay(10);
digitalWrite(2,HIGH);
delay(2000); // Allow time for reset to complete
Serial.write(0x55); // Issue auto-baud command
while(Serial.read() != 0x06); // Wait for ACK
}
void loop()
{
unsigned char cmd[20]; // Serial packet for LCD commands
int x,y,n;
long a,b,a2,b2,posReal,posImag,startTime,elapsedTime;
Serial.write(0x45); // Clear screen
delay(100); // Brief pause, else 1st few pixels are lost
cmd[0] = 0x50; // 'Pixel' command is issued repeatedly
digitalWrite(13,HIGH); // LED on while rendering
startTime = millis();
posImag = startImag;
for(y = 0; y < pixelHeight; y++) {
cmd[2] = y; // Y coordinate of pixel
posReal = startReal;
for(x = 0; x < pixelWidth; x++) {
a = posReal;
b = posImag;
for(n = iterations; n > 0 ; n--) {
a2 = (a * a) >> bits;
b2 = (b * b) >> bits;
if((a2 + b2) >= (4 << bits)) break;
b = posImag + ((a * b) >> (bits - 1));
a = posReal + a2 - b2;
}
cmd[1] = x; // X coordinate of pixel
cmd[3] = n * 29; // Pixel color MSB
cmd[4] = n * 67; // Pixel color LSB
Serial.write(cmd,5); // Issue LCD command
posReal += incReal;
}
posImag -= incImag;
}
elapsedTime = millis() - startTime;
digitalWrite(13,LOW); // LED off when done
// Set text to opaque mode
cmd[0] = 0x4f;
cmd[1] = 0x01;
Serial.write(cmd,2);
// Seems the chipKIT libs don't yet handle the String(long)
// constructor, hence this kludge. Working backward, convert
// each digit of elapsed time to a char, with " ms" at end
// and text command at head. Length is variable, so issue
// command from final determined head position.
cmd[19] = 0;
cmd[18] = 's';
cmd[17] = 'm';
cmd[16] = ' ';
n = 15;
do {
cmd[n--] = '0' + elapsedTime % 10;
elapsedTime /= 10;
} while(elapsedTime);
cmd[n--] = 0xff; // Color LSB
cmd[n--] = 0xff; // Color MSB
cmd[n--] = 0; // Use 5x7 font
cmd[n--] = 0; // Row
cmd[n--] = 0; // Column
cmd[n] = 0x73; // ASCII text command
Serial.write(&cmd[n],20-n);
delay(5000); // Stall a few seconds, then repeat
}
Y los números:
Arduino: 27,734 ms.
chipKIT: 7,209 ms.
Ahora solo una diferencia de 3.8x, a pesar de que el PIC32 habla su idioma nativo. ¿Lo que da?
Incluso a 115.200 bits / seg, la pantalla LCD en serie nos frena seriamente, porque el código se "bloqueará" cuando salga cada carácter. Algunos cálculos de la contraportada sugieren cuánto tiempo se pierde allí:
128 x 128 píxeles, comando de 5 bytes por píxel = 81,920 bytes.
Incluidos los bits de inicio y parada por byte = 819.200 bits en total
819.200 bits / 115.200 bps = ~ 7,1 segundos.
Entonces, nuestro MCU permanece allí durante siete segundos con el pulgar hacia arriba en su ASCII para actualizar la pantalla. Claro, si comentamos sobre el comando Serial.write () pero dejamos todos los cálculos en su lugar, los resultados son significativamente más dramáticos:
Diapositiva:
Arduino: 49.685 ms.
chipKIT: 5822 ms.
Mejora de 9.3x.
Punto fijo:
Arduino: 22,326 ms.
chipKIT: 168 ms
Mejora de 133x. Cálido demonio. ¡Ahora hablemos!
Por lo tanto, podríamos representar esto a velocidades de cuadro interactivas, debido a la falta de una interfaz bastante rápida para la pantalla LCD. Este tipo de restricción aparecerá cada vez que nos conectemos a un dispositivo real. No todo es 100% código interno y matemáticas ... hay límites finitos para el rendimiento de E / S, y eso más que nada puede limitar la velocidad de toda la aplicación. Por lo que realmente no podemos dar un "Todo será un X por ciento más rápido" consistente para esta placa.
El rendimiento parece bueno para las matemáticas, especialmente si un algoritmo puede funcionar con números enteros o puntos fijos. Otro pensamiento que tuvimos fue el muestreo de analógico a digital, que tiene aplicaciones en robótica ... digamos para un rastreador de líneas o un robot equilibrado. Las muestras más frecuentes deberían proporcionar una operación más suave, o se pueden promediar varias muestras para obtener resultados más precisos. El PIC32 debe llorar tiurilate. Y todavía…
void setup()
{
const int samples = 10000;
int i,n;
long startTime,elapsedTime;
Serial.begin(115200);
startTime = millis();
for(i = 0; i < samples; i++) {
n = analogRead(0);
}
elapsedTime = millis() - startTime;
Serial.print(samples);
Serial.print(" samples in ");
Serial.print(elapsedTime);
Serial.print(" ms = ");
Serial.print(((float)samples * 1000.0) / (float)elapsedTime);
Serial.println(" samples/sec");
}
void loop()
{
}
Arduino: 10000 muestras en 1119 ms = 8936,55 muestras / s
chipKIT: 10000 muestras en 1008 ms = 9920,63 muestras / s
Al funcionar a plena capacidad, el PIC32 es capaz de hasta 1 millón de muestras ADC por segundo, en comparación con las 125.000 del chip Atmel. Seguro que la implementación de la biblioteca introducirá algún costo adicional, pero ¿qué ofrece? Arraigando a través del código fuente de la biblioteca aparece esta gema en wire_analog.c:
//* A delay is needed for the the ADC start up time //* this value started out at 1 millisecond, I dont know how long it needs to be //* 99 uSecs will give us the same approximate sampling rate as the AVR chip // delay(1); delayMicroseconds(99);
Esto genera algunas señales de alerta. Primero, ¿por qué la frecuencia de muestreo debería ser consistente con el AVR? Para funciones relacionadas con el tiempo como delay () y para las tasas de bits de Serial.begin (), por supuesto, nos gustaría números similares, estos están relacionados con incrementos de tiempo. Pero no medimos, o al menos no deberíamos, medir el tiempo con lecturas de ADC. Y en segundo lugar, bueno, ¿por qué no averiguar cuánto tiempo debería ser realmente el tiempo de lanzamiento de ADC? Unos minutos examinando las hojas de datos de Microchip finalmente mostró la respuesta correcta: dos microsegundos. Entonces, cambiando la línea en wire_analog.c a:
delayMicroseconds(2);
Da resultados drásticamente diferentes:
chipKIT: 10000 muestras en 101 ms = 99009,90 muestras / s
Aproximadamente diez veces mejor, y las lecturas todavía parecen válidas. Esto rompe la compatibilidad simultánea con los Arduinos basados en AVR, pero como dijimos, ¿por qué? Por supuesto, es posible que algunas decisiones se hayan tomado apresuradamente ... es un proyecto monumental, llevar todo este código a un chip completamente diferente, y el IDE aún está recién salido del horno ... pero algunos de estos pequeños detalles sí importa sobre nosotros. qué otras sorpresas aún se pueden esconder debajo.
No me malinterpretes ... estamos entusiasmados con las placas chipKIT. El desafío técnico está resuelto y solo necesita un poco de limpieza. Lo que queda para Digilent es ahora un desafío de marketing: para quien es esto realmente? Cuando hablamos de cosas como megamuestras y algoritmos de punto fijo, estos no son exactamente temas cotidianos familiares para la audiencia objetivo de los desarrolladores de Arduino por primera vez. Y el usuario más avanzado puede haber seguido adelante, dejando atrás a Arduino. Entonces, ¿por qué mantener este factor de forma? ¿Por qué mantener este IDE?
Obviamente, parte de la atracción es el ecosistema de escudo Arduino existente. Hay algunas cosas bastante agradables, pantallas táctiles e interconectadas y controladores de motor paso a paso, la mayoría de los cuales encajarán físicamente. Tener una solución existente ahorra tiempo de desarrollo. Luego está la facilidad y familiaridad de las bibliotecas Arduino. Aunque son lentos y torpes en algunos lugares, a veces puede ser muy útil simplemente introducir información de estado en un puerto serie sin tener que hacer toda la configuración UART manualmente.
Las placas chipKIT tienen un precio inteligente para aproximarse a Arduino en términos de costo (incluso disminuyendo ligeramente). Ese es un gran comienzo, con código y igualdad de precios, pero ¿dónde está el extra ¿valor? Lo que Uno32 y Max32 pueden necesitar son algunos programas asesinos. Ideas que el principiante puede implementar, pero que realmente aprovechan el rendimiento y las capacidades adicionales del chip PIC32. La velocidad solo puede ser una parte de eso. ¿Qué podemos hacer con la RAM adicional y el espacio flash que un Arduino normal simplemente no puede manejar, incluso con los escudos más inteligentes? La gente ha hecho cosas increíbles con el pequeño AVR de 8 bits. Esperamos ver si esta es la herramienta que lleva estos trucos al siguiente nivel.
Stefano dice:
"Repetir (lo siento juego de palabras) ..."
"... con el pulgar hacia arriba su ASCII ..."¡Grandes e ingeniosos juegos de palabras! ¡Más de este escritor!
Jeremy dice:
Me preguntaba si este chip realmente abriría nuevos caminos para la pila arduino. Todavía tengo un pie dentro y un pie fuera de arduino. ¡Hay momentos en que el arduino me disparó en el pie por falta de espacio de programación debido a bibliotecas hinchadas y hay momentos en que el arduino simplemente hace las cosas más fáciles! Esperaba una buena reseña del nuevo premio Digilent. ¿Puede hacer un seguimiento en los próximos meses a medida que lanzan actualizaciones?
DanJ dice:
Estoy interesado en esta placa porque parece una excelente manera de aprender sobre PIC32 sin gastar $ 900 en el compilador de Microchip (y funciona, ahora, en Linux / Mac) o tener que pasar tiempo construyendo / instalando / configurando mi propia cadena de herramientas. Me permite aprender gradualmente a usar el PIC32 (por ejemplo, puedo escribir inmediatamente algún código útil sin tener que perder tiempo buscando en mi propia biblioteca / herramienta). Con el tiempo, puedo agregar otro soporte de biblioteca o reubicarme en el entorno de desarrollo oficial (y muy sobrevalorado) de Microchip.
Nota para las personas sobre el marketing de Microchip: las herramientas costosas desalientan a las personas a adoptar sus microcontroladores. Usted, entre todas las empresas, debería comprender esto. Dado el dominio de la arquitectura ARM, creo que querría utilizar el PIC32 de la forma más sencilla posible.
probador de humo dice:
El ecosistema de escudo Arduino existente fue mi razón para ordenar uno de estos. Gran reseña.
Phil Burgess dice:
@DanJ: MPLAB X es gratuito, la única limitación es que los niveles óptimos superiores (-O2, -O3 y -mips16) están desactivados. Sin límites de tamaño de código. Buen trato.
Algo que olvidé mencionar en la revisión es que ambas placas tienen cabezales ICSP y se pueden usar con el PICkit 3 y MPLAB X. Por lo tanto, existe la posibilidad de usar un IDE para "adultos" con los chipKIT, a falta de las bibliotecas Arduino. . y funciones C ++ (C32 de Microchip es solo C).
Straub dice:
Otra característica del PIC32 que no he visto mencionada es su USB On-The-Go (OTG) integrado. Esto permite que el PIC actúe como un host USB sin la adición de placas / chips adicionales. Esto podría usarse para hablar con dispositivos esclavos USB, como memorias USB, impresoras USB, etc. ¿Crees que harán una biblioteca USB para esto? Me interesaría mucho que eso sucediera.
Diego Spinola dice:
¡Buen artículo! Estoy esperando a que lleguen mis propias tablas para poder ejecutar un punto de referencia de Dhrystone en ellas
Charles Gantt dice:
Muy buen artículo Phil. Esto realmente hace que mi cobertura parezca bastante amateur. ¡No puedo esperar para leer más cobertura de chipKIT de usted!
Addidis dice:
Sí, gran reseña. Realmente espero que los chicos de Arduino vean esto como algo bueno. Al final lo que hace un arduino es el código u otra forma de verlo son las personas que lo usan. Hay personas (yo mismo, por ejemplo) que están completamente desterradas de los problemas de existencias de atmel que inicialmente aprendieron en 16f84. Esto me abre la puerta a mí y a mis compañeros. No hay un debate real sobre si esta placa será más poderosa con los ajustes adecuados. Pero el beneficio real para la comunidad de Arduino es la adopción a gran escala de su plataforma e invita voluntariamente a sus usuarios leales (microchips) a la capacidad de contribuir directamente al lado comercial que impulsa a Arduino. Los escudos. Más usuarios significa más señalización vendida, lo que significa más incentivos para que la gente haga señalización. Esto no resta mucho a las personas que compran ArduinoTM, pero AGREGA personas a la comunidad que de otro modo podrían quedar excluidas. Los usuarios más avanzados que usan la plataforma significan que se realizarán actualizaciones más rápidas (piense en el estúpido problema de demora en serie), lo que hará que la plataforma Arduino sea aún mejor y más ampliamente utilizada.
wow, eso fue hace mucho tiempo.Andrés dice:
Solo una molestia: la placa Chipkit en realidad tiene un factor de 7.5 veces el Arduino MIPS, ya que AVR ofrece un máximo de 1MIPS / MHz (menos alrededor de las ramas), y PIC32 es un máximo de 1.5MIPS / MHz (nuevamente, menos si la tubería está rota).
gusto dice:
Mojosa. Tan pronto como apagan el escudo de conexión que trae los pines ether a PHY, obtengo el max32.
Haku dice:
Creo que un aspecto del chipKIT, que es una desventaja pero que no puede evitarse, es que el microcontrolador está montado en la superficie, lo que significa que es un paso más allá del aficionado electrónico promedio hacer sus propios tableros con algunos tableros. y DIP IC como con los microcontroladores más tradicionales que la gente usa.
Además de eso, significa que los usuarios de chipKIT dependerán en gran medida de las placas y escudos integrados, por lo que las empresas que fabrican / venden chipKIT y escudos harán más negocios.
Charles Gantt dice:
@Zing, el escudo etéreo oficial de chipKIT se lanzará en junio.
@Haku, siento que habrá algunos chips PIC32 desnudos con el cargador de arranque ya ardiendo en ellos. No es difícil soldar a mano muchas cosas SMD siempre que tenga una pluma fluida, delgada
punta de soldadura y una soldadura muy fina.Diego Spinola dice:
@Andrew No puede compararlos así porque los parámetros de instrucción de bajo nivel tienen una longitud de 32 bits en PIC32 frente al AVR de 8 bits ... La suma de 32 bits requiere una sola instrucción en la arquitectura PIC32;)
asdf dice:
@Danj, @Phil Burgess: El compilador de Microchip es solo GCC, ¿verdad? AFAIK, puede volver a compilar sus ediciones de origen y obtener el compilador completo, con todas las optimizaciones habilitadas.
ftorama dice:
¿Qué tal una comparación entre Maple y Uno32?
Como acabo de comprar Maple, me gustaría saberlo.
Además, Arduino está lejos de estar optimizado. Eche un vistazo a la definición de DigitalWrite y considere reemplazarla con un simple acceso al registro.
Está hecho para ser simple, pero por eso es muy lento
Ustedes dice:
¿Por qué el de la imagen tiene dos pines ICSP?
Addidis dice:
Aquí está el foro oficial (es decir, soporte) para los chipkits. Creo que quedó fuera de la publicación anterior.
http://www.chipkit.org/forum/El mejor stock electrónico dice:
Creo que quedó fuera de la publicación anterior. Eche un vistazo a la definición de DigitalWrite y considere reemplazarla con un enfoque de registro simple.
Andrés dice:
@Diego eso solo significa que es más rápido que para mayor margen 🙂
WestfW dice:
>> AVR ofrece un máximo de 1MIPS / MHz y PIC32 es un máximo de 1.5MIPS / MHz
Se supone que el núcleo PIC32 ofrece alrededor de 1,5 "Dhrystone MIPS" (DMIPS) por MHz, que es un rendimiento de referencia específico que es más que solo la velocidad de instrucción bruta. El AVR aparentemente registra un punto de referencia similar en aproximadamente 0.3 DMIPS / MHz. (http://www.ecrostech.com/Other/Resources/Dhrystone.htm)ftorama dice:
@WestfW
PIC32 parece obtener 1.5 DMIPS / Mhz en papel, pero ... no he encontrado ningún banco real, por lo que tiene la misma confiabilidad que 1 MIPS / Mhz de Atmel.
Luego, este valor se da mientras la memoria está configurada en "0 Estado de espera". Esto significa que la velocidad máxima del reloj debe ser de 30 MHz. Para llegar a 80 MHz, el estado de espera debe establecerse en 2, lo que reduce los resultados de Dhrystone.
De todos modos, es lógico que un chip de 32 bits sea más rápido que uno de 8 bits y, con suerte, es ^^
tres punto uno dice:
Mi impresión personal del ChipKIT es que si está haciendo un proyecto muy rápido y desea usar código Arduino preescrito, simplemente debe usar el compilador mpide. Los tiempos de demora similares están ahí para garantizar que el código sea / completamente / compatible.
Sin embargo, si está haciendo cosas de alta calidad, tiene la ventaja de poder usar PICKit para escribir código más optimizado en C, por lo que obtiene lo mejor de ambos mundos.
Cosas que realmente quiero que hagan:
a) ¿Por qué no cambiar entre el modo de alto rendimiento y el modo compatible con arduino? tiene dos conjuntos de bibliotecas, una con retrasos y otra sin.
b) ¿Por qué no depurar línea por línea? deberían haber escrito el problema para trabajar con PICKit. Hablé con alguien que recientemente cambió a la placa barata MSP430, y notó algo que me olvidé de Arduinos (generalmente solo hago PIC o microcontrolador directamente con las herramientas de programación nativas): no obtienes el integrado. función de depuración línea por línea! Está integrado en el chip, ¡pero no puedes usarlo porque usa un estúpido gestor de arranque! Tenía la esperanza de que una empresa como digilent pensara en hacer esto, pero supongo que no = / Realmente, para una herramienta fácil de depuración / creación de prototipos, realmente creo que dar la capacidad de depurar línea por línea y ver código es cierto. , realmente genial para que los principiantes accedan.Que no dice:
Buen escrito y bien hecho en la crítica y la investigación controladas.
En cuanto a por qué un arduino, creo que los sistemas que no sean arduino podrían ser mejores, pero a menudo son muy confusos y confusos en lugar de tener una placa base y agregar escudos, que es una configuración simple y clara.
Es un poco como lo hace {companynamewithheldbyauthor}, no es que no todo esté disponible en otros lugares más barato y rápido, pero el paquete es lo que hace que se venda.DigicamMan dice:
Suena como una placa realmente genial y * me encanta * el IDE común: puedo usar un dúo de $ 15 'construido con equipo como Modern Device para proyectos inferiores y el Chipkit para cosas más exigentes. La gran decepción para mí es que los ADC todavía son solo de 10 bits: realmente quiero 12 bits (como en el Maple) para proyectos donde la medición es más crítica ...
Peter Hamilton dice:
¿Alguien sabe si PIC32 puede manejar SSL? HTTPS específico? En teoría, un procesador de 32 bits debería poder manejar esto.
Marcos dice:
Solucionamos el problema de velocidad del compilador. El problema fue el comando gcc vs g ++ para el paso que convirtió el archivo elf. Tenía que ser gcc en lugar de g ++
Mark y Rico
Fabio Varesano dice:
Chicos, este es un proyecto de hardware gratuito. Ni siquiera lo tocaría.
Nosotros, los usuarios de arduino, disfrutamos de hardware / software / comunidad abiertos y gratuitos ... mantengámoslo así.
desperdicio dice:
@fabio
Los usuarios de arduino disfrutamos de una gran comunidad, con una gran historia de código de fragmentación y ejemplos de proyectos. Se vende como una placa prefabricada de una pieza que coincide con los proyectos y el código de esa misma comunidad. A quién le importa si la placa en sí es una fuente cerrada, copie el código de arranque e insértelo en la imagen 32 si desea hacer su propio hardware a nivel de plataforma o simplemente espere hasta que los chips se vendan individualmente con un código de lanzamiento pregrabado.
¿Quieres protoboard? Solo obtenga un adaptador para chips tqfp smd y extienda los pines verticales con un cable ...
Este es el primer paso real en la dirección correcta para abrir realmente la plataforma arduino a mejores micrófonos, y luego el "no es 100%". Aparecen alimentadores de código abierto ...
sistema aburrido dice:
Ciertamente apoyo a Fabio llamando a la aparición no libre. El diseño abierto y el ecosistema de los clones de Arduino es una gran parte de su éxito. Un éxito que chipKIT quiere llevar al banco con compatibilidad con shield.
Open Hardware es donde nosotros, la comunidad de bricolaje, tenemos poder y futuro. Éso es lo que hacemos. ¿Qué ganaríamos olvidándonos de eso? ¿Bloqueo de vendedor? ¡Día a día!WestfW dice:
@fabio: ¿de qué parte te quejas de no ser lo suficientemente abierto? HW: lanzado con licencia CC / SA. SW: Cambios publicados en Arduino IDE más subcapa gcc / mips ...
Fabio Varesano dice:
¡Disculpa, mi error! No me di cuenta de que hay fuentes descargables de los diseños.
Nico Verduin dice:
Acabo de comprar uno hace unos días. Debería llegar en algún momento de esta semana. Todavía estoy impresionado con la relación calidad / precio. Comparado con mi KIM-! Compré una microcomputadora en 1976 🙂
makomk dice:
tres punto uno: Sin embargo, si está haciendo cosas de alta calidad, tiene la ventaja de poder usar PICKit para escribir código más optimizado en C, por lo que obtiene lo mejor de ambos mundos.
Esto no es útil en absoluto, ya que tiene que pagar $ 900 a Microchip si desea niveles de compilación más altos habilitados en su compilador C32. (Lo que ni siquiera han desarrollado, es una versión renombrada de MIPS gcc con protección de copia agregada). Uno de los beneficios de esto es que parece evitar la necesidad de lidiar con la terrible licencia de un compilador de Microchip.
@wetware: no la placa en sí está cerrada, sino cosas como las bibliotecas que usan (especialmente, la biblioteca C es de código cerrado y con una licencia borrosa, y creo que algunos de los códigos y encabezados utilizados para acceder a los periféricos también lo son).
Diego Spinola dice:
@Andrew Mi punto es correcto = D, espero que el mío llegue ahora mismo
Jason dice:
También estoy entusiasmado con las fichas, pero en los cálculos de tiempo anteriores tengo algunas preguntas. Al comentar sobre serialWrite, esperaríamos unos 7 segundos menos para todas las placas si las comunicaciones se ejecutan a la misma velocidad (115Kb), pero en su segunda prueba de diapositivas para Arduino, el tiempo es exactamente el mismo (54,329 ms). ¿Es esto un error o un error de cálculo?
Y otra pregunta que tenía era porque estaba examinando el archivo "cableado_analog.c" y observando el retraso que noté justo después de que se tratara de un bucle de retraso esperando a que se estableciera el indicador de interrupción, ¿es necesario el retraso?
Phil Burgess dice:
@Jason: Buen truco ... Copié el número equivocado de mis notas. El tiempo de deslizamiento de Arduino sin las llamadas Serial.write () debería ser 49.685 ms (artículo ahora actualizado). El factor de mejora fue correcto según lo publicado, solo que el momento fue incorrecto.
No estoy seguro de la bandera de retraso contra interrupción. Sin embargo, necesitaba este archivo hoy, y probaré ambos casos.
Phil Burgess dice:
@Jason, parte II: se necesita algo de retraso para permitir que el ADC se 'disuelva' después de haber sido habilitado y cambiado a una nueva línea de entrada. Después de un poco de experimentación, resulta que el retraso de 2 uS es finalmente demasiado corto ... devuelve lecturas de aspecto correcto, ¡pero están asignadas a los pines incorrectos! Lo mismo ocurre si el retraso está desactivado.
9 microsegundos parece ser el retardo mínimo "seguro" para obtener lecturas precisas de los pines correctos. Esto tiene un efecto mínimo en la frecuencia de muestreo: aún administra muy buenas 92,592 muestras / seg.
Phil Burgess dice:
@Jason, el capítulo final: bueno, encontré el verdadero problema. analogRead () no borra el indicador de interrupción antes de la prueba, sino que se realiza después de la lectura, lo cual no es el comportamiento correcto (solo se establecerá nuevamente cuando el ADC se ejecute libremente). Sin embargo, el tiempo de estabilización de 2 ee.uu. es probablemente una buena idea.
Entonces, las cosas originales en wire_analog se ven así:
delayMicroseconds (99);
dum (! mAD1GetIntFlag ()) {}
analogValue = ReadADC10 (0);
mAD1ClearIntFlag ();Debe cambiarse a:
delayMicroseconds (2);
mAD1ClearIntFlag ();
dum (! mAD1GetIntFlag ()) {}
analogValue = ReadADC10 (0);Reciba ahora las lecturas esperadas de los pines esperados a un ritmo favorable, exactamente 100.000 muestras / seg.
Jason dice:
@Phil, es una gran noticia sobre el ADC. No conozco la superposición de la plataforma Arduino, pero mientras navegaba por algunos de los archivos no vi dónde estaba configurada la "muestra" de AD1CON1. Entonces, ¿es eso algo que se hace en lo anterior periódicamente?
Gracias de nuevo por las actualizaciones.
Phil Burgess dice:
@Jason: No conozco los detalles de grano de PIC32 ADC, pero mi impresión del bit ADC_AUTO_SAMPLING_ON pasado a OpenADC10 () (todavía en cableado_analog.c aquí) es que ejecutan el ADC en alguna operación libre. modo y solo tome una muestra del flujo resultante cuando sea necesario. No está claro exactamente por qué se eligió esta ruta, pero produce resultados válidos.
Supongo que configurar ADC_SAMP_ON y ver ADC_CONVERSION_DONE sería el equivalente a una muestra de ADC de un solo disparo. No es una función demasiado grande para realizar, así que tal vez intente reescribirlo de esa manera.
Jason dice:
@Phil, tienes razón. Revisé la hoja de datos y encontré que se estableció el bit "ASAM", que establece una muestra automática inmediatamente después de la última conversión. También corrige el bit "Provinter". Entonces el retraso tiene más sentido ahora. Supongo que le permite tomar una muestra o dos mientras cambia de canal y la muestra que se toma realmente es después de un período estable.
Mate dice:
¿El Uno32 tiene alguna EEPROM para almacenamiento cuando las baterías están desconectadas? Sé que el Arduino anterior tenía algunos. ¿O puedes tocar en el Flash?
Phil Burgess dice:
@Matt: no EEPROM en sí, pero hay formas de almacenar datos en el espacio flash del programa. Busque en Google la "emulación de eeprom pic32".
Mate dice:
@Phil
Gracias. ¡Acabo de ordenar mi Uno32! Se ve bienGene Apperson dice:
Buena revisión y seguimiento de la placa Uno32. Me gustaría aclarar una cosa: Digilent (yo específicamente) diseñó el hardware, y nosotros (algunos pasantes que trabajan para mí) llevamos algunas de las bibliotecas de Arduino, pero Digilent no hizo nada del trabajo en MPIDE, cargador de arranque o Arduino. archivos del kernel.
Este trabajo fue realizado por Mark Sproul y Rick Anderson (Laboratorios FUBAR). No quiero atribuirme el mérito del trabajo que no hicimos.Voluntad dice:
Es bueno escuchar que EEPROM es algo compatible http://www.chipkit.cc/forum/viewtopic.php?f=7&t=242
Marcus Fazzi dice:
Probé esos códigos con Emperor 795 + UBW32 bootloader y Penguin IDE, usando ITDB02 Display 400 × 240, tomo 48s para la versión flotante y 5.7s para la versión entera, observe que mi pantalla tiene muchos más píxeles y usa una base de datos de 16 bits + 4- bus de control de bits ...
Jovan Ivkovic dice:
Hola Phil y todos,
Han pasado 5 años, así que espero encontrarte bien y mi pregunta es si algo ha cambiado en relación con esa velocidad de conversión de ADC.
Acabo de obtener una versión de ChipKIT Pi con una versión PIC 32MX250xx UART ligeramente más lenta en 40MHz y la actualicé a una versión de 50MHz con carga USB para poder ADC algunos sensores de computadora a la velocidad máxima de ADC porque UART / serial es algo limitado y luego yo tropezón. acerca de su revisión y se decepcionará al descubrir una velocidad de prueba> 10 veces más lenta que la especificada (1.1MSPS).
¿Hay alguna mejora en esta área MPIDE, código, etc.?
