en mi opinion arduino es un poco mas para "divertirse" hacer proyectos de robotica de un par de semanas, y despues desmontarlos y realizar otros... mientras que cuando se trabaja con un PIC es para tener algo que trascienda, un brazo robotico que quede diseñado, estructurado y montado con su placa y su controlador listo para usarse cuando se quiera con tan solo conectarlo a la corriente....
Cada producto tiene su aplicación, yo tengo por aquí un Arduino, que compré para curiosear, como es tan barato, pero todos mis desarrollos los hago con PIC32MX, y también tengo en mente usar los ARM STM32 y los PIC32MZ. Y no acaba ahí la cosa, tambien tengo Raspberry y Beaglebone Black, que voy a utilizar en proyectos en los que necesito gestionar video de alta resolución
Tampoco es que haya mucha diferencia con Arduino, es decir y en mi opinion: RPI y BBB son "tan para hobistas" con lo es Arduino...
Tampoco es que haya mucha diferencia con Arduino, es decir y en mi opinion: RPI y BBB son "tan para hobistas" con lo es Arduino...
Pues hay dos diferencias importantes, el entorno de desarrollo prefabricado de Arduino que no existe ni para Raspberry ni para Beaglebone, y la complejidad del hardware que dificulta mucho que uno pueda hacer su propio PCB para montar un hardware similar al de Raspberry o Beaglebone.
Yo puedo diseñar y ensamblar mis propias placas con TQFP100 con PI32MX, PIC32MZ, ARM STM32, también con los Atmel de Arduino, pero veo demasiado complejo trabajar con BGA y con pasivos tan extremadamente pequeños como los que montan estos SOC, para ese hardware no tengo más remedio que usar productos prefabricados como Raspberry o Beaglebone, sino no tendría acceso a esas soluciones.
asm("nop");
TCCR1A = (outmode_A << 6) | (outmode_B << 4) | (mode & 3) ;
TCCR1B = (capture_mode << 6) | ((mode & 0xC) << 1) | clock_mode ;
De cualquier forma, una plataforma que no tiene depurador no me inspira confianza.
Además el micro que montan da para muy poco, señal de reloj baja, poca flash, poca ram, da para hacer cuatro experimentos chumineros o para controlar otras placas por SPI o I2C.
....
Exacto, es un producto orientado a estudiantes y gente que empieza y no quiere profundizar ni en la electrónica, ni en el software.
....
Fuente: http://arduino.cc/en/pmwiki.php?n=/******************************************************************
This is the core graphics library for all our displays, providing
basic graphics primitives (points, lines, circles, etc.). It needs
to be paired with a hardware-specific library for each display
device we carry (handling the lower-level functions).
Adafruit invests time and resources providing this open
source code, please support Adafruit and open-source hardware
by purchasing products from Adafruit!
Written by Limor Fried/Ladyada for Adafruit Industries.
BSD license, check license.txt for more information.
All text above must be included in any redistribution.
******************************************************************/
#include "Adafruit_GFX.h"
#include "glcdfont.c"
#include <avr/pgmspace.h>
void Adafruit_GFX::constructor(int16_t w, int16_t h) {
_width = WIDTH = w;
_height = HEIGHT = h;
rotation = 0;
cursor_y = cursor_x = 0;
textsize = 1;
textcolor = textbgcolor = 0xFFFF;
wrap = true;
strokeColor = 0;
useStroke = true;
fillColor = 0;
useFill = false;
}
// draw a circle outline
void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
drawPixel(x0, y0+r, color);
drawPixel(x0, y0-r, color);
drawPixel(x0+r, y0, color);
drawPixel(x0-r, y0, color);
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
drawPixel(x0 + x, y0 + y, color);
drawPixel(x0 - x, y0 + y, color);
drawPixel(x0 + x, y0 - y, color);
drawPixel(x0 - x, y0 - y, color);
drawPixel(x0 + y, y0 + x, color);
drawPixel(x0 - y, y0 + x, color);
drawPixel(x0 + y, y0 - x, color);
drawPixel(x0 - y, y0 - x, color);
}
}
void Adafruit_GFX::drawCircleHelper( int16_t x0, int16_t y0,
int16_t r, uint8_t cornername, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x4) {
drawPixel(x0 + x, y0 + y, color);
drawPixel(x0 + y, y0 + x, color);
}
if (cornername & 0x2) {
drawPixel(x0 + x, y0 - y, color);
drawPixel(x0 + y, y0 - x, color);
}
if (cornername & 0x8) {
drawPixel(x0 - y, y0 + x, color);
drawPixel(x0 - x, y0 + y, color);
}
if (cornername & 0x1) {
drawPixel(x0 - y, y0 - x, color);
drawPixel(x0 - x, y0 - y, color);
}
}
}
void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
// used to do circles and roundrects!
void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
uint8_t cornername, int16_t delta, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x1) {
drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}
// bresenham's algorithm - thx wikpedia
void Adafruit_GFX::drawLine(int16_t x0, int16_t y0,
int16_t x1, int16_t y1,
uint16_t color) {
int16_t steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
swap(x0, y0);
swap(x1, y1);
}
if (x0 > x1) {
swap(x0, x1);
swap(y0, y1);
}
int16_t dx, dy;
dx = x1 - x0;
dy = abs(y1 - y0);
int16_t err = dx / 2;
int16_t ystep;
if (y0 < y1) {
ystep = 1;
} else {
ystep = -1;
}
for (; x0<=x1; x0++) {
if (steep) {
drawPixel(y0, x0, color);
} else {
drawPixel(x0, y0, color);
}
err -= dy;
if (err < 0) {
y0 += ystep;
err += dx;
}
}
}
// draw a rectangle
void Adafruit_GFX::drawRect(int16_t x, int16_t y,
int16_t w, int16_t h,
uint16_t color) {
drawFastHLine(x, y, w, color);
drawFastHLine(x, y+h-1, w, color);
drawFastVLine(x, y, h, color);
drawFastVLine(x+w-1, y, h, color);
}
void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color) {
// stupidest version - update in subclasses if desired!
drawLine(x, y, x, y+h-1, color);
}
void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) {
// stupidest version - update in subclasses if desired!
drawLine(x, y, x+w-1, y, color);
}
void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
// stupidest version - update in subclasses if desired!
for (int16_t i=x; i<x+w; i++) {
drawFastVLine(i, y, h, color);
}
}
void Adafruit_GFX::fillScreen(uint16_t color) {
fillRect(0, 0, _width, _height, color);
}
// draw a rounded rectangle!
void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
drawFastHLine(x+r , y , w-2*r, color); // Top
drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
drawFastVLine( x , y+r , h-2*r, color); // Left
drawFastVLine( x+w-1, y+r , h-2*r, color); // Right
// draw four corners
drawCircleHelper(x+r , y+r , r, 1, color);
drawCircleHelper(x+w-r-1, y+r , r, 2, color);
drawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
drawCircleHelper(x+r , y+h-r-1, r, 8, color);
}
// fill a rounded rectangle!
void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
fillRect(x+r, y, w-2*r, h, color);
// draw four corners
fillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
fillCircleHelper(x+r , y+r, r, 2, h-2*r-1, color);
}
// draw a triangle!
void Adafruit_GFX::drawTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color) {
drawLine(x0, y0, x1, y1, color);
drawLine(x1, y1, x2, y2, color);
drawLine(x2, y2, x0, y0, color);
}
// fill a triangle!
void Adafruit_GFX::fillTriangle ( int16_t x0, int16_t y0,
int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color) {
int16_t a, b, y, last;
// Sort coordinates by Y order (y2 >= y1 >= y0)
if (y0 > y1) {
swap(y0, y1); swap(x0, x1);
}
if (y1 > y2) {
swap(y2, y1); swap(x2, x1);
}
if (y0 > y1) {
swap(y0, y1); swap(x0, x1);
}
if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing
a = b = x0;
if(x1 < a) a = x1;
else if(x1 > b) b = x1;
if(x2 < a) a = x2;
else if(x2 > b) b = x2;
drawFastHLine(a, y0, b-a+1, color);
return;
}
int16_t
dx01 = x1 - x0,
dy01 = y1 - y0,
dx02 = x2 - x0,
dy02 = y2 - y0,
dx12 = x2 - x1,
dy12 = y2 - y1,
sa = 0,
sb = 0;
// For upper part of triangle, find scanline crossings for segments
// 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
// is included here (and second loop will be skipped, avoiding a /0
// error there), otherwise scanline y1 is skipped here and handled
// in the second loop...which also avoids a /0 error here if y0=y1
// (flat-topped triangle).
if(y1 == y2) last = y1; // Include y1 scanline
else last = y1-1; // Skip it
for(y=y0; y<=last; y++) {
a = x0 + sa / dy01;
b = x0 + sb / dy02;
sa += dx01;
sb += dx02;
/* longhand:
a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) swap(a,b);
drawFastHLine(a, y, b-a+1, color);
}
// For lower part of triangle, find scanline crossings for segments
// 0-2 and 1-2. This loop is skipped if y1=y2.
sa = dx12 * (y - y1);
sb = dx02 * (y - y0);
for(; y<=y2; y++) {
a = x1 + sa / dy12;
b = x0 + sb / dy02;
sa += dx12;
sb += dx02;
/* longhand:
a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) swap(a,b);
drawFastHLine(a, y, b-a+1, color);
}
}
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h,
uint16_t color) {
int16_t i, j, byteWidth = (w + 7) / 8;
for(j=0; j<h; j++) {
for(i=0; i<w; i++ ) {
if(pgm_read_byte(bitmap + j * byteWidth + i / 8) & (128 >> (i & 7))) {
drawPixel(x+i, y+j, color);
}
}
}
}
#if ARDUINO >= 100
size_t Adafruit_GFX::write(uint8_t c) {
#else
void Adafruit_GFX::write(uint8_t c) {
#endif
if (c == '\n') {
cursor_y += textsize*8;
cursor_x = 0;
} else if (c == '\r') {
// skip em
} else {
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
cursor_x += textsize*6;
if (wrap && (cursor_x > (_width - textsize*6))) {
cursor_y += textsize*8;
cursor_x = 0;
}
}
#if ARDUINO >= 100
return 1;
#endif
}
// draw a character
void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
uint16_t color, uint16_t bg, uint8_t size) {
if((x >= _width) || // Clip right
(y >= _height) || // Clip bottom
((x + 5 * size - 1) < 0) || // Clip left
((y + 8 * size - 1) < 0)) // Clip top
return;
for (int8_t i=0; i<6; i++ ) {
uint8_t line;
if (i == 5)
line = 0x0;
else
line = pgm_read_byte(font+(c*5)+i);
for (int8_t j = 0; j<8; j++) {
if (line & 0x1) {
if (size == 1) // default size
drawPixel(x+i, y+j, color);
else { // big size
fillRect(x+(i*size), y+(j*size), size, size, color);
}
} else if (bg != color) {
if (size == 1) // default size
drawPixel(x+i, y+j, bg);
else { // big size
fillRect(x+i*size, y+j*size, size, size, bg);
}
}
line >>= 1;
}
}
}
void Adafruit_GFX::setCursor(int16_t x, int16_t y) {
cursor_x = x;
cursor_y = y;
}
void Adafruit_GFX::setTextSize(uint8_t s) {
textsize = (s > 0) ? s : 1;
}
void Adafruit_GFX::setTextColor(uint16_t c) {
textcolor = c;
textbgcolor = c;
// for 'transparent' background, we'll set the bg
// to the same as fg instead of using a flag
}
void Adafruit_GFX::setTextColor(uint16_t c, uint16_t b) {
textcolor = c;
textbgcolor = b;
}
void Adafruit_GFX::setTextWrap(boolean w) {
wrap = w;
}
uint8_t Adafruit_GFX::getRotation(void) {
rotation %= 4;
return rotation;
}
void Adafruit_GFX::setRotation(uint8_t x) {
x %= 4; // cant be higher than 3
rotation = x;
switch (x) {
case 0:
case 2:
_width = WIDTH;
_height = HEIGHT;
break;
case 1:
case 3:
_width = HEIGHT;
_height = WIDTH;
break;
}
}
void Adafruit_GFX::invertDisplay(boolean i) {
// do nothing, can be subclassed
}
// return the size of the display which depends on the rotation!
int16_t Adafruit_GFX::width(void) {
return _width;
}
int16_t Adafruit_GFX::height(void) {
return _height;
}
uint16_t Adafruit_GFX::newColor(uint8_t r, uint8_t g, uint8_t b) {
return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}
void Adafruit_GFX::background(uint8_t red, uint8_t green, uint8_t blue) {
background(newColor(red, green, blue));
}
void Adafruit_GFX::background(color c) {
fillScreen(c);
}
void Adafruit_GFX::stroke(uint8_t red, uint8_t green, uint8_t blue) {
stroke(newColor(red, green, blue));
}
void Adafruit_GFX::stroke(color c) {
useStroke = true;
strokeColor = c;
setTextColor(c);
}
void Adafruit_GFX::noStroke() {
useStroke = false;
}
void Adafruit_GFX::noFill() {
useFill = false;
}
void Adafruit_GFX::fill(uint8_t red, uint8_t green, uint8_t blue) {
fill(newColor(red, green, blue));
}
void Adafruit_GFX::fill(color c) {
useFill = true;
fillColor = c;
}
void Adafruit_GFX::text(const char * text, int16_t x, int16_t y) {
if (!useStroke)
return;
setTextWrap(false);
setTextColor(strokeColor);
setCursor(x, y);
print(text);
}
void Adafruit_GFX::textWrap(const char * text, int16_t x, int16_t y) {
if (!useStroke)
return;
setTextWrap(true);
setTextColor(strokeColor);
setCursor(x, y);
print(text);
}
void Adafruit_GFX::textSize(uint8_t size) {
setTextSize(size);
}
void Adafruit_GFX::point(int16_t x, int16_t y) {
if (!useStroke)
return;
drawPixel(x, y, strokeColor);
}
void Adafruit_GFX::line(int16_t x1, int16_t y1, int16_t x2, int16_t y2) {
if (!useStroke)
return;
if (x1 == x2) {
if (y1 < y2)
drawFastVLine(x1, y1, y2 - y1, strokeColor);
else
drawFastVLine(x1, y2, y1 - y2, strokeColor);
}
else if (y1 == y2) {
if (x1 < x2)
drawFastHLine(x1, y1, x2 - x1, strokeColor);
else
drawFastHLine(x2, y1, x1 - x2, strokeColor);
}
else {
drawLine(x1, y1, x2, y2, strokeColor);
}
}
void Adafruit_GFX::rect(int16_t x, int16_t y, int16_t width, int16_t height) {
if (useFill) {
fillRect(x, y, width, height, fillColor);
}
if (useStroke) {
drawRect(x, y, width, height, strokeColor);
}
}
void Adafruit_GFX::rect(int16_t x, int16_t y, int16_t width, int16_t height, int16_t radius) {
if (radius == 0) {
rect(x, y, width, height);
}
if (useFill) {
fillRoundRect(x, y, width, height, radius, fillColor);
}
if (useStroke) {
drawRoundRect(x, y, width, height, radius, strokeColor);
}
}
void Adafruit_GFX::circle(int16_t x, int16_t y, int16_t r) {
if (r == 0)
return;
if (useFill) {
fillCircle(x, y, r, fillColor);
}
if (useStroke) {
drawCircle(x, y, r, strokeColor);
}
}
void Adafruit_GFX::triangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3) {
if (useFill) {
fillTriangle(x1, y1, x2, y2, x3, y3, fillColor);
}
if (useStroke) {
drawTriangle(x1, y1, x2, y2, x3, y3, strokeColor);
}
}
#if defined(__SD_H__) // Arduino SD library
#define BUFFPIXEL 20
void Adafruit_GFX::image(PImage & img, uint16_t x, uint16_t y) {
int w, h, row, col;
uint8_t r, g, b;
uint32_t pos = 0;
uint8_t sdbuffer[3*BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
uint8_t buffidx = sizeof(sdbuffer); // Current position in sdbuffer
// Crop area to be loaded
w = img._bmpWidth;
h = img._bmpHeight;
if((x+w-1) >= width()) w = width() - x;
if((y+h-1) >= height()) h = height() - y;
/*
// Set TFT address window to clipped image bounds
setAddrWindow(x, y, x+w-1, y+h-1);
*/
for (row=0; row<h; row++) { // For each scanline...
// Seek to start of scan line. It might seem labor-
// intensive to be doing this on every line, but this
// method covers a lot of gritty details like cropping
// and scanline padding. Also, the seek only takes
// place if the file position actually needs to change
// (avoids a lot of cluster math in SD library).
if(img._flip) // Bitmap is stored bottom-to-top order (normal BMP)
pos = img._bmpImageoffset + (img._bmpHeight - 1 - row) * img._rowSize;
else // Bitmap is stored top-to-bottom
pos = img._bmpImageoffset + row * img._rowSize;
if(img._bmpFile.position() != pos) { // Need seek?
img._bmpFile.seek(pos);
buffidx = sizeof(sdbuffer); // Force buffer reload
}
for (col=0; col<w; col++) { // For each pixel...
// Time to read more pixel data?
if (buffidx >= sizeof(sdbuffer)) { // Indeed
img._bmpFile.read(sdbuffer, sizeof(sdbuffer));
buffidx = 0; // Set index to beginning
}
// Convert pixel from BMP to TFT format, push to display
b = sdbuffer[buffidx++];
g = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
//pushColor(tft.Color565(r,g,b));
drawPixel(x + col, y + row, newColor(r, g, b));
} // end pixel
} // end scanline
}
#endif
....
Exacto, es un producto orientado a estudiantes y gente que empieza y no quiere profundizar ni en la electrónica, ni en el software.
....
yo también estoy de acuerdo con esta respuesta. observen que en el mismo sitio lo dicen:
"...It's intended for artists, designers, hobbyists and anyone interested in creating interactive objects or environments..."Código: [Seleccionar]Fuente: http://arduino.cc/en/pmwiki.php?n=
pues como todo en esta vida, depende del uso que le vayas a dar a los micros, no defenderé arduino (porque no lo conozco) pero tampoco defenderé a los pic (que si los conozco). Es cuestión de hacer pruebas y ver cuál resulta mas conveniente en el entorno que se trabaje.
En cualquier caso, reconozco en Arduíno una herramienta de prototipado muy buena, mucho mejor en muchos aspectos que las de Microchip:
....
Yo a mis alumnos de secundaria, cuando queremos hacer algun proyecto simple, les doy un arduino y en un par de clases, sin mas, salen trabajando solos y eso es espectacular! pero cuando quiero resolver algun proyecto un poco mas avanzado o con vistas comerciales, sin duda que voy por el lado de un pic o un atmel o un arm
mi granito de arena!
....
Yo a mis alumnos de secundaria, cuando queremos hacer algun proyecto simple, les doy un arduino y en un par de clases, sin mas, salen trabajando solos y eso es espectacular! pero cuando quiero resolver algun proyecto un poco mas avanzado o con vistas comerciales, sin duda que voy por el lado de un pic o un atmel o un arm
mi granito de arena!
+1
El problema real de Arduino es que lo acaban usando muchos estudiantes para realizar su proyecto de final de carrera de "ingeniero electrónico" x_x. Como ya te han comentado Arduino está bien para la gente de 12-17 años que están en el instituto o empiezan con la electrónica, o para la gente que quiere hacer algo, no está especializado en electrónica, y necesita de un microcontrolador para realizar ese "algo" con un lenguaje de programación cuyo nivel de abstracción es muy alto, por lo que se va a poder usar el microcontrolador sin tener que mirar el datasheet.
ahora estan trabajando en el pic32mz (ya lo han sacado, pero no estan a la venta, solo en demostracion).
El problema real de Arduino es que lo acaban usando muchos estudiantes para realizar su proyecto de final de carrera de "ingeniero electrónico" x_x. Como ya te han comentado Arduino está bien para la gente de 12-17 años que están en el instituto o empiezan con la electrónica, o para la gente que quiere hacer algo, no está especializado en electrónica, y necesita de un microcontrolador para realizar ese "algo" con un lenguaje de programación cuyo nivel de abstracción es muy alto, por lo que se va a poder usar el microcontrolador sin tener que mirar el datasheet.
El problema no es del alumno, es del profesor que es tan mediocre que por ir de "modernillo" le permite hacer un PFC con un Arduino: y conozco a más de uno de cerca.
ahora estan trabajando en el pic32mz (ya lo han sacado, pero no estan a la venta, solo en demostracion).
El PIC32MZ, si que está a la venta, al menos algunas referencias como el PIC32MZ2048ECG100, que tienes en Amidata con plazo de entrega 24 horas, también lo tienes disponible como sample gratuito en la web de Microchip.
Yo hace poco, compré en Amidata una tarjeta PIM con un PIC32MZ2048EC, por 20 Euros, para probarlo en mi Explorer16. Aún no he tenido ocasión de probarlo, porque supongo que no estará soportado por MPLAB y C32, solo por MPLABX y el compilador XC32.
Muchas placas se hacen con Atmel. Todos los controladores de motores brushless que conozco (ESC) utilizan micros Atmel. Seguro que conocéis muchos más ejemplos porque los AVR se venden como churros.
A propósito de ventas, desde 2010 las ventas de microcontroladores de 32 bits han superado a los de 8 bits y venden el doble de dinero. ¿Qué opináis de eso?
(http://www.electronicspecifier.com/cms/images/old/www/pr40665a3.jpg)
Saludos.
Consegui este video que vi hace algun tiempo, acerca de la comparación de AVR vs PIC, veanlo es muy interesante.
Cambiar de PIC a Arduino. buena o mala ideaEso no lo hacía el "pingüino" Che?Código: [Seleccionar]Cambiar de PIC a Arduino. buena o mala idea
¿y esta pregunta no se respondería si microchip (y tienen que ser ellos) sacasen una versión hardware libre con un pic32 y un compilador con un lenguaje amigable y que sea posible la conexión de modulos independendientes?
no crei que fuera a ser tan comentado este temaEs que este es un foro dedicado a los PIC y Atmel es uno de sus grandes competidores. Puede llegar a ser una cuestión de religión.
me internare en arduino un dia de estos, no estara de mas conocerlo, por ahora tengo planes de saber mas y mas en cuanto a PICs
Al igual que muchos pienso que para un nivel universitario, en especial si se estudia una ingenieria electronica, arduino no deberia ser la base de los proyectos pues existen cosas en los desarrollos que debemos conocer como la palma de nuestra mano, y con arduino al facilitar muchas cosas, se omite el conocimiento de dichas partes.
El problema no es del alumno, es del profesor que es tan mediocre que por ir de "modernillo" le permite hacer un PFC con un Arduino: y conozco a más de uno de cerca.
De las personas que conozco que usan arduino, un 95 % no tiene ni la menor idea de lo que hacen (o como hacen) las funciones que descargan libremente de internet, simplemente buscan quien ya hizo su trabajo y solo lo aplican.
Actualmente se pueden conseguir herramientas de bajo costo con microcontroladores de mayor capacidad de memoria, más periféricos, mayor velocidad de procesamiento, precargados con un bootloader... obviamente con los contras de compiladores de paga, una mayor curva de aprendizaje o que se tienen que conectar a un proto board que al final es igual en los arduino.
http://www.mikroe.com/stm32/clicker-2/
http://www.mikroe.com/mini/pic32/
1. Introducción . . . . . . . . . . . . . . . . . . . . . . . 1
1.1. Redes de sensores . . . . . . . . . . . . . . . . . . . . 1
1.2. Localización y navegación . . . . . . . . . . . . . . . . 2
1.3. Objetivos del proyecto . . . . . . . . . . . . . . . . . 3
1.4. Organización de la memoria . . . . . . . . . . . . . . . 3
2. Escenario experimental 5
2.1. Contexto del experimento . . . . . . . . . . . . . . . . 5
2.2. Descripción del escenario . . . . . . . . . . . . . . . . 5
2.3. Obtención de observaciones para modelización . . . . . . 6
2.4. Trayectorias experimentales . . . . . . . . . . . . . . . 9
3. Descripción de los datos 11
3.1. Conjuntos de datos . . . . . . . . . . . . . . . . . . . 11
3.2. Descripción de los ficheros de datos . . . . . . . . . . 12
3.2.1. Ficheros de datos de modelización . . . . . . . . . . 12
3.2.2. Ficheros de datos de prueba . . . . . . . . . . . . . 13
3.3. Estudio de los datos de modelización . . . . . . . . . . 13
3.3.1. Potencia recibida frente a distancia . . . . . . . . . 13
3.3.2. Media y varianza muestral de las observaciones . . . . 15
3.3.3. Histogramas de las observaciones . . . . . . . . . . . 18
3.4. Estudio de los datos de prueba . . . . . . . . . . . . . 21
3.5. Conclusiones . . . . . . . . . . . . . . . . . . . . . . 23
4. Modelos numéricos 25
4.1. Definición de las ecuaciones del sistema . . . . . . . . 25
4.2. Modelo de movimiento . . . . . . . . . . . . . . . . . . 26
4.3. Modelo de observación . . . . . . . . . . . . . . . . . 28
4.3.1. Ecuación de observación . . . . . . . . . . . . . . . 28
4.3.2. Modelo logarítmico . . . . . . . . . . . . . . . . . . 29
Definición del modelo . . . . . . . . . . . . . . . . . . 30
Cálculo de los parámetros del modelo . . . . . . . . . . . 31
Curvas de ajuste . . . . . . . . . . . . . . . . . . . . . 32
4.3.3. Modelos Polinómicos . . . . . . . . . . . . . . . . . 34
Definición del modelo . . . . . . . . . . . . . . . . . . 34
Cálculo de los parámetros del modelo . . . . . . . . . . . 35
Curvas de ajuste . . . . . . . . . . . . . . . . . . . . . 36
4.3.4. Interpolación de la varianza de observación . . . . . 38
4.4. Conclusiones . . . . . . . . . . . . . . . . . . . . . . 40
5. Algoritmos de localización 43
5.1. Filtro de Kalman Extendido . . . . . . . . . . . . . . . 44
5.1.1. Introducción al Filtro de Kalman . . . . . . . . . . . 44
5.1.2. Fases del algoritmo . . . . . . . . . . . . . . . . . 45
5.2. Filtro de partículas . . . . . . . . . . . . . . . . . . 46
5.2.1. Introducción al filtro de partículas . . . . . . . . . 46
5.2.2. Fases del algoritmo . . . . . . . . . . . . . . . . . 48
5.3. Ejemplos de aplicación de los algoritmos . . . . . . . . 49
5.3.1. Ejemplo unidimensional lineal . . . . . . . . . . . . 49
5.3.2. Ejemplo unidimensional no lineal . . . . . . . . . . . 51
5.4. Linealización de los modelos de observación . . . . . . 52
5.4.1. Modelo logarítmico . . . . . . . . . . . . . . . . . . 53
5.4.2. Modelo Polinómico . . . . . . . . . . . . . . . . . . 54
5.5. Conclusiones . . . . . . . . . . . . . . . . . . . . . . 55
6. Simulaciones 57
6.1. Simulaciones con datos sintéticos . . . . . . . . . . . 57
6.1.1. Número de partículas . . . . . . . . . . . . . . . . . 57
6.1.2. Error de estimación de los algoritmos . . . . . . . . 59
6.1.3. Ejemplo: una trayectoria aleatoria . . . . . . . . . . 63
Modelo polinómico de tercer orden . . . . . . . . . . . . 63
Modelo logarítmico . . . . . . . . . . . . . . . . . . . . 65
6.1.4. Primera trayectoria de prueba . . . . . . . . . . . . 67
Modelo polinómico de tercer orden . . . . . . . . . . . . 67
Modelo logarítmico . . . . . . . . . . . . . . . . . . . . 69
6.1.5. Segunda trayectoria de prueba . . . . . . . . . . . . 70
Modelo polinómico de tercer orden . . . . . . . . . . . . 71
Modelo logarítmico . . . . . . . . . . . . . . . . . . . . 72
6.2. Pruebas con datos experimentales . . . . . . . . . . . . 73
6.3. Conclusiones . . . . . . . . . . . . . . . . . . . . . . 78
7. Conclusiones y trabajo futuro 81
7.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . 81
7.1.1. Modelos . . . . . . . . . . . . . . . . . . . . . . . 82
7.1.2. Algoritmos . . . . . . . . . . . . . . . . . . . . . . 83
7.1.3. Simulaciones . . . . . . . . . . . . . . . . . . . . . 83
7.1.4. Pruebas experimentales . . . . . . . . . . . . . . . . 85
7.1.5. Resumen . . . . . . . . . . . . . . . . . . . . . . . 86
7.2. Líneas futuras de trabajo . . . . . . . . . . . . . . . 87
A. Presupuesto . . . . . . . . . . . . . . . . . . . . . . . 89
A.1. Recursos materiales . . . . . . . . . . . . . . . . . . 89
A.2. Recursos humanos . . . . . . . . . . . . . . . . . . . . 90
Referencias . . . . . . . . . . . . . . . . . . . . . . . . . 91
Los profesores que han dirigido un PFC así no me parecen ni mediocres ni que vayan de modernillos.
Repito: utilizar Arduino no te convierte en un usuario ignorante.
Leyendo un articulo sobre Arduino, dice que es buena idea hacer una donación de vez en cuando, o comprar placas originales, ya que de momento es software y hardware libre ¿imagináis que puede pasar si hiciesen el IDE de pago? ¿lo creéis posible?
Yo suelo usar PIC, el IDE permite depurar, y puedes hacer debug con un PICKIT o un ICD, hay más variedad de micros, el tema de los fuses me gusta más sobre todo para proteger el código... Y Arduino principalmente para probar algunos periféricos, y luego adaptar librerías a PIC, o si quiero hacer algo rápido, o complejo como un servidor web, o cosas así.
Saludos!!!