ELECT 24: ArduiNotes

De wikijoan
Salta a la navegació Salta a la cerca

Abstract

Abstract in English

Arduinotes is an Arduino project. With a standard PS2 keyboard we can write directly to an EEPROM memory. It's a reliable, functional, cheap, light and autonomous way to take notes, though it lacks of a screen.

Besides the hardware, software development was necessari:

  1. firmware: composed by the main source code, and 2 libraries (PS2Arduinotes, recoded from PS2Keyboard, and EEPROM)
  2. arduinotes.c: a script to read from serial port all the content that comes from the EEPROM memory, and creates a text file with all this information.

Resum

Arduinotes és un projecte d'Arduino. Amb un teclat d'ordinador estàndar (PS2) podem escriure directament a una memòria EEPROM. És un sistema per a prendre notes fiable, funcional, barato, lleuger i autònom (amb l'inconvenient que no té una pantalla i no podem fer correccions sobre la marxa).

A més del hardware, ha sigut necessari desenvolupar i/o modificar software:

  1. firmware: composat pel fitxer de codi font principal, i dues llibreries (PS2Arduinotes, on s'ha fet canvis a partir de PS2Keyboard, and EEPROM)
  2. arduinotes.c: un executable per llegir pel port sèrie tot el contingut que ve de la memòria EEPROM. Amb aquest contingut es crea un fitxer de text.

Introducció

Basat en el projecte ELECT_21.

Sistema autònom per prendre notes amb un Arduino i un teclat. La idea és buscar un sistema transportable per prendre notes, i poder utilitzar un teclat PS-2 estàndard buscant la productivitat.

Partim del que ja sé fer: a) la connexiói bàsica d'un teclat PS-2 amb Arduino; 2) grabar en una memòria EEPROM; 3) pantalla de cristall líquid. Amb tot això hauria de ser fàcil fer un projecte per prendre notes. Aquesta seria la part A (mode escriptura)

La part B (mode lectura) és recuperar la informació de l'EEPROM. S'ha d'enviar el contingut de la memòria pel port sèrie, i a l'ordinador ha de córrer una petita aplicació que llegeixi el port sèrie i fiqui la informació en un fitxer. Hauria de ser una aplicació petiteta i s'hauria de fer amb C. També podria haver una versió per Windows feta amb VB.

No hi haurà pantalla de LCD perquè un dels requisits és que sigui el més petit i autònom possible, i la pantalla LCD gasta una mica de corrent.

Funcionament

Entro en un loop que espera Fx+ r,w,e, s. Fx (F1, F2, F3 i F4) és la pàgina que vull seleccionar (divideixo la memòria EEPROM en pàgines). Hi ha quatre modes de funcionament: esborrar (e), escriure (w), salvar (s) i llegir (r).

Les primeres posicions de la EEPROM guarden les posicions on comencen les pàgines i el cursor de la pàgina actual.

Hi ha un led verd i un vermell, per saber quan podem escriure i quan no.

  • mode esborrar: apreto F1+e: el led es posa vermell. Quan acaba l'esborrat entrem directament en mode escriptura i el led es posa verd
  • mode escriptura: apreto F1+w. el led està vermell. Llegeixo la posició actual del cursor, ja sé on he d'escriure, i poso el led en verd. ja puc escriure.
  • mode lectura: connecto el arduino a l'ordinador. Engego l'aplicació escrita en C que llegeix el port sèrie i que sap traduir els números que li arriben a caràcters (amb accents, caràcters especials,...). Apreto F1+r, i el led està vermell fent. Quan acabo de volcar la memòria el led vermell fa pampallugues, indicant que ja acabat el volcat. En l'ordinador m'ha d'aparèixer el fitxer F1.txt.
  • mode salvar. Quan apreto es guarda la posició actual del cursor. De manera que quan entro en mode escriptura llegeix aquest valor i ja sap on ha de començar a escriure. Em sembla recordar que cada 50 caràcters es graba la posició (com si apretéssim S).

verd vol dir que podem escriure. vermell en esborrar o lectura. -> això ha canviat perquè he mirat de reduir al màxim el consum d'energia.

Càlcul de les pàgines. En una pàgina de text normal hi ha uns 3200 caràcters, alguns d'ells necessiten dos bytes per guardar la informació: per ex, caràcters amb accent (à), un byte per l'accent i un byte pel caràcter.

A grosso modo, 1 pàgina = 3200 bytes. Si la memòria EEPROM és de 512Kb=64KB, hi caben 64K/3.2 = 20 pàgines. Faré una paginació de 5 pàgines (F1, F2, F3, F4, F5) de 4 pàgines cadascuna.

Necessito saber quines són les posicions on comença cada pàgina, i quines són les posicions de la capçalera per guardar la informació d'on comencen les pàgines i quina és la posició actual del cursor. Si he acabat d'escriure tota una pàgina, el LED vermell hauria de quedar fent pampallugues... (de moment no està implementat)


A més, crec que es pot implementar el tema del backspace, per corregir si m'equivoco (encara està per fer). per exemple: 

a v i a backspace backspace backspace ` a v i a

hauré corregit sobre la marxa avia per àvia

Construcció

En la meva placa poso un connector PS2 femella de soldar a la placa. La correspondència de les potes amb el connector PS2 femella és: 

    __

4  *  1  3
*       5


6  ||  5
4      3
  2  1

1 +Data
3 GND
4 Vcc
5 CLK

El pin CLK va connectat al PWM3 de l'arduino. Això és important perquè primer ho havia connectat al PWM2 i no funcionava. Connectat al PWM2 havia fet les següents modificacions: 

en el fitxer arduinotes_v2:
#define KBD_CLK_PIN  2 (en comptes de 3)

En el fitxer PS2Arduinotes.h
#define PS2_INT_PIN 2 (en comptes de 3)

Tanmateix, no funciona, o sigui que ho deixo tal qual, i utilitzo el PWM3.

Programació

Càlcul de les posicions de memòria per a 4 pàgines en una EEPROM de 64KB 

65536/4=16384

8 256
9 512
10 1024
11 2048
12 4096
13 8192
14 16384
per tant, necessito 2 bytes

pos1 pos2 pos3 pos4
**   **   **   **

els primers 8 bytes són per guardar les posicions actuals de cada pàgina

En un altre disseny, es podria fer que les pàgines tinguessin mides diferents. Les direccions actuals són vàlides per a una memòria EEPROM de 512Kb, o 64KB, és a dir, 655336 bytes. La memòria es pot augmentar utilitzant EEPROMS de més capacitat o encadenant memòries EEPROM.

les direccions de memòria on comencen les pàgines són: 

0-1 direcció actual pàg 1
2-3 direcció actual pàg 2
4-5 direcció actual pàg 3
6-7 direcció actual pàg 4
8-16383
16384-32767
32768-49151
49152-65535

Les pàgines són de 16KB (16384 bytes), excepte la 1a que és de 16384-8=16376 bytes

El codi per escriure la posició de memòria 10000 en els dos primers bytes és: 

  if (modus==1){ //mode escriptura

    w=word(10000);
    b1=byte(w);
    b2 = w >> 8;
    i2c_eeprom_write_byte(0x50, addrposF1, b1);
    delay(10);
    addr++;
    i2c_eeprom_write_byte(0x50, addrposF1+1, b2);
    delay(10);
    addr++;
    
  Serial.print((int)b1);
  Serial.print("\n");
  Serial.print((int)b2);
  Serial.print("\n");
  Serial.print((int)w);
  Serial.print("escribint");
  }
  
  
    //lectura: per quan vull recuperar la informació que hi ha a la EEPROM
    if (modus==2){ //mode lectura
         byte b1 = i2c_eeprom_read_byte(0x50, addrposF1); //accés a les posicions on comencen les dades (5 i 6 bytes, al començament hi ha 'Temp:'
         byte b2 = i2c_eeprom_read_byte(0x50, addrposF1+1);
         w=word(b2,b1);
         Serial.print((int)b1);
         Serial.print("\n");
         Serial.print((int)b2);
         Serial.print("\n");
         Serial.print(w);
      
   }

Video

Títol: Arduinotes: a system to take notes based on Arduino 

p1. portada
p2. introducció
p3. funcionament
p4. lectura del port sèrie
p5. muntanya
p6. lectura de la muntanya
p7. conclusions
p8. contraportada

transcripció català

[p2] En aquest video construirem un sistema autònom i portàtil per prendre notes, basat en Arduino. Ja sé que avui dia hi ha pda's, notebooks i altres gadgets que poden fer aquesta feina fantàsticament, i a un preu competitiu..., pero és que a mi m'agrada escriure en els teclats estàndar, i a vegades el que es busca és la rapidesa i fiabilitat per damunt de tot.

Els requisits que ha de complir el projecte són: que sigui una solucuió compacta, portàtil, econòmica, autònoma i funcional. És veritat que la falta d'una pantalla per veure el que escrius pot ser un problema. Però recorda que una pantalla consumeix molta energia. Si el que es busca és un sistema per prendre notes de forma eficient que et serveixi per quan estas enmig de la selva, i que et duri setmanes, pren atenció a aquest projecte.

Una solució compacta i portàtil significa que ocupi poc espai, que càpiga a la butxaca, que no faci mandra porta-ho a sobre. Autònoma significa que la font d'alimentació duri dies o setmanes, i que no pesi. Econòmic: haurem d'intentar minimitzar el preu de desenvolupament d'un projecte basat en arduino. I funcional: el sistema per entrar la informació serà un teclat d'ordinador estàndar, per a mi la única solució factible. Hi ha models de teclats que són plegables i més prims i portàtils que aquest, que és molt gros.

[p3] Bé, anem a veure el procés... aquí tenim el arudino, y aquí tenim la placa de l'arduinotes. Els connectem, i ho connectem tot plegat al teclat. Escriurem aquí dins, dins d'aquesta petita EEPROM de 512kb o 64kB, és a dir, hi caben 64000 caràcters equivalents a 20 pagines. He paginat la memòria en 4 pàgines que puc escollir mitjançant les tecles de funció: F1, F2, F3 i F4. D'aquesta manera accedeixo a diferents posicions de memòria i puc treballar amb diferents documents alhora.

El funcionament és molt bàsic. Hi ha quatre opcions: opció esborrar, per esborrar una pàgina; opció escriure: per començar a escriure en una pàgina. Per saber en quina posició de la memòria s'ha d'escriure, en els primers bytes de la memòria EEPROM es guarda la posició actual del cursor. L'opció guardar, per guardar la posició actual del cursor. I l'opció lectura: connectem el arduino al port sèrie de l'ordinador i podem volcar el contingut de la memòria EEPROM a un fitxer de text.

Anem a veure-ho amb un exemple. Selecciono la pàgina 3 apretant F3, i apreto la tecla W que representa el mode escriptura. El led groc m'indica que ja estic en condicions d'escriure a la memòria. Ara ja puc escriure, també són vàlids els caràcters especials, accents,...

Tanco la sessió, apreto F3 i S, de save, per guardar la posició actual de la memòria. Ara vull entrar en mode lectura. Connecto el arduino a l'ordinador a través del port USB.

[p4] Engego una petita aplicació escrita en llenguatge C que té per missió volcar a fitxer tot el que ve del port sèrie. Selecciono la pàgina que vull llegir, F3, i apreto R per entrar en l'opcio Lectura. I ara en el fitxer de text està volcat tota la informació que ve de la memòria EEPROM. En aquest cas és el poema La Vaca Cega de Jacint Verdaguer.

[p5] Mireu-me aqui, estic enmig dels Pirineus... m'ha vingut la inspiració i estic prenent unes notes sobre el meu proper post. Després, a casa, faré correccions i milloraré el text...

[p6] Ara ja he tornat a casa i ja puc volcar sobre fitxer tot allò que he escrit en la placidesa de la muntanya.

[p7]Evidentment, una cosa que es troba a faltar és una pantalla. Es podria haver posat una pantalla LCD, però consumeix bateria, i de totes maneres una pantalla LCD de dues línies tampoc seria molt funcional. La idea que es busca és un sistema per prendre notes, un sistema per escriure a raig, que sigui senzill, barato, autònom, funcional i portàtil.

Només he volgut ensenyar un projecte senzill i pràctic que es pot fer amb Arduino, integrant un teclat PS2 i una memòria EEPROM. L'he anomenat Arduinotes, un sistema basat en Arduino per prendre notes. Pots trobar més informació a www.joanillo.org.


transcripció castellà

[p2] En este video construiremos un sistema autónomo y portátil para tomar notas, basado en Arduino. Ya sé que hoy día hay PDA's, notebooks y otros cacharros que pueden hacer esta tarea fantásticamente, y a un precio competitivo..., pero es que a mi me gusta escribir en los teclados estándar, y a veces lo que se busca es la rapidez y la fiabilidad por encima de todo.

Los requisitos que tiene que cumplir el proyecto son: que sea una solucuión compacta, portátil, económica, autónoma y funcional. Es verdad que la falta de una pantalla para ver lo que escribes puede ser un problema. Pero recuerda que una pantalla consume mucha energía. Si lo que se busca es un sistema para tomar notas de forma eficiente que te sirva para cuando estás enmedio de la selva, y que te dure semanas, toma atención a este proyecto.

Una solución compacta y portátil significa que ocupe poco espacio, que quepa en el bolsilloa, que no dé pereza llevarlo encima. Autònoma significa que la fuente de alimentación dure días o semanas, y que no pese. Económico: tendremos que intentar minimizar el precio de desarrollo de un proyecto basado en Arduino. Y funcional: el sistema para entrar la información será un teclado de ordenador estándar, para mi la única solución factible. Hay modelos de teclados que son plegables y más delgados que éste, que es muy grande.

[p3] Bien, vamos a ver todo el proceso... aquí tenemos el arudino, y aquí tenemos la placa del arduinotes. Los conectamos, y lo conectamos todo al teclado. Escribiremos aquí dentro, dentro de esta pequeña EEPROM de 512kb o 64kB, es decir, caben 64000 caracteres equivalentes a 20 páginas. He paginado la memoria en 4 páginas que puedo escoger mediante las teclas de función: F1, F2, F3 y F4. De esta manera accedo a diferentes posiciones de memoria y puedo trabajar con diferentes documentos a la vez.

El funcionamiento es muy básico. Hay cuatro opciones: opción borrar, para borrar una página; opción escribir: para empezar a escribir en una página. Para saber en qué posición de la memoria se tiene que escribir, en los primeros bytes de la memoria EEPROM se guarda la posición actual del cursor. La opción guardar, para guardar la posición actual del cursor. Y la opción lectura: conectamos el arduino al puerto serie del ordenador y podemos volcar el contenido de la memoria EEPROM a un fichero de texto.

Vamos a verlo con un ejemplo. Selecciono la página 3 apretando F3, y aprieto la tecla W que representa el modo escritura. El led amarillo me indica que ya estoy en condiciones de escribir a la memoria. Ahora ya puedo escribir, también son válidos los caracteres especiales, acentos,...

Cierro la sesión, aprieto F3 y S, de salvar, para guardar la posición actual de la memoria. Ahora quiero entrar en modo lectura. Conecto el arduino al ordenador a través del puerto USB.

[p4] Arranco una pequeña aplicación escrita en lenguaje C que tiene por misión volcar a fichero todo lo que llega por el puerto serie. Selecciono la página que quiero leer, F3, y aprieto R para entrar en la opció Lectura. Ahora ya puedo abrir el fichero, que contiene toda la información que viene de la memoria EEPROM. En este caso es el poema La Vaca Cega del poeta catalán Jacint Verdaguer.

[p5] Aquí estoy, enmedio de los Pirineos... me ha venido la inspiración y estoy tomando unas notas para mi próximo post. Luego, en casa haré correcciones y mejoraré el texto...

[p6] Ahora ya he vuelto a casa y ya puedo volcar sobre fichero todo lo que he escrito en la placidez de la montaña.

[p7]Evidentmente, una cosa que se encuentra a faltar es una pantalla. Se podría haber puesto una pantalla LCD, pero consume batería, y de todas maneras una pantalla LCD de dos líneas tampoco es muy funcional. La idea que se busca es un sistema para tomar notas, un sistema para escribir sobre la marcha, que sea simple, barato, autónomo, funcional y portátil.

Sólo he querido enseñar un proyecto simple y práctico que se puede hacer con Arduino, integrando un teclado PS2 y una memoria EEPROM. Lo he llamado Arduinotes, un sistema basado en Arduino para tomar notas. Puedes encontrar más información en www.joanillo.org.

transcripció anglès

[p2] I want to show you a portable and autonomous system to take notes, based on arduino. I know that nowadays there are a lot of solutions to take notes with ease: pda's, notebooks, mobile phones and other gadgets... but i like typewriting in standard keyboards, and sometimes the most important thing is to write quickly and in a reliable manner.

The requirements to accomplish this project are a compact solution, portable, cheap, autonomous and functional. It's true that the lack of a screen to see what you are typewriting is a handicap, but remember that a screen needs lots of energy. If you are looking for a simple taking notes system, useful if you are in the middle of a rain forest and that lasts for weeks, take a look at this project.

A compact and portable solution means that is pocket size, that you are'nt gonna be lazy to carry it. Autonomous means that the power source lasts for days or weeks, and is light. We are going to look for the chapest design. Based on an arduino, we have several possibilities, not all of them at the same price.

Looking for a cheap solution, we are going to use an EEPROM memory. Must be functional: for me, a functional solution means to use a standar PS2 keyboard, the only reliable solution. This one is a big one, there are more fashion and foldable keyboards.

[p3] So, we are going to see the whole process... Here is the arduino, and here is the arduinotes board. We plug them, and we plug the whole thing to the keyboard. We will write here inside this small EEPROM of 512kb or 64kB. It means that we can store 64000 characters, about 20 pages. I divided the memory in four pages, that I can choose with the function keys: F1, F2, F3 i F4. This way, I can access to the different memory positions, and I can work with four different documents at the same time.

The functionality is very easy to understand. There are four options. Erase option, to delethttps://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewFilteredProducts-SingleVariationTypeFiltere the content of a memory. Write option: to start writing in a page. To know where to write, in the first bytes of the EEPROM memory are saved the cursor position of each page. Option Save, to save the cursor position for the actual page. And finally, the Reading option: we plug the arduino to the USB computer port, that acts like a serial port, and we can download the content of the EEPROM to a text file.

Lets see with an example the basic functionality. I select the page number #3 pressing the F3 function key, and I press W, that is, writing mode. Now yellow led means that I can start writing. I can write with special characters, accents,...

I close this session. I press F3 and S (for Saving), and I save the actual position of the memory. Now, I want to enter in Reading Mode. I connect the arduino to the computer's USB port.

[p4] I started a little application written in C language, and this application listen all the bytes coming form arduino serial port. All this content is written in a text file. I select the page I want to read, F3, and I press R to enter in Reading Mode. Now you can see in the file all the content that comes from the EEPROM memory. In this case is a poem of a Catalan poet, Jacint Verdaguer. The poem is called La Vaca Cega, The Blind Cow.

[p5] Here I am, in the middle of the mountains, in the Pyrenees. Inspiration has come, and I'm taking some notes for my next post. Later, at home, I will correct and improve this text...

[p6] Now I'm back at home, and I can download all the content that I wrote in the serenity of the mountains to a text file.

[p7] Of course, this gadget lacks of a screen. It is possible to use a small LCD screen, but a screen has energy consumption, and a two-rows LCD screen is not very functional at all. I'm looking for a system to take notes in a quick way, a system simple, autonomous, functional, portable, and cheap.

I wanted to show a simple and practical project that could be done with Arduino, integrating a PS2 keyboard with an EEPROM memory. I called it Arduinotes, a system based on Arduino to take notes. You can find more information at www.joanillo.org.

notes tècniques

Faig el acidrip com ho feia amb el way2... 

cd /home/joan/projectes/ELECT_24/video
PS1="$ "

fem acidrip de tots els videos que hem grabat (si ho fem tot de cop ens estalviem molt de temps...)

  • track title: el que sigui
  • crop: desmarcat
  • scale: fico width 852 i marco lock aspect. A height no surt 480 però no faig cas. Compte! perque se'm torna a ficar sense voler 800 i he de tornar a ficar 852.
$ ffmpeg -y -i g.avi -s 852x480 -aspect 16:9 -r 25 -sameq p5.avi -ss 00:00:21.000 -t 00:00:39.000
$ ffmpeg -y -i f.avi -s 852x480 -aspect 16:9 -r 25 -sameq p2.avi -ss 00:00:21.000 -t 00:02:04.000
$ ffmpeg -y -i e.avi -s 852x480 -aspect 16:9 -r 25 -sameq p7.avi -ss 00:00:05.000 -t 00:01:03.000
$ ffmpeg -y -i b.avi -s 852x480 -aspect 16:9 -r 25 -sameq p3a.avi -ss 00:00:00.000 -t 00:01:38.000
$ ffmpeg -y -i a.avi -s 852x480 -aspect 16:9 -r 25 -sameq p3b.avi
$ avimerge -o p3.avi -i p3a.avi p3b.avi

$ ffmpeg -y -i p2.avi image_inici%d.png

obtinc image_inici.png 

$ ffmpeg -y -i p7.avi -s 852x480 -aspect 16:9 -r 25 -sameq p7_final.avi -ss 00:01:01.000
$ ffmpeg -y -i p7_final.avi image_final%d.png

obtinc image_final.png 

$ dvd-slideshow -n p1a.avi -p -w -o /home/joan/projectes/ELECT_24/video -w -f fade_inici.cfg
$ dvd-slideshow -n p8a.avi -p -w -o /home/joan/projectes/ELECT_24/video -w -f fade_final.cfg

i obtinc p1a.avi.vob i obtinc p8a.avi.vob

ara faig acidrip per convertir p1a.avi.vob a p1.avi, amb les següents característiques:

  • track title: p1a
  • crop: desmarcat
  • scale: fico width 852 i marco lock aspect. A height no surt 480 però no faig cas. Compte! perque se'm torna a ficar sense voler 800 i he de tornar a ficar 852.

obtinc p1a.avi

fem acidrip de p8a.avi.vob tal com hem dit, i obtenim p8a.avi, que convertim a p8.avi 

$ ffmpeg -y -i p1a.avi -s 852x480 -aspect 16:9 -r 25 -sameq p1.avi
$ ffmpeg -y -i p8a.avi -s 852x480 -aspect 16:9 -r 25 -sameq p8.avi


Faig recordmydesktop, aquest cop amb audio. Després falta convertir el video a avi, retallar el que no interessa, extreure el mp3, augmentar amb el audacity el guany del mp3, i tornar-lo a ficar al video. 

$ recordmydesktop -channels 2 -freq 48000 -device hw:0,0 -delay 3 -fps 25 --overwrite -o p6a.ogv
$ ffmpeg -y -i p6a.ogv -s 852x480 -aspect 16:9 -r 25 -sameq p6a.avi -ss 00:00:1.000 -t 00:00:23.00

$ recordmydesktop -channels 2 -freq 48000 -device hw:0,0 -delay 3 -fps 25 --overwrite -o p4a.ogv
$ ffmpeg -y -i p4a.ogv -s 852x480 -aspect 16:9 -r 25 -sameq p4a.avi -ss 00:00:1.000 -t 00:01:01.00

Per extreure d'un video la veu en format mp3: 

$ ffmpeg -y -i p4a.avi -vn -ar 48000 -ac 2 -ab 192 -f mp3 p4a.mp3
$ ffmpeg -y -i p6a.avi -vn -ar 48000 -ac 2 -ab 192 -f mp3 p6a.mp3

i ara aquest mp3 l'he d'amplificar amb el Audacity per igualar el so que em ve de la videocàmera. Els trossos de silenci els puc atenuar (amplificació amb un valor negatiu per a reduir el soroll, però potser no interessa eliminar-lo del tot, queda estrany). 


Torno a incorporar el so: Mix a video with a sound file
$ ffmpeg -y -i p4b.mp3 -i p4a.avi -s 852x480 -aspect 16:9 -r 25 -ar 48000 -sameq p4.avi
$ ffmpeg -y -i p6b.mp3 -i p6a.avi -s 852x480 -aspect 16:9 -r 25 -ar 48000 -sameq p6.avi

i ja podem ajuntar-ho tot: 

$ avimerge -o ELECT_24.avi -i p1.avi p2.avi p3.avi p4.avi p5.avi p6.avi p7.avi p8.avi
o millor,
$ mencoder -oac copy -ovc copy p1.avi p2.avi p3.avi p4.avi p5.avi p6.avi p7.avi p8.avi -o ELECT_24.avi

NOTA: he notat que amb avimerge hi havia al final de tot una petita desincronització del audio (quasi no es percebia, però hi era). Documentant-me algú considera que per ajuntar videos és millor mencoder que avimerge. (no veig que es pugui ajuntar directament videos amb ffmpeg, l'aplicatiu que utilitzo per tot...): avimerge is another simple tool for this but i've run into audio sync problems using it, the mencoder method seems

 to not have this issue.''

Ho passem al format del YouTube:
$ ffmpeg -i ELECT_24.avi -s 852x480 -pass 1 -passlogfile log-file -ar 44100 -sameq -y ELECT_24.flv


Ara pengem el video. www.youtube.com (JoanilloMediaArt/jq********)

i obtenim el video YouTube: http://www.youtube.com/watch?v=q7ncPsrqphg

  • Títol: Arduinotes: a system to take notes based on Arduino
  • Descripció del video: Arduinotes is an Arduino project. With a standard PS2 keyboard we can write directly to an EEPROM memory. It's a reliable, functional, cheap, light and autonomous way to take notes, though it lacks of a screen.
  • Etiquetes: Joan Quintana, Joanillo, Arduino
  • Categoria: Ciència i Tecnologia
  • http://www.youtube.com/watch?v=q7ncPsrqphg

Enllaços

creat per Joan Quintana Compte, desembre 2009

Obtingut de «http://wiki.joanillo.org/index.php?title=ELECT_24:_ArduiNotes&oldid=4427»