Einfaches Arduino-UserInterface mit 16×2-Display

Waehrend die Text-Ausgabe auf einem kleinen 16×2-Zeichen-Display mit LiquidCrystal noch relativ einfach ist, erfordert die Eingabe doch gewoehnlich ein wenig Programmieraufwand, zu dem man oft keine Lust hat und dann doch lieber alles hardcodiert und fuer jeden Wert den Code neu uebertraegt. Um die Lebensspanne meines Arduinos ein wenig zu erhoehen habe ich daher eine kleine Library entwickelt ueber der sich diverse Werte schnell und einfache eingeben lassen. Benoetigt wird lediglich ein Display, welches sich ueber die LiquidCrystal-Library ansprechen laesst, und 5 Buttons (LEFT, RIGHT, UP, DOWN, SELECT) die beliebig selbst implementiert werden duerfen.

Kernfunktionen sind unter anderem ein Menu, Nummerneingabe, Texteingabe und Prozenteingabe. Auch die Buttons lassen sich bequem ansprechen und z.B. Funktionen zuweisen.

Anwendungsbeispiele

Menu:

display16x2-menu

Ein einfaches Menu bei dem ein Eintrag gewaehlt werden kann. Navigiert wird mit den UP und DOWN Tasten. Wenn der gewuenschte Eintrag erreicht wurde, kann er mit SELECT oder RIGHT ausgewaehlt werden. Mit LEFT wird abgebrochen.

 

char *menu[] = {"Entry A", "Entry B", "Entry C", 0}
switch(simpleui.showMenu("Titel", menu)){
   case 0: //Entry A
      ...
   case -1: //Abbruch (en: abort)
...

Prozent:

display16x2-procent

Eine Funktion zur Eingabe von Prozentzahlen, z.B. fuer die Lautstaerke. Mit LEFT und RIGHT macht man 10% Schritte und mit UP und DOWN 1%. Es kann eine Funktion gesetzt werden, die jedes mal aufgerufen wird, wenn der Wert sich aendert (um z.B. einen Probeton abzuspielen).

 

int p = simpleui.getPercent("Titel", 63, onVolumeChange);
...
void onVolumeChange(uint8_t p){
   //Spiele Beispielton
}

Texteingabe:

display16x2-textEine sehr primitive Texteingabe wie sie von Spielekonsolen(„Please enter your name“) bekannt ist.  Mit LEFT/RIGHT wird die Position geaendert und mit UP/DOWN das Symbol veraendert. Mit SELECT wird die Eingabe abgeschlossen. Es koennen klein und Grossbuchstaben sowie Zahlen und Leerzeichen eingegeben werden. Ein Erweiterung um die erlaubten Symbole selber zu setzen ist geplant.

char buffer[20];
simpleui.getString(buffer, 20);

Nummerneingabe:

display16x2-numberEine relativ schnelle Eingabemethode von Nummern. Ueber LEFT/RIGHT wird der Summand veraendert (Zehnerpotenz 1,10,100,…) und mit UP/DOWN der Summand addiert oder subtrahiert. Mit SELECT  wird die Eingabe abgeschlossen.

 

int i = simpleui.getUInt();

 

Konfiguration

Zu erst musst du LiquidCrystal initalisieren in dem du ein entsprechendes Objekt erzeugst. Die Parameter entsprechen den verwendeten Pins zu Ansteuerung des Displays. Du findest sie in der Anleitung oder Homepage deines Displays.
LiquidCrystal lcd(8,9,4,5,6,7);
Als naechstes erstellst du dann analog das SimpleUI16x2-Objekt, dem du das LiquidCrystal-Objekt und eine Funktion zum Abfragen der Buttons gibst.
LiquidCrystal lcd(8,9,4,5,6,7);
SimpleUI16x2 simpleui(&lcd,getButton);

//The Button function you have to define by yourself
uint8_t getButton(){
	int adc_key_in = analogRead(0);
	if (adc_key_in > 790) return BUTTON_NONE;
	if (adc_key_in < 50) {
		return BUTTON_RIGHT;
	}
	if (adc_key_in < 195) {
		return BUTTON_UP;
	}
	if (adc_key_in < 380) {
		return BUTTON_DOWN;
	}
	if (adc_key_in < 555) {
		return BUTTON_LEFT; 
	}
	if (adc_key_in < 790) {
		return BUTTON_SELECT;  
	} 
	return BUTTON_NONE;
}
Nun solltest du in der Lage sein, das Nutzerinterface zu benutzen. Siehe auch das in der Library enthaltene Beispiel.

 

Download

Du findeste die Library in Git unter https://github.com/dserv01/SimpleUI16x2.

Um die Library zu benutzen musst du den Ordner SimpleUI16x2 in den Ordner libraries in deinem Sketchbook-Verzeichnis verschieben. Sollte dieser Ordner nicht existieren, so kannst du ihn einfach anlegen. Unter Umstaenden musst du dir auch noch die LiquidCrystal-Library besorgen, sollte sie in deiner Arduino-Installation nicht standardmaessig enthalten sein.

./sketchbook/libraries/SimpleUI16x2/SimpleUI16x2.h
./sketchbook/libraries/SimpleUI16x2/SimpleUI16x2.cpp 
./sketchbook/libraries/SimpleUI16x2/examples/MenuExample/MenuExample.ino

Die Library befindet sich noch im Aufbau und wird in der naechsten Zeit, ebenso wie dieser Artikel fertiggestellt.

Schnellstart AVR mit mySmartUSB light und ATtiny2313

Achtung! Ich bin (angehender) Informatiker und kein Elektrotechniker/ISTler o.Ae. .
Was ich hier schreibe basiert auf „bei mir hats so geklappt“, aber das kann oft auch reines Glueck gewesen sein. Dieser Artikel ist noch nicht vollstaendig fertig, aber ich bin mir unsicher ob er das jemals sein wird.
Wenn man nur eine einfache Aufgabe umsetzen moechte, braucht man nicht immer einen teuren und grossen Arduino, sondern kann auch einen einfachen und guenstigen AVR-Microcontroller wie z.B. den ATtiny2313 fuer 2-3Euro benutzen. Es gibt jedoch ein paar Nachteile dabei:

  • Keine Arduino-IDE: Es muss in echtem C geschrieben werden und ueber das Terminal mit laengeren Befehlen compiliert und uebertragen werden.
  • Keine Arduino-Library: Es wird noch ein Stueck hardwarenaeher programmiert (Register und Bit-Operatoren)
  • Kein USB und Onboardprogrammer: Es muss ein ISP-Programmer benutzt werden. Wir werden den guenstigen und Linux-kompatiblen mySmartUSB light fuer 16Euro benutzen.
  • Die AVRs besitzen keinerlei Schutz gegen DAUs und so ist es unvermeintlich, dass man mal ausversehn einen AVR zerstoert. Bestellt also immer ein paar zuviel.
  • Eine externe Stromversorgung wird benoetigt. Es laesst sich ein AVR auch relativ einfach ueber USB speisen, aber die Gefahr bei einem Kurzschluss den Computer zu zerstoeren ist doch sehr hoch. Nehmt also ein Labornetzteil oder Batterien.

Auf der anderen Hand sind AVRs sehr guenstig und haben ungefaehr den gleichen Funktionsumfang wie Arduinos. Sie sind nur benutzerunfreundlicher.

 Anschluss des AVR an den Programmer

Anschlussskizze

Erstaunlicherweise hat mir das die groessten Probleme gemacht. Durch meine Unerfahrenheit mit den entsprechenden Dokumentationen war mir nie ganz klar, ob das jetzt alles richtig-rum ist oder spiegelverkehrt etc.. Die folgende Skizze soll den richtigen Anschluss hoffentlich ein wenig erleichtern. Um nicht jedesmal wieder alles miteinander verbinden zu muessen, empfiehl es sich einen Sockel oder ein freies Breadboard zu verwenden, auf das man den AVR dann nur noch druecken muss.

Mit einer soliden Verdrahtung muss der AVR nur noch auf das Breadboard gelegt werden um Programmiert zu werden.
Mit einer soliden Verdrahtung muss der AVR nur noch auf das Breadboard gelegt werden um Programmiert zu werden.

Die Skizze entspricht der Breadboard-Draufsicht. Die Kerbung des AVR sollte offensichtlich sein. Der Anschluss fuer den Programmer entspricht einem entsprechenden Steckplatz auf dem Breadboard. Eine zusaetzliche Stromversorgung sollte nicht noetig sein.

 

 

 

 Compilieren und Uebertragen

Zum testen werden wir folgenden Code benutzen, der sich grade so compilieren laesst aber absolut keinen Nutzen hat. Wir verwenden keine IDE sondern einfach unseren Lieblingseditor (in meinem Falle ViM).

./helloworld.c

 // 1MHz
#define F_CPU 1000000UL

#include <avr/io.h>

int main(void){
	return 0;	
}

Nun bauen wir uns unser Makefile.  Make ist ein in der Linux-Welt sehr beliebtes und gewoehnlich vorinstalliertes Build-Tool. Einmal erstellt werden wir mit ‚make compile‘ compilieren und mit ‚make write‘ den AVR programmieren koennen ohne jedes mal ein laengeres Kommando eingeben zu muessen. Ein Makefile wird fuer jedes Projekt angelegt und definiert ein paar Funktionen (in unserem Falle werden das ‚compile‘, ‚write‘ und ‚clean‘ sein) fuer dieses Projekt. Das folgende Makefile ist auf eine einzige .c-Datei ohne Header ausgelegt.

./makefile

#basiert auf: http://www.lima-city.de/thread/makefile-fuer-avr-gcc
#CFILE.c enthaelt den Code. 
CFILE=helloworld
#Type des AVR
AVRTYPE=attiny2313

compile:
	avr-gcc -mmcu=$(AVRTYPE) -O2 $(CFILE).c -o $(CFILE).o

write:
	avr-objcopy -j .text -j .data -O ihex $(CFILE).o $(CFILE).hex
	avrdude -V -p $(AVRTYPE) -c stk500v2 -P /dev/ttyUSB0 -U flash:w:$(CFILE).hex

clean:
	rm $(CFILE).hex $(CFILE).map $(CFILE).o $(CFILE).out

Falls du einen anderen Dateinamen oder AVR benutzen willst, kannst du das in den Parametern einfach einstellen.

Wenn wir den AVR mit dem mySmartUSB light und gleichen mit dem Computer verbunden haben, gehen wir in der Ordner mit helloworld.c und makefile und fuehren folgendes aus:

  1. ‚make compile‘ zum compilieren
  2. ‚make write‘ zum Uebertragen des compilierten Programms auf den AVR
  3. ‚make clean‘ falls du wieder einen sauberen Ordner haben willst.

Die Ausgabe sollte folgendermassen aussehen:output-new

Wenn beim ersten Befehl was fehl schlaegt, ist entweder etwas in deinem Code falsch oder dir fehlt eine Library. Wenn beim zweiten etwas fehlt schlaegt hast du vermutlich bei der Verkabelung was falsch gemacht.

Ein Program mit Input und Output

pinsJetzt wo wir den AVR Programmieren koennen, koennen wir anfangen nuetzliche Programme zu schreiben, insbesondere die Pins zu benutzen. Der Arduino-Nutzer wird sich jetzt vermutlich ein wenig in die Steinzeit zurueckversetzt fuehlen, den ganz so einfach wie auf dem Arduino ist dies nicht. Vielleicht ist dir schon in der Verkabelungsskizze aufgefallen, dass die Pins nicht von 1-N durchnummeriert sind, sondern auch einen Buchstaben haben. Der Grund hierfuer ist, dass es fuer jede Pin-Gruppe ein 8Bit-Register(wird in C wie ein Variable benutzt) gibt, in dem fuer B und D jeweils ein Bit fuer einen Pin stehen. Bei der A-Gruppe handelt es sich um analoge Pins, die mehr als nur ein Bit brauchen, weswegen es auch nur 3 Stueck von diesen gibt.

Schnelle Schaltskizze
Schnelle Schaltskizze

Fuer einen einfacheren Einstieg schauen wir uns den Code erstmal fuer Arduino an. Ich nehme hierbei einfach mal an, dass du bereits Erfahrungen mit Arduino gesammelt hast, bevor du es mit AVR versuchst. Sollte dies nicht so sein, so kannst du den Arduino-Teil auch ueberspringen. Die Schaltung kommt mit einem Button und einer Led aus. Du brauchst zum testen eine externe Spannungsquelle mit 3,5-5V (am besten Labornetzteil, aber auch Batterien oder ein Arduino koennen herhalten). Die Led braucht unter Umstaenden einen Vorwiderstand abhaengig von Betriebsspannung und Led.

//Beispiel fuer Arduino mit Pin 2 fuer Led und Pin3 fuer Button
//TODO: Ungetestet
int led = 2;
int button = 3;

void setup(){
  pinMode(led, OUTPUT); //Pin als Output
  pinMode(button, INPUT); //Pin als Input
  digitalWrite(button, HIGH); //Pullup
}

void loop(){
  if(digitalRead(button)==HIGH){ //Falls Button gedrueckt
    digitalWrite(led, HIGH); //Led einschalten
    delay(1000); //1 Sekunde warten
  } else {
    digitalWrite(led, LOW); //Led ausschalten
  }
}

Nun bauen wir den Code fuer AVR um. Statt direkt die Pins ansprechen zu koennen muessen wir nun ueber die Ports gehen, was den Code deutlich komplizierter macht. Wir benutze auch keine Funktionen mehr fuer die Pin Ein- und Ausgabe sondern lesen direkt aus dem Register.

#define F_CPU 1000000
#include <avr/io.h>
#include <util/delay.h>

//Pin B0 als Led
#define LED_DDR DDRB
#define LED_PORT PORTB
#define LED_PINNR PB0

//Pin B1 als Button
#define BUTTON_DDR DDRB
#define BUTTON_PORT PORTB
#define BUTTON_PINNR PB1
#define BUTTON_PIN PINB

int main(){ //Wir haben nichtmehr setup() und loop() sondern nur noch main()
   //setup()
     LED_DDR |= (1<<LED_PINNR);//Led-Pin als Output
     BUTTON_DDR &= ~(1<<BUTTON_PINNR);//Button-Pin als Input
     BUTTON_PORT |= (1<<BUTTON_PINNR);//PullUp

   //loop()
      while(1){
         if((BUTTON_PIN & (1<<BUTTON_PINNR))==0){ //Falls Button gedrueckt. Button gedrueckt -> Low(0)
	    LED_PORT |= (1<<LED_PINNR); //Led an
	    _delay_ms(1000); //1 Sekunde warten
	 } else {
            LED_PORT &= ~(1<<LED_PINNR); //Led aus
	 }
       }

   //Damit der Compiler nicht meckert:
   return 0;
}

Jedes Register hat 8 Bit die mit Bit-Operatoren modifiziert werden koennen (dies mag jetzt im Vergleich zu Arduino barbarisch wirken, kann aber ein paar CPU-Takte sparen. Angesichts der CPU-Taktrate und den Optimierungsmoeglichkeiten des Compilers, darf aber auch ohne schlechtes Gewissen einfach eine selbstzuschreibende Hilfsfunktion benutzt werden).  Eine Uebersicht ueber die Operatoren, die man bei ‚hoeheren‘ Programmen doch eher selten braucht, gibt es auf Wikipedia.

| Pin7 | Pin6 | Pin5 |Pin4 | Pin3 | Pin2 | Pin1 | Pin0 |

DDR ist fuer Eingabe/Ausgabe zustaendig. Wenn an der entsprechenden Stelle eine 1 steht, so wird der Pin als Ausgabe verwendet, bei einer 0 als Eingabe. Bei Eingabe sollte man nicht vergessen, den PullUp-Wiederstand zu setzen, falls man dies nicht mit Hardware geloest hat.

  • Beispiel: Pin 1(B) als Ausgang => DDRB = 00000010(bin)
  • DDRB |= (1<<1); // Pin1 auf ‚1‘ setzen, die anderen Pins unveraendert.
  • DDRB &= ~(1<<1); //Pin1 auf ‚0‘ setzen, die anderen Pins unveraendert.

PORT ist fuer die Ausgangsspannung zustaendig. Wenn wir also eine Led leuchten lassen oder den PullUp aktivieren wollen, muessen wir an die entsprechende Stelle eine 1 setzen.

  • Beispiel: Pin 2(b) auf HIGH => PORTB = 00000100(bin)
  • PORTB |= (1<<2); // Pin2 auf ‚1‘ setzen, die anderen Pins unveraendert.
  • PORTB &= ~(1<<2); //Pin2 auf ‚0‘ setzen, die anderen Pins unveraendert.

PIN ist fuer die Eingangsspannung zustaendig. Hier koennen wir also auslesen ob am Pin eine Spannung anliegt bzw. der Button gedrueckt/losgelassen wurde.

  • Beispiel: An Pin 3(b) liegt eine Spannung an => PINB = 00001000(bin)
  • if( (PINB & (1<<3))==0 ) //Falls Pin3 =’0′ ist (Button gedrueckt)

[to be continued]

Es funktioniert nicht!? Ich hatte das Problem, dass die meisten Makefiles aus anderen Tutorials zwar ohne Fehlermeldungen und aehnlichem Output durchliefen, aber leider hat sich beim AVR nichts geregt. Sollte dies bei dir auch der Fall sein, so versuch einfach mal ein paar andere Makefiles. Leider habe ich noch kein Tutorial zum Anfertigen eines solchen Makefiles gefunden, sodass es ich nach Try&Error vorgegangen bin. Da ich aber nur sehr selten AVR programmiere und dann auch nicht professionel habe ich bisher keinen Grund gesehn, mich dort selbststaendig tiefer einzuarbeiten.

PDFs unter Linux bearbeiten/annotieren

Nicht jedes Vorlesungsmaterial will man ausdrucken, aber doch hat man regelmaessig das Beduerfnis wichtige Passagen zu markieren oder Bemerkungen anzufuegen. Waehrend etliche PDF-Reader unter Windows das von Haus aus koennen, kann unter Linux das leider fast keiner. Im Folgenden werde ich ein paar Linux Tools vorstellen, die diese Funktionalitaet erbringen. Es werden ausschliesslich Tools betrachtet die auch als Reader zu gebrauchen sind, alles andere wuerde die Produktivitaet wohl kaum foerdern.

Der einzige echte Linux-PDF-Reader der Annotationen und Markierungen beherscht ist Okular aus KDE. Zwar bringt dies den Nachteil mit sich, das Teile der KDE-Umgebung installiert werden muessen, jedoch gibt es in der KDE-Welt einige gute weitere Programme und derzeit wird auch wohl die Trennung der Anwendungen vom Desktop vorrangetrieben (Dies habe ich vor kurzem irgendwo mal gelesen. Ob dies korrekt in meinem Gedaechnis geblieben ist, kann ich nicht garantieren.). Okular ist zwar ein wenig langsammer als Evince (Default auf den meisten Systemen), aber bietet einen wenig besseren Nutzerkomfort und kann, wie schon angesprochen, zusaetzlich auch noch Annotieren und Markieren.

Beispiel in Okular
Beispiel in Okular

Okular verfuegt ueber ein paar Tools die sich angenehm per Maus benutzen lassen aber auch per Shortcut mit [F6] zum aktivieren des Bearbeitungsmodus und dann den Tasten 1-9 zur Auswahl des Tools. Die Feineinstellungen fuer die Markierungen lassen sich leider nur einzeln ueber Rechtsklick und Bearbeiten machen und leider ist die unveraenderbar Grundeinstellung fuer Unterstreichen und Ellipse unbrauchbar, da sie den Text unlesbar machen. Der Marker hingegen funktioniert sehr gut und auch die blauen Boxen lassen sich schnell ziehen. Alle Bearbeitungen lassen sich auch nachtraeglich noch veraendern oder wieder entfernen, da sie nicht in der PDF selbst, sondern extern von Okular gespeichert werden. In den neueren Versionen von Okular koennen die Annotionen aber auch exportiert werden. Okular verfuegt auch im Praesentationsmodus ueber eingeschraenkte Malfunktionen.

Xournal ist im Gegensatz zu Okular kein echter PDF-Reader, kann aber PDFs sowohl importieren, als auch exportieren. Es annotiert weniger, als das es ‚Malwerkzeuge‘ in Form von Marker, Stift und Text sowie dafuer Linial und Form-Erkennung. Leider bietet es aber keine Texterkennung, was sauberes Markieren ausserordentlich umstaendlich macht, und zusaetzlich auch keine Shortcuts.

Xournal Beispiel
Xournal Beispiel – Beim gelben Marker ist zu erkennen, dass verschiedene Markierungen interferieren und somit den Text unleserlich machen koennen.

Obwohl die Nutzerfreundlichkeit dadurch gegenueber Okular deutlich geringer ist, hat man aber auch viel mehr Moeglichkeiten fuer umfangreichere Bearbeitungen. Auch die Optionen fuer die einzelnen Tools wie ‚Farbe‘ etc. lassen sich viel schneller wechseln als in Okular. Ein gezieltes Loeschen von Markierungen ist nicht moeglich, dafuer stehen aber Radierer zur Verfuegung. Wer also intensiveres Bearbeiten von wenigeren Seiten vorhat, faehrt mit Xournal vermutlich deutlich besser. Wenn man hingegen einfach nur die wichtigen Stellen in einem laengerem Skript markieren will, der sollte aufgrund der hoeren Benutzerfreundlichkeit und den besseren Reader-Eigenschaften lieber auf Okular zurueckgreifen.

Fuer Bearbeitungen die weit ueber das Markieren hinaus gehen sollen, sei auch darauf hingewiesen, dass Inkscape das OpenSource Pendant zu Adobe Illustrator, auch PDFs bearbeiten kann. Allerdings wird man hiermit keinesfalls mehr als eine Seite bearbeiten wollen, da es keinerlei Reader-Eigenschaften aufweist.

Wer einfach nur seine Vorlesungsfolien zur Klausurvorbereitung auf das wesentliche kuerzen will, indem man die unwichtigen Folien die man bereits auswendig kann entfernt, wird vermutlich auch mit pdfshuffler gluecklich werden. Mit diesem kann man sich bequem die Folien ansehen und nach belieben Loeschen/Drehen/Verschieben. Auch wenn der Viewer eigentlich nur zur Auswahl der Folien dienen soll, kann er dank der Zoom-Funktion auch als Reader benutzt werden, wobei hierbei leider die Schaerfe etwas zu wuenschen uebrig laesst. Dafuer lassen sich auch 1000+ Folien nach ein wenig Ladezeit ruckelfrei ansehen.

PDF-Shuffler mit Zoom auf 3 Seiten
PDF-Shuffler mit Zoom auf 3 Seiten

to be continued…

Siehe auch meinen Artikel zu Vorlesungsfolien auf EBook-Reader

Vorlesungsfolien auf E-Book Reader Kindle

Etliche Vorlesungen werden heute nichtmehr mit Skript und Tafel gefuehrt, sondern nur noch mit Folien ala PowerPoint. Da die Anzahl der Seiten dieser jedoch teils sehr hoch sein kann (Teils 1000+) und sich am Computer nur bedingt lernen laesst, habe ich mir ein Amazon Kindle geholt, welches mit damals 99Euro bereits recht guenstig war (Wenn man das WLAN deaktiviert und nur USB benutzt ist man auch von Amazon ‚befreit‘).

Auch wenn das E-Ink Display wirklich extrem angenehm ist und das 4:3-Verhaeltnis optimal fuer die Vorlesungsfolien im selben Format sein sollte, so macht die Fortschrittleiste des Kindles doch Probleme, da durch diese eine Seite nichtmehr ganz auf das Display passt und Kindle eine Folie auf zwei Seiten spaltet. Alternativ kann man natuerlich einfach im Hochkantmodus bleiben, aber dann nutzt man nur die Haelfte des Displays. Dies war fuer mich nicht aktzeptabel. Ich wollte eine Seite fuer eine Folie und den kompletten Display benutzen. Gluecklicherweise ist dies mit leichten Modifikationen der PDFs moeglich.

Wenn wir die Folieseiten einfach um 90Deg drehen, stellt das Kindle die Folien im Hochkantmodus wie im Seitwaertsmodus dar, ohne sie zu spalten. Dies kann pdftk recht einfach und ohne das die PDF gigantisch gross wird (Dies war bei meiner ersten Idee, das Folienformat anzupassen, der Fall). Der Befehl hierfuer ist:

pdftk folien.pdf cat 1-endE output folienKindle.pdf

Falls ihr Dozent pro Kapitel einen Foliensatz macht, ist es eventuell noch ganz praktisch, die zu einer PDF zusammenzufuegen. Auch dies kann pdftk problemlos:

pdftk 1.pdf 2.pdf 3.pdf cat output 123.pdf

Vorlesungsfolie auf Kindle

Mit diesen beiden Tricks stellt ein E-Book Reader die perfekte Moeglichkeit dar, fuer eine Vorlesung zu lernen. Jede Seite fuehlt sich an wie eine grosse Karteikarte, nur das man das komplete Semester in der Jackentasche verstauen kann um im Bus nochmal die letzte Vorlesung zu rekapitulieren.

Anmerkung:  pdftk ist auch fuer Windows und Mac verfuegbar.

Fuer speziellere Beduerfnisse bietet sich auch pdfshuffler an. Fuer automatisiertes Vorgehen (automatischer Download und Konvertierung und Uebertragung der neusten Folien aufs Kindle) ist dieser zwar nicht geeignet, dafuer lassen sich gut die ‚unwichtigen‘ Folien aussortieren.

Zerlegen einer 2x1-PDF in die urspruenglichen Folien
Zerlegen einer 2×1-PDF in die urspruenglichen Folien mit pdfscissors

Sollten die Vorlesungsfolien nur ‚Druckfertig‘, also z.B. 2 Folien pro Seite, angeboten werden, so kann man die PDF mit pdfscissors, einer Java-Web-Applikation die sich u.A. mit icedTea(OpenJDK) ausfuehren laesst (einfach die .jnlp Datei downloaden und ausfuehren), in entsprechende Teile zerschneiden. Dies funktioniert erstaunlich schnell und die erzeugte PDF ist kaum groesser als das Original.

 

 

Experimental Blog