Oye, ha pasado mucho tiempo desde que envié algo a Instructables para devolverle a la comunidad, así que pensé en compartir cómo construí nuestra nueva plataforma de programación para los tableros que se usan en www.dougswordclock.com DeskClocks.

Sabes cómo va, has creado un proyecto increíble y se lo contaste a mucha gente y seguro que a muchas personas les gustaría tener uno para ellos. Obtiene los tableros de circuitos, y pasa años aplicando soldadura en pasta y componentes, soldando por reflujo e instalando los componentes sin reflujo, luego comienza a cargar microcódigo en el controlador para que el proyecto haga lo que está diseñado para hacer … Wow - ¡Cuántos pasos!

Cargando el microcódigo ????? Sí, como puede que sepas, una computadora sin software es bastante inútil. Todos nuestros relojes tienen un programa especial cargado para que puedan saber la hora correctamente. Cuando construyo los tableros para los relojes, no hay ningún software cargado en el chip del microcontrolador (el chip es demasiado pequeño para ponerlo en un programador normal): este proceso coloca el software en el chip para que el reloj pueda funcionar.

En los viejos tiempos (hace un par de semanas:-)) usé una computadora portátil, un programador USBTiny y el maravilloso software AVRDUDE para programar los tableros. Me sentaba en mi escritorio en el taller, escribía el comando de programación en la computadora. sostenga el cable de programación contra el reloj y presione ENTER. La computadora entonces programaría la pizarra para mí y estaría listo. El único problema con esto es que tengo que sentarme allí todo el tiempo, así que decidí que uno de mis empleados podría hacerlo en su lugar … Desafortunadamente, descubrió que a veces movía el cable un poco, lo que provocaba que el trabajo de programación Fallaría y tendría que empezar de nuevo. Para agravar el problema, si hubiera un error de soldadura, el puerto USB de mi computadora portátil se apagaría y el USBTiny tendría que desconectarse y volver a conectarse para restablecer el puerto USB … ¡Tenía que haber una mejor manera! ¿Cómo lo hicieron los Big Boys?

Resulta que los Big Boys (tm) tienen robots que son muy buenos para sostener cables y dispositivos electrónicos que pueden hacer pruebas. Debido a que DougsWordClock.com se queda sin mi garrage, no era probable que llegara pronto, así que, ¿qué podría hacer para facilitar nuestra vida? Como diría mi amigo Mikal … "¡Construye una plantilla!". (Nota 1)

¡Así que aquí tenemos la plantilla que Doug hizo! Si bien está diseñado específicamente para programar los tableros DeskClock de DougsWordClock.com, los conceptos aquí se pueden extender a cualquier otro proyecto basado en microprocesador que esté construyendo a granel, ¡así que lea cómo resolví el problema y vea qué puede hacer usted mismo!

Empecemos.

-------------------------------------------------------

Nota 1: a principios de 2000, mi mejor amigo Mikal entró en mi taller cuando estaba construyendo un conjunto de estantes. Estaba colocando juntas, lo cual era una tarea repetitiva y aburrida. Mikal dijo "¡Construya una plantilla!" Dije: "Demasiado difícil, acabaré pronto". Dijo: "Nahh, vamos a hacerlo" … Lo hicimos. En pocas palabras, la simplicidad de construir una plantilla, junto con el hecho de que no pensé que golpeó mi Ego con fuerza … Decidí que era inútil … (Imagínate).. Finalmente, salí de Decidí escribir un artículo para demostrarle al mundo que no era inútil. Así que diseñé un proyecto de dados electrónicos basado en PIC. Incluso fue publicado por la revista Silicon Chip - (http://archive.siliconchip.com.au/cms/A_102324/printArticle.html) Una historia real, y probablemente el comienzo para volver a usar microcontroladores para proyectos y escribir artículos..:-)

Suministros:

Paso 1: El tablero DeskClock

Primero, comencé con el tablero DeskClock. Cuando lo diseñé, proporcioné un conector de 6 pines para permitir la conexión de un cable de programación. Aquí hay una foto de la placa, que muestra los distintos conectores.

Por supuesto, cuando cargamos componentes en la placa no llenamos estos conectores, simplemente están ahí para la programación y las pruebas.

El lado de esta foto de la parte posterior del tablero, en comparación con la parte frontal del tablero con todos los LED, se llena primero. durante la fabricación.

Utilicé esta placa para medir con mucho cuidado la ubicación y el espaciado de las diversas conexiones a las que quería conectarme.

Ahora, ¿cómo me conecté al tablero? Me alegra que hayas preguntado. ¡Usé los pines de Pogo!

Paso 2: Pogo Pins y otro hardware

Los pines de Pogo son lo que los profesionales usan para hacer conexiones temporales a los tableros cuando los están probando. Están disponibles en muchos tamaños y formas, y cuentan con un mecanismo de resorte de precisión para garantizar que el pasador se empuja contra la tabla con una presión uniforme.

Traje mis pines de Pogo de un proveedor en eBay. ¡Eran lo suficientemente baratos que creo que ahora tengo un suministro de por vida! El mismo proveedor también me proporcionó el otro hardware complicado que necesitaba usar para sujetar el tablero.

Aquí hay un par de fotos de los pines, la mordaza del tablero y los soportes de espaciado del tablero de goma.

Paso 3: Medir y hacer el montaje para el tablero

Por lo tanto, tengo los Pogo Pins y otros accesorios de montaje. Medí cuidadosamente el tamaño y el espacio de los orificios y creé un diseño para mi cortador láser. También podría haber perforado agujeros con un taladro, pero el cortador hace un trabajo hermosamente repetible.

Decidí espaciar los orificios para que los pasadores no estuvieran en el centro de los orificios de la almohadilla, esto aseguró que los pasadores estuvieran firmemente en contacto con la placa.

También diseñé un espacio para la abrazadera y algunas pestañas para la parte posterior del tablero.

En el caso de la placa DeskClock, hay una toma de corriente axial de 2,1 mm instalada en la placa para la que tuve que proporcionar un orificio de alivio, y, finalmente, no olvide los montajes de goma para apoyar esa parte posterior de la placa.

Paso 4: Una Raspberry Pi para los cerebros y una pantalla a color de 1.8 "

Necesitaba algo para reemplazar mi computadora portátil, así que decidí usar la Raspberry PI.

Se montó fácilmente en la base del programador y utiliza un simple cable de 26 vías conectado a los pines GPIO para conectarse con la placa DeskClock y la pantalla, y el interruptor de palanca.

La configuración específica de pines que utilicé no es importante, usted usará la suya según sus necesidades.

La pantalla que se usó es una pantalla de 1.8 "de Sainsmart. Hace 6 meses traje un montón de ellos en caso de que encontré un uso para ellos. ¡Este fue solo el uso! Seguí el blog de Marks http://marks-space.com/ 2012/11/23 / raspberrypi-tft / para reconstruir un kernel de Linux para que sea compatible con la pantalla.

Mark tenía razón: compilar el kernel en el Pi fue un proceso LENTO, lo dejé correr durante la noche.

El cableado de la pantalla fue simple, y bastante rápidamente tuve un dispositivo FrameBuffer2 en funcionamiento.

Paso 5: Un bolsillo para sostener la pantalla de 1.8 "

Necesitaba una forma de montar la pantalla LCD en la plantilla para que no se moviera. Me acerqué con unos ides simples: solo construyo un bolsillo en ángulo para ello.

Se asienta cuidadosamente en la parte frontal de la unidad, en un ángulo para que el usuario vea fácilmente la pantalla.

La pantalla se ajusta firmemente, pero en caso de que deba decidir deslizarse hacia afuera, el tornillo de nylon de 3 mm se mantiene en su lugar.

Es gracioso, olvidé durante unos 20 años lo fácil que es trabajar con Acrylic. Lo usé en la tienda en la escuela, luego lo olvidé rápidamente. ahora, mi taller tiene cubos de cosas:-)

Paso 6: Hacer que el Pi sea un programador

La siguiente parte de la compilación fue encontrar un software que me permitiera programar la placa directamente con el Pi. Decidí usar el método que Steve Marple explicó en su blog:

En mi caso, usé diferentes pines GPIO ya que la pantalla LCD de 1.8 "entró en conflicto con ellos.

Hubo un fuerte chillido de alegría cuando descubrí que el Pi estaba programando correctamente.

Algunas personas han usado cambiadores de nivel para proteger el PI, no lo hice y el proyecto simplemente funciona.

Paso 7: Un interruptor de palanca para quitar la energía de la placa DeskClock

Decidí instalar un interruptor para desconectar la alimentación de la placa DeskClock y decirle al PI cuándo era el momento de comenzar.

El interruptor era un DPDT, por lo que una mitad estaba conectada a + 5v y la otra mitad estaba conectada a un pin GPIO no utilizado.

Cuando el interruptor estaba apagado, el pin GPIO estaba conectado a tierra, y cuando estaba encendido, el pin GPIO estaba alto. Utilicé una resistencia de 100 ohmios para garantizar que el pin GPIO estuviera en búfer en caso de que se configurara para ser una salida.

Paso 8: Software en el Pi to Tie It All Togehter

A continuación, escribí mi primer programa de Python.

Soy programador de C - Afortunadamente, hay cubos de tutoriales para ayudar.

Obtuve la mayoría del código de un conjunto de muestras en las que alguien usó su PI como indicador del clima.

Aquí está el código para el script de Python que lee el botón y controla la pantalla

#! / usr / bin / python

importar pygame

sistemas de importación

tiempo de importación

desde el momento de importar tiempo de actividad

importación OS

subproceso de importación

Importar RPi.GPIO como GPIO

GPIO.setmode (GPIO.BCM)

# configura el dispositivo framebuffer al TFT

si no es os.getenv ('SDL_FBDEV'):

os.putenv ('SDL_FBDEV', '/ dev / fb1')

os.putenv ('SDL_VIDEODRIVER', 'fbcon')

def displayTime ():

# usado para mostrar la fecha y hora a la TFT

screen.fill ((0,0,0))

font = pygame.font.Font (Ninguno, 50)

now = time.localtime ()

para establecer en ("% H:% M:% S", 60), ("% d% b", 10):

timeformat, dim = setting

currentTimeLine = strftime (timeformat, ahora)

text = font.render (currentTimeLine, 0, (0,250,150))

Surf = pygame.transform.rotate (texto, -90)

screen.blit (Surf, (dim, 20))

def displayText (texto, tamaño, línea, color, pantalla transparente):

# usado para mostrar texto en la pantalla TFT

si borrar la pantalla:

screen.fill ((0,0,0))

font = pygame.font.Font (Ninguno, tamaño)

text = font.render (texto, 0, color)

textRotated = pygame.transform.rotate (texto, -90)

textpos = textRotated.get_rect ()

textpos.centery = 80

si la línea == 1:

textpos.centerx = 90

screen.blit (textRotated, textpos)

línea elif == 2:

textpos.centerx = 40

screen.blit (textRotated, textpos)

def main ():

pantalla global

pygame.init ()

tamaño = ancho, altura = 128, 160

negro = 0,0,0

ROJO = 255,0,0

VERDE = 0,255,0

AZUL = 0,0,255

BLANCO = 255,255,255

fail_cnt = 0

GPIO.setup (18, GPIO.IN)

pygame.mouse.set_visible (0)

screen = pygame.display.set_mode (tamaño)

displayText ("DougsWordClock", 20, 1, VERDE, Verdadero)

displayText ("150mm Programer", 20, 2, AZUL, Falso)

pygame.display.flip ()

time.sleep (5)

displayText ("Firmware Rev", 20, 1, ROJO, Verdadero)

displayText ("20130520", 40, 2, BLANCO, Falso)

pygame.display.flip ()

time.sleep (5)

mientras que True

displayText ("En espera", 30, 1, VERDE, Verdadero)

displayText ("Insertar tabla", 20, 2, AZUL, Falso)

pygame.display.flip ()

si (GPIO.input (18)):

displayText ("Programación", 30, 1, (200,200,1), Verdadero)

displayText ("Wait 10 Sec", 30, 2, RED, False)

pygame.display.flip ()

Y aquí está el script de shell que realmente hace la programación:

#! / bin / sh

cd / home / pi

sudo avrdude -c gpio -p m169 -Ufuso: w: 0xf5: m -U hfuse: w: 0xDa: m -U lfuse: w: 0xFF: m -Flash: w: DeskClock-Prod.hex

Por supuesto, su plantilla tendrá un software diferente:-)

Paso 9: TODO FUNCIONA !!!

Finalmente, tuve el lote conectado, ¡y funcionó de maravilla!

Aprendí un montón acerca de cómo manejar estas pequeñas pantallas LCD de 1.8 ", hasta el punto en que ahora me toca a mi dispositivo para proyectos de Pi trivial.

De todos modos - Aquí hay un par de fotos de ella en acción.

Disfrutar.

¿De dónde a partir de aquí?

Bueno, esa es una pregunta genial: en este momento, el programador simplemente programa la placa y verifica que el micro se haya flasheado correctamente. Inspeccionamos el funcionamiento de los LED visualmente (de ahí la pantalla brillante): el siguiente paso es agregar una función que pueda comunicarse con el tablero de ejecución para validar la precisión de la combinación de chip / cristal RTC, comparando el paso del tiempo con Internet estándar. Eso no debería ser demasiado difícil …..:-)