Monitor your SVN Repositories with a simple Python script

I have to work with a lot of SVN repositories that do only have a terrible EMail notification. So, it would be nice to have a script that quickly collects the updates of all your repositories by listening you all the commit messages of all new commits.

This can be done using the following simple Python script:

svncheck.py

# This script has some functions to check the svn revision and print the logs since the last update (it updates on
# its way).
# In the base version of this script, the list 'svn_folders' is run through. However you can also print the change log
# for the current working directory with 'printLog(getRevisionDifference())'

import os

# TODO: Enter the paths to your repos here
svn_folders = ["/home/USER/Repos/Repo1", "/home/USER/Repos/Repo2"]

# parses the current local revision
def getRevision():
    stdin, stdout = os.popen2("svn log -l 1")
    stdin.close()
    lines = stdout.readlines()
    if len(lines) == 1:
        return None
    return int(lines[1].split(" ")[0].replace('r',''))


# gets the svn up to date
def update():
    stdin, stdout = os.popen2("svn up")
    stdin.close()
    stdout.readlines() # for waiting for termination


# updates the svn and returns the revision change
def getRevisionDifference():
    revOld = getRevision()
    if revOld is None:
        print 'Not a working directory. Please check your configuration.'
        return
    update()
    revNew = getRevision()
    return revNew - revOld


# prints the log for the last n changes
def printLog(lastN):
    if lastN == 0:
        print "No changes."
        return
    os.system("svn log -l " + str(lastN))


# execute
for svn_folder in svn_folders:
    print svn_folder
    os.chdir(svn_folder)
    printLog(getRevisionDifference()

Simply save it as a .py-file and make it executable with ‘chmod +x svncheck.py’. Afterwards you can execute it anytime with ‘python svncheck.py‘ (actually on most systems you don’t need the ‘python‘)

The script will go to each repository-folder and for each of these folders:
1. Check the current local revision
2. Update the repository
3. Check the new revision
4. Print the log for the new revisions

Note: This does not automatically send you notifications but only displays changes if executed manually. However, you can quite easily pipe

os.system("svn log -l " + str(lastN)

into some notification program and let the script be executed automatically via a cronjob.

Workaround for Misprints of Samsung XPress M2825ND

I got myself a Samsung XPress M2825ND Mono Laser Printer for little money. Most of the time it does a great job: It is fast, very sharp, and the automatic duplex is a blessing if you have to print many papers. Unfortunately, if printing manipulated PDFs (like 2 pages per side) it doesn’t print properly: It leaves some parts blank. I did not notice any difficulties with ‘clean’ PDFs like created by Latex (as long as you do not use any further modifications in the print properties).

However, if I do the 2 pages per side modification externally (not in the print configuration) with

 pdfnup --nup 2x1 --landscape --suffix '''2x1''' --scale '''0.95'' input.pdf

 and afterwards convert the PDF to PNG and concatenate the PNGs to a PDF again

convert -quality 100 -density 300x300 input.pdf single%05d.png && convert -adjoin single*.png output.pdf && rm single*.png

everything works fine.

Nonetheless, the produced PDF takes much longer to process for the printer. I only apply this method if the normal printing fails (It happens only seldom and if mostly only one page, so the wasted prints are not serious).

Note: I haven’t had any misprints for some time using the newest Samsung drivers and Arch Linux. I only had a problem with “Select page size using document size” which resulted in very small prints if activated.

Erfahrungsbericht: Mein Informatik-Studium an der TU Braunschweig

Das Studium ist ein neuer Lebensabschnitt und gewöhnlich bereitet einem die Schule nur sehr bedingt darauf vor. Um potentiellen zukünftigen Informatik-Studenten an der TU Braunschweig eine bessere Vorstellung zu gewährleisten, habe ich meine Erfahrungen mal zusammengefasst. Ich stelle weder den Anspruch auf Vollständigkeit noch auf Korrektheit, sondern gebe nur eine subjektive Einsicht.

Vorkenntnisse:

Ich persönlich hatte nie Informatik-Unterricht. Java habe ich mir in der Zeit nach Schulabschluss und vor Semesterbeginn selber beigebracht. Diese Sprache müsst ihr in eurem Bachelorstudium beherrschen (C und C++ werden später auch verlangt, aber nicht so intensiv). Ein gutes Buch für den Java Einstieg ist ‘Grundkurs Programmieren in Java von Ratz et al.’.

Offiziel müsst ihr keinerlei Vorkenntnisse zum Studienbeginn haben, aber die Mathematik wird euch vermutlich sehr fordern und bereits Programmieren zu können wird euch den Einstieg bedeutend einfacher machen. Die Mathematik in der Hochschule unterscheidet sich sehr stark von der Schulmathematik und ich denke nicht, dass man sich alleine darauf richtig vorbereiten kann. Falls du es doch versuchen willst, kann ich das Buch ‘Mathematik für Informatiker von Teschl und Teschl’ empfehlen. Es ist gut lesbar, aber richtig vorbereitet hatte es mich trotzdem irgendwie nicht. Das soll dir aber keine Angst machen: Es ist anders und es ist schwerer (Keine Kunst, Schulmathematik ist nicht sonderlich anspruchsvoll), aber es ist auch bedeutend besser und schöner.

Aufbau:

Das Studium besteht aus Pflichtmodulen, die für einen Informatiker unerlässlich sind, und Wahlpflichtmodulen, die in eine bestimme Richtung vertiefen. Module sind meistens Vorlesungen, aber es gibt auch Praktika/Teamprojekte etc.. Vorlesungen werden meistens mit einer benoteten Klausur in der vorlesungsfreien Zeit abgeschlossen und du wirst etwa 5 Prüfungen pro Semester machen. Prüfungen haben eine Durchfallquote von meist etwa 30% (aber auch 95% u.Ä. sind in Pflichtmodulen schon vorgekommen). Du darfst eine Prüfung aber 3 Mal wiederholen und wenn dir die Note nicht gefällt hast du sogar einen zweiten Verbesserungsversuch (nur wenn du das erste mal bestehst, beste Note wird gewertet). Insofern du aber vernünftig lernst und nicht ganz talentlos bist, solltest du aber nie Durchfallen.

Die ersten Semester sind hauptsächlich Pflichtmodule wie Programmieren 1+2, Lineare Algebra, Analysis, Diskrete Mathematik, Logik. Dies sind Vorlesungen mit teils über 200 Teilnehmern und dementsprechend anonyme. Später werden die Vorlesungen aber deutlich kleiner, sodass die Professoren/Dozenten teils die Namen der Studenten kennen. Es gibt allgemein keine Anwesenheitspflicht und man kann auch einfach mit dem Material lernen. Dies ist im Allgemeinen aber nicht zu empfehlen, ausserdem sind Vorlesungen keine langweiligen Schulstunden.

Neben der Informatik wirst du auch noch ein Nebenfach wählen müssen. Dieses macht aber nur einen kleinen Umfang des Studiums aus (2-3 Vorlesungen). Ich persönlich habe Mathematik gewählt.

 Mein Studienverlauf

Dein Studienverlauf kann vollkommen anders aussehen. Dozenten wechseln zwar nicht häufig, aber es kommt vor.

Ich habe mein Studium in Regelstudienzeit und ‘mit Auszeichnung’ abgeschlossen. Ich bin ein begeisterter Informatiker und fühle mich inbesondere in den mathematischeren Gebieten (Insb. Algorithmik) besonders wohl. In diesem Bericht gehe ich davon aus, dass du ähnliche Ambitionen hast.

Ich bin das erste Jahr noch gependelt (~3 Stunden pro Uni-Tag) und bin erst dann in mein erste eigene Wohnung in Uninähe gezogen. Die Wohnsituation ist für günstige Studentenwohnungen in Uninähe durchaus anstrengend, aber nicht hoffnungslos. Ich zahle 160Euro(Kalt) für eine 18.49$m^2$ Wohung  mit Balkon ins Grüne. Die Selbstständigkeit ist eine wichtige Erfahrung, aber eine Pantryküche und Party-Studenten als Nachbarn keine sonderlich schöne.

1. Semester

Im ersten Semester wirst du vermutlich nur Vorlesungsmodule hören, die alle mit einer schriftlichen Klausur abgeschlossen werden. Bei mir waren es die folgenden:

  • Programmieren 1 (6CP, Pflicht): Hier wird mit Java und objektorientierter Programmierung angefangen. Diese Vorlesung hat einige theoretische/mathematische Elemente, die man nicht unterschätzen sollte. Es gibt Programmier-Hausaufgaben, die aber schnell gemacht sind. Die Klausur beinhaltet Fallen, aber dafür sind die alten Klausuren ins Netz gestellt.
  • Lineare Algebra (10CP,Pflicht): Abstrakte Mathematik die weit über das Vektorrechnen aus der Schule hinausgeht. Am Anfang des Studiums scheint einem das vielleicht ein wenig nutzlos vorkommen, aber das Zeug ist wirklich wichtig und wird euch immer wieder begegnen. Hier gibt es keine verpflichtenden Hausaufgaben, aber es empfiehlt sich an den Übungen teilzunehmen.
  • Diskrete Mathematik (5CP, Pflicht): Ein Rundumschlag über die für Informatik wichtigen Disziplinen ausserhalb von Linearer Algebra und Analysis. Die Klausur ist nur Anwendung und es werden keine Beweise oder Ähnliches verlangt. Da ich das Material aber auf Verständnis gelernt habe und nicht auf Anwendung, wurde dieses Fach meine schlechteste Klausur (3.0). Dafür sitzt es aber immer noch tief und fest. Dies ist nicht bei jedem so und man stolpert später auch mal über Studenten die den Induktionsbeweis nicht ganz richtig verstanden haben, aber glauben dies zu tun. Tatsächlich hatte ich schon mal (im 6. Semester) eine Auseinandersetzung mit einer Gruppe Studenten, weil ich einen von einem Studenten vorgeführten falschen Induktionsbeweis nicht akzeptiert habe. Ich war nicht in der Lage mich durchzusetzen, erst später gab man mir dann Recht.
  • Theoretische Informatik 1(5CP, Pflicht): Einführung in Automatentheorie, Formale Sprachen u.Ä.. Eigentlich erst für das dritte Semester vorgesehen, kann man aber vorziehen. Die Hausaufgaben sind gewöhnlich sehr fordernd und auch die Klausur ist nicht einfach. Ist aber ein sehr interessantes Fach. Wirklich zur Sache geht es aber erst in Theoretische Informatik 2. Obwohl die Vorlesung einige Voraussetzungen aus den ersten zwei Semestern hat, habe ich als einer der besten abgeschlossen.
  • Algorithmen und Datenstrukturen (8CP, Pflicht): Algorithmen und Datenstrukturen ist der Werkzeugkasten des Informatikers. Die Vorlesung legt viel Wert darauf, solide Grundlagen zu legen. Wenn dir, wir mir, der Inhalt zu interessant ist und du bereits zu Beginn die Bücher verschlingst, wird dir die Vorlesung aber zu langsam sein. Obwohl die Algorithmik nun mein Spezialisierungsgebiet ist und ich mich bereits damals sehr viel weiterführend damit beschäftigt habe, habe ich die Klausur nur mit einer 1.7 abgeschlossen.

 2. Semester

  • Programmieren 2 (6CP, Pflicht): Hier geht es in gleicher Manier wie in Programmieren 1 weiter.
  • Analysis (10CP, Pflicht): Ähnlich zu Linearer Algebra nur das jetzt das Thema anders ist.
  • Theoretische Informatik 2 (6CP, Pflicht): Hier geht es jetzt aufbauend auf Theoretischer Informatik 1 richtig zur Sache. NP=P-Problem, Entscheidbarkeit, etc. sind die anspruchsvollen aber extrem interessanten Themen dieser Vorlesung. Eine der wichtigsten Vorlesungen in meinem Studium.
  • Logik (5CP, Pflicht): Eigentlich als Vorspiel zur Theoretischen Informatik gedacht und dementsprechend fiel mir dieses Fach leicht. Es ist trotzdem sehr interessant und nützlich. Wer sich mit dem Stoff vernünftig auseinandersetzt, kann die häufig im Netz schwirrenden Logikprobleme relativ einfach lösen. Aber auch sonst im Leben und insbesondere in der Informatik ist Logik sehr nützlich.
  • Grundlagen der Technischen Informatik (5 CP, Wahlpflicht): Eine freiwillige (Wahlpflicht) Vorbereitung auf Technische Informatik. Die Vorlesung ist ansich nicht schlecht, aber ich hätte doch lieber etwas anderes gehört. Die mathematischeren/theoretischeren Fächer liegen mir einfach mehr.
  • Stochastik (5CP, Mathe-Wahlpflicht): Wähle zwei aus: Stochastik, Numerik, Algebra, Statistik. Stochastik war mein erstes Mathewahlpflichtfach. Hier werden die Grundlagen der Stochastik durchgegangen. Gar nicht so weit von der Schulmathematik entfernt wie die anderen Mathematik-Veranstalltungen. Nützlich, aber wenn ich Stochastik brauche muss ich trotzdem nachschlagen.
  • Computernetze 1 (5CP): Nur halbherzig gehört und Prüfung wieder abgemeldet (bis zum Abend vor der Klausur möglich). Verschoben auf 4. Semester.

3. Semester

  • Software Engineering (5 CP, Pflicht): Wie baut/verkauft/beschreibt man Software. Also Diagramme, Charts, Pflichtenheft und Ähnliches. Die Prüfung habe ich unter Krankheit abgelegt, weil ich das Unwohlsein als Prüfungsangst fehlinterpretiert habe. Anschließend lag ich für über eine Woche halb tot im Bett (und ich konnte mich auch nicht mehr wirklich an die Klausur erinnern).
  • Relationale Datenbanksysteme 1 (5CP): Daten in Tabellen und wie man mit diesen Daten arbeitet. Sollte jeder Informatik-Student können, aber begeistern kann ich mich für SQL nicht. Die Prüfung ist sehr berüchtigt und du kannst einige lustige Geschichten hören und lesen. Aufgrund von Krankheit im 4. Semester geprüft.
  • Algorithmik-Praktikum (5CP, Wahlpflicht, unbewertet): Hier haben wir external Memory Algorithmen für die Wiselib programmiert. Sehr nützliche Erfahrung.
  • Geschichte der Mathematik (5CP, Schlüsselqualifikation, unbewertet): Unterhaltsame Vorlesung mit Abschluss durch Hausarbeit. Ich habe mich mit Cantor und seinen Beiträgen zum Verständnis der Unendlichkeit beschäftigt. Tatsächlich ist diese bedeutend weniger intuitiv als man denken mag (Unendlich ist nicht gleich Unendlich, z.b. Gibt es genauso viele natürliche Zahlen wie rationale Zahlen, aber mehr reelle Zahlen als natürliche Zahlen). Eng verflochten mit der Theoretischen Informatik.
  • Teamprojekt (5CP, Pflicht, unbewertet): Hier haben wir eine Roboterlokalisierung über eine Kamera implementiert. Es sind einige Marker auf DIN-A4 ausgedruckt mit bekannten Positionen auf dem Boden verteilt. Sobald der Roboter eine solche Markierung sieht, berechnet er die relative Position des Markers und damit seine eigene Position. Auch wenn der Marker relativ weit entfernt war und die Auflösung nicht so gut, funktionierte dies doch erstaunlich genau (maximal wenige cm Abweichung). Double-Werte haben sich hier für mich zum ersten Mal als zu ungenau herausgestellt.
  • Betriebssystem (5CP, Pflicht): Hier es um die Probleme, die ein Betriebssystem lösen muss (etwa wie es 5 Prozesse auf einem Prozessor ausführt und alle glauben, sie wären alleine). Ein Betriebssystem selber schreiben kann man anschließend aber nicht.
  • Programmieren für Fortgeschrittene (5CP): Hier geht es um Funktionale Programmierung und den generellen Eigenschaften die Programmiersprachen haben können. Interessant, aber aufgrund von Krankheit nicht geprüft. Da ich keine Credit-Probleme hatte, habe ich die Prüfung nie nachgeholt.
Hiwi

Ich habe dieses Semester als Tutor für Theoretische Informatik 1 gearbeitet. Dies beinhaltet das Leiten einer kleinen Übung in der Hausaufgaben besprochen werden, das Korrigieren von Hausaufgaben, Mithilfe in der Korrektur der Klausuren. Die meisten Teilnehmer in meiner Übung waren im selben oder gar höherem Semester als ich. Dementsprechend fehlte es mir an Selbstvertrauen und ich wurde meinen eigenen Anforderungen nicht gerecht. Trotzdem habe ich hieraus Erfahrungen gesammelt und weiß wie man es nicht machen sollte.

4. Semester

  • SEP (7CP, Pflicht, Unbewertet): Das SEP ist ein berüchtigter Zeitfresser in dem man in einer Gruppe ein mittelgroßes Softwareprojekt umsetzen muss. Wir haben einen Raum gebaut in dem 3 Wände mit Beamern bestrahlt wurden und eine 3D U-Boot Umgebung darstellte. Der Raum war weiter mit (drahtlos) vernetzten Objekten ausgestattet mit denen der Nutzer Aufgaben erfüllen musste die das U-Boot am Sinken hindern. Wir hatten ein Haufen Arduinos (mit XBee) und Sensoren, sowie die Raumkonstruktion und mussten ansonsten alles selbst programmieren. Unser Team war mit 11 Leuten (3 Informatiker, 8 IST’ler) sehr groß und bis auf eine Person waren auch alle sehr fleißig und kompetent. Wir haben deutlich mehr geleistet als verlangt war, weil uns unsere Betreuer im Glauben gelassen haben, wir würden zu wenig tun. Trotzdem hat es extrem viel Spaß gemacht und wir haben am Ende den zweiten Platz bekommen (auch wenn die meisten meinen, wir hätten den ersten verdient). Konkret habe ich hier insbesondere die Middleware zwischen Arduinos und Server entwickelt, die ziemlich cool und intelligent geworden ist.
  • Graphentheorie (10CP, Nebenfach Mathematik): Hier geht es um Graphen und deren Eigenschaften. Ein Graph ist eine Menge von Punkten die untereinander verbunden sein (können).  Hier ergeben sich einige interessante Probleme und ich konnte sehr viel Nutzen aus diesem Fach ziehen, da Probleme aus der Graphentheorie auch der Algorithmik zugeordnet werden können. Viele dieser Probleme sind auch NP-Vollständig.
  • Computernetze 1 (5CP, Pflicht): Hier geht es darum, wie ein Computernetzwerk funktioniert. Angefangen wie man Daten über ein Kabel oder Funk sendet bis zu komplexen Netzwerken. Sehr wichtiger Inhalt. Die Vorlesung wird aufgenommen und kann sich auch zuhause angesehen werden. Die Übungen nicht, diese sind aber wichtig für die Klausur. Die Klausur ist dafür aber nicht so schwer, aber nicht unbedingt gut bewertet. Ich habe etwa keine 1.0 bekommen, weil ich die letzten Null-Stellen eines Binärcodes, den ich  vorher bereits als Dezimaldarstellung angegeben hatte, aus Platzgründen mit ‘…’ abgekürzt habe.
  • Algebra (5CP, Mathe-Wahlpflicht): Mein zweites Mathe-Wahlpflichfach. Hier geht es um Gruppen, Ringe, und Ähnliches. Ich musste mich hier ziemlich durchkämpfen und habe erst später in Kryptologie den Sinn dahinter verstanden.
  • Technische Informatik 2 (4CP, Pflicht): Hier ist der interessante Teil der Technischen Informatik: Wie funktioniert ein Prozessor. Dementsprechend Schaltungslogik und Co..
HiWi

Dieses Semester arbeitete ich als Tutor für Theoretische Informatik 2. Lief bedeutend besser als im ersten Semester, aber lehren ist schwerer als man annimmt.

5. Semester

  • Einführung in Algorithm Engineering (5CP, Wahlpflicht): Diese Vorlesung war keine Vorlesung im klassischen Sinne. Auch gab es keine Klausur. Stattdessen wurden die Studenten (<20) in 4-5er Gruppen eingeteilt und mussten ein bestimmtes Thema wissenschaftlich erarbeiten und ein Paper daraus schreiben. Wir haben einen Algorithmus für RDF-Subgraph-Isomorphismen entwickelt der zu mindestens in unseren Testszenarios und InMemory schneller war als Jena. Ich habe nach der Veranstaltung noch einen weiteren Algorithmus entwickelt der noch mal ein ganzes Stück schneller war. Allerdings ist InMemory für RDF-Datenbanken nicht ganz realistisch, daher ist der Praxisbezug wohl eher gering. Nichtsdestotrotz habe ich in der Vorlesung sehr viel über das Verfassen von Papern und der allgemeinen Arbeitsweise in der Algorithmik gelernt.
  • Information Retrieval and Web Search Engines (5CP, Wahlpflicht, Master-Modul): Diese Vorlesung habe ich aus dem Master-Pool in den Bachelor importiert. Die Vorlesung behandelt eine Fülle von Aspekten und auch eine Menge Machine-Learning (Classifier, Stochastische Modelle, etc.). Hat mir etliche neue Tools geliefert. Die Vorlesung wird mit Multimedia-Datenbanken forgesetzt in der noch weitere (noch nützlichere) Tools vorgestellt werden. Dies war meine einzige mündliche Klausur im Bachelor und ich war etwas zu nervös und obwohl ich perfekt vorbereitet war, reichte es somit nur für eine 1.3.
  • Algorithmische Graphentheorie (5CP, Nebenfach Mathematik): Fortsetzung von Graphentheorie, nur jetzt ging es um das Lösen von graphentheoretischen Problemen. Informatiker haben in dieser Vorlesung einen kleinen Vorsprung, trotzdem war es eine interessante Vorlesung.
  • Technische Informatik 1 (4CP, Pflicht): Kombiprüfung Technische Informatik 1+2 abgelegt. Die Vorlesung zu TI1 war nicht sonderlich berauschend. Hier habe ich von den Problemen der Elektronik in Prozessoren gelernt. Das meiste habe ich mir aber selber mit Büchern beigebracht.
  • Ethnomathematik (5CP, Schlüsselqualifikation, Unbewertet): Eine sehr unterhaltsame Vorlesung, ob ich aber wirklich was für meine Zukunft gelernt habe möchte ich bezweifeln.
  • Seminar (5CP, Pflicht): Im Seminar muss man zu einem Thema eine schriftliche Ausarbeitung und Präsentation machen, die benotet werden (und auch in die Endwertung eingehen). Ich musste diese vollständig in Englisch machen.
HiWi

In diesem Semester war ich als Tutor für Relationale Datenbanken 1 tätig. Lief eigentlich recht gut und ich habe am Ende eine gute Evaluation erhalten. Nebenbei war ich somit für die 3 Aussiebefächer der Informatik HiWi, was ich damals irgendwie cool fand.

Weiteres

Nebenbei habe ich mich mit einem Mitstudenten noch um eine interessante Bachelorarbeit gekümmert. Hier haben wir tatsächlich etwas Zeit in einige Treffen mit dem Professor investiert aber das dieser so viel Zeit für uns gefunden hat, fand ich schon beeindruckend.

6. Semester

  • Bachelorarbeit (15CP, doppelt gewertet): Wir hatten am Ende tatsächlich ein sehr interessantes Thema gefunden, dass mich bis heute begleitet: Schwarmrobotik. Gewöhnlich werden Bachelorarbeiten auch alleine verfasst, aber es ist auch möglich diese zu zweit zu verfassen, insofern man hervorhebt welche Leistungen von wem erbracht wurden. Ich habe mit dem Mitstudenten schon in sehr vielen Projekten zusammengearbeitet und dementsprechend waren wir schon aufeinander eingestimmt. Ausserdem waren wir auf einem gleichen Leistungsniveau und konnten uns gut ergänzen, sodass wir sehr effektiv miteinander arbeiten konnten. Für unsere Arbeit wurden wir später auch ausgezeichnet.
  • Netzwerkalgorithmen (5CP, Wahlpflicht): Mir fehlten noch 3 oder 4 CP, also habe ich noch Netzwerkalgorithmen neben der Bachelorarbeit gehört. Netzwerkalgorithmen hat nichts mit Computernetzen sondern eher mit Graphentheorie zu tun. Aufgrund meines Nebenfachs hatte ich aber einen enormen Vorteil.
  • Knowledge Based Systems (5CP, Master-Modul): Die zu dem Zeitpunkt einzige KI-Vorlesung. Da ich aber die Punkte für meinen Bachelor schon zusammen hatte, habe ich die Prüfung nicht abgelegt, sondern die Vorlesung nur aus Interesse gehört.

 

Ende November gab es dann eine Abschlussveranstaltung mit Urkundenverleihung und Preisverleihung. Sie war aber nur ein optionales Extra. Da ich einen sehr guten Abschluss hatte, bin ich aber hingegangen. Unsere Bachelorarbeit hat tatsächlich einen Preis gewonnen. Wir wurden nicht vorher informiert und mein Mitstudent ist auch nicht zur Veranstaltung gekommen. Ich wäre beinahe auch nicht hingegangen, da mein Anzug doch etwas eng geworden ist. Glücklicherweise bin ich aber doch gegangen und habe den Preis (je ein iPad und ein Abendessen im LaCupola) dann für uns beide angenommen. Das Abendessen fand dann nach Absprache Ende Februar statt. Es war ein vergnüglicher Abend mit der Vorsitzenden der GI Regionalgruppe Braunschweig und ihrem Sohn (auch in der Informatik).

Das Informatik-Studium an der TU-Braunschweig kann ich im Nachhinein nur empfehlen: Die Vorlesungen sind zwar nicht immer so gut wie an den großen Universitäten, aber dafür muss man sich gewöhnlich nicht um Sitzplätze prügeln und man hat einen sehr direkten Kontakt zu den Professoren. Die Studentenzahlen in der Informatik sind in der letzten Zeit gestiegen, daher weiß ich nicht wie das in Zukunft aussehen wird. Aber auch wenn sich die Studentenzahl verdoppelt, werden die späteren Wahlpflicht Kurse nicht viel mehr als 30-40 Studenten haben.

Desweiteren gibt es sehr viele HiWi-Jobs sodass jeder halbwegs talentierte Informatik-Student sich seine Brötchen verdienen kann. Die Bezahlung ohne Studienabschluss liegt meiner Erinnerung nach bei etwa 9Euro die Stunde bei etwa 30-40 Stunden im Monat. Ausserdem lernt man in den meisten Jobs noch eine Menge und ist auch in die Forschung oder Lehre eingebunden.

FAQ:

Wie sieht es mit Englisch aus? In den ersten zwei Semestern kann man sich vor Englisch noch drücken, aber spätestens im 3. Semester werden Material und Literatur englischsprachig sein. Je weiter man voranschreitet, desto mehr verdrängt Englisch Deutsch. Am Ende des Bachelors wirst du flüssig Englisch verstehen und schreiben können (müssen) oder du hast schwere Probleme in der Zukunft. Mach dir darüber aber keine Sorgen, das kommt schon von alleine.

Muss ich ein Nebenfach belegen? Ja, aber es nimmt nur 15CP von 180CP ein. Ausserdem gibt es interessante Nebenfächer. Du kannst überall reinhören, aber bevor du dich Prüfen lassen willst, musst du dich festlegen.

Bis wann muss ich mich entscheiden, ob ich eine Prüfung ablege? Du musst dich in der Mitte des Semesters anmelden, kannst dich aber bei schriftlichen Klausuren bis zum Abend vor der Klausur wieder abmelden. Falls du dich also überschätzt hast und am Tag vor der Klausur noch nicht 100% fit bist, kannst du dich noch schnell um entscheiden.

Kann man Noten verbessern? Ja, das ist in beschränktem Rahmen möglich. Ein schlechter Tag in der Klausurenphase muss dir also nicht den Schnitt versauen.

Printing Course Slides

The most PDF-Reader do not support good arrangements for slides.
The most PDF-Reader do not support good arrangements for slides.

If you want to print your slides with Linux you have not that much choice how to arrange them. For 4:3-Slides, which should be the most common, 2×4 slides per page would be ideal. Unfortunately the print-menu of the most PDF-Viewer do not have this configuration.
Also it would be nice if there could be some extra space for the punch holes. And since we want to print double-sided to save paper (and to let it look less. It’s hard to motivate yourself with a thick bunch of paper.), the extra space has to be different for the even and the odd pages.

A optimal page usage with extra space for the punch holes. The content of the slides can be ignored. It's simply the first set of slides I found and not the best.
A optimal page usage with extra space for the punch holes. The content of the slides can be ignored. It’s simply the first set of slides I found and not the best.

A simple tool to generate such a printable PDF is pdfnup out of the pdfjam package. The used command is

pdfnup --twoside --nup 2x4 --suffix '2x4' --no-landscape --offset '0.8cm 0cm' --scale '0.95' slides.pdf
  • –twoside
    We want to print two-sided. If your printer does not support that, you can simply print first all odd pages and afterward you put the printed pages back into the printer and print the even pages on their backside.
  • –nup 2×4
    For the 2×4 arrangement.
  • –suffix ‘2×4’
    The output-file will have ‘2×4’ as suffix
  • –no-landscape
    If you want to print landscape you can write –landscape but then the 2×4 arrangement would be very bad.
  • –offset ‘0.8cm 0cm’
    The offset for  the punch holes. 0.8cm for the side with the punch holes and 0cm for the other
  • –scale ‘0.95’
    Maybe you have to vary the scale if the single slides are too big or small.
  • slides.pdf
    The input file

Getting notified of exam results posted on webpages

[en]The waiting for exam results is often very consuming. If they are going to be posted on the webpage of the course you are probably refreshing the page every hour for sometimes a long time. I can remember one exam, where the expected publication was unknown and took nearly two months. The exam has been corrected on the same day by the assistants ,and this was known to us, but for some reason the publication has been delayed. Since the nervous refreshing is very bad for your health it would be better to let your computer look for updates and tell you if the results are available. [/en]

[de]Das Warten auf Klausurergebnisse ist meistens sehr anstrengend. Insofern die Ergebnisse auf der entsprechenden Website veröffentlich werden, ist es nicht unwahrscheinlich das man jede Stunde die Seite lädt und das teils für einen verhältnismässig langen Zeitraum. Ich kann mich an eine Klausur erinnern bei der das erwartete Veröffentlichungsdatum unbekannt war und die Veröffentlichung fast 2 Monate brauchte. Die Klausur war, wie uns auch bekannt war, bereits am selben Tag korrigiert worden aber aus irgendeinem Grund wurde die Veröffentlich verzögert. Da das nervöse Neuladen äusserst ungesund ist, wäre es besser seinen Computer für einen auf Updates zu achten und ihn uns benachrichtigen lassen, sobald die Ergebnisse da sind.[/de]

[en]Finding a tool that is able to control all updates if they really contain the results is actually not that easy, but for being notified for all updates is. Since it is very likely that if the website is getting updated, it really contains the results, we should be satisfied with that. A simple tool for that is the Firefox-Addon Update Scanner.[/en]

[de]Ein Tool zu finden, das in der Lage ist zu kontrollieren, ob ein Update wirklich die Ergebnisse enthält ist nicht so einfach, aber einfache Update-Benachrichtiger gibt es genug. Da es sehr wahrscheinlich ist, dass wenn die Website upgedated wird, wirklich die Klausurergbnisse enthält, sollte uns das ausreichen. Ein einfaches Tool hierfür ist das Firefox-Addon Update Scanner.[/de]

This message is shown, if a scanned webpage has been updated.
This message is shown, if a scanned webpage has been updated.

[en]Chosing a page to be scanned for update is very easy. You only have to visit the page, do a right-click and chose the entry ‘Scan Page For Updates…’ . Afterwards you define a limit for symbols being ignored (such as if the webpage prints dynamically the actual date). If there is no dynamic content you should disable this function, so you wont miss an update.[/en]
[de]Eine Seite auszuwählen, die regelmäßig überprüft werden soll ist ziemlich einfach. Es muss einfach nur die Seite besucht werden, ein Rechtsklick gemacht und der Eintrag ‘Scan Page For Updates…’ ausgewählt werden. Anschließend kannst du ein Limit an Zeichen definieren die ignoriert werden sollen (Zum Beispiel wenn die Webseite dynamisch das aktuelle Datum anzeigt). Wenn sie kein dynamischen Inhalt besitzt, sollte du diese Funktion deaktivieren damit du kein Update verpasst.[/de]

Chosing a page can be made by a right mouse click.
Chosing a page can be made by a right mouse click.
The configuration after the right mouse click
The configuration after the right mouse click

[en] After you have configured the scanner for the page you can lean back and wait for your results. If the page has been updated you will see the notification from above and the page will be opened with the changes highlighted in yellow.[/en]

[de] Nachdem der Scanner für die Seite konfiguriert wurde kann man sich zurücklehnen und auf die Ergebnisse warten. Wenn die Seite verändert wurde, wirst du die Benachrichtigung von oben sehen und die Website wird sich öffnen mit den in Gelb hervorgehobenen Änderung.[/de]

The changes are marked in yellow.
The changes are marked in yellow.

[en] For other browser there are similar extensions.[/en][de]Für andere Browser gibt es ähnliche Erweiterungen.[/de]

Einfaches Arduino-UserInterface mit 16×2-Display

[en]The English translation may be not complete, since I just started to write bilingual, and also not very good.[/en]
[de]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.[/de]

[en]While Text-Output on 16×2 Character-Displays with LiquidCrystal is quite easy, input is a little bit harder. Hence you are often coding the parameters hard and flash the arduino for every value new. To expand the lifetime of my Arduino I wrote a little library for simple Input. You need only a display, compatible with the LiquidCrystal-Library, and 5 Buttons (LEFT, RIGHT, UP, DOWN, SELECT) which you can implement as you like.

The mainfunctions are for example a Menu, Numberinput, Textinput and Percentinput. Also the buttons can be accessed easily and assigned functions.[/en]

[de]Anwendungsbeispiele[/de][en]Examples of user[/en]

Menu:

display16x2-menu [de]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.[/de][en]A simple menu where you can chose between entries. You can navigate through it using the UP and DOWN keys. If you have reached the desired entry you can select it with SELECT or RIGHT. Use LEFT to abort.

[/en]

 

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

[de]Prozent:[/de][en]Percent:[/en]

display16x2-procent[de]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).[/de][en]A function to input percent-values, for example the volume. With LEFT and RIGHT you change in 10% steps, with UP and DOWN in 1% steps. You can set a function, which is called everytime the value changes (to play a sound with the new volume etc.). [/en]

 

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();

 

[de]Konfiguration[/de][en]Configuration[/en]

[de]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.[/de][en]First you have to initalize LiquidCrystal by creating the specific object. The parameter are the pins for controlling the display. You will find them in the manuals or homepage for your display.[/en]

LiquidCrystal lcd(8,9,4,5,6,7);

[de]Als naechstes erstellst du dann analog das SimpleUI16x2-Objekt, dem du das LiquidCrystal-Objekt und eine Funktion zum Abfragen der Buttons gibst.[/de][en]In the next step you create the SimpleUI16x2-object which you give the LiquidCrystal-object and a function to query the buttons.[/en]

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;
}

[de]Nun solltest du in der Lage sein, das Nutzerinterface zu benutzen. Siehe auch das in der Library enthaltene Beispiel.[/de][en]Now you should be able to use the UserInterface. You should take a look at the example in the library.[/en]

 

Download

[de]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.[/de]
[en]You will find the library in git under https://github.com/dserv01/SimpleUI16x2.

To use the library you have to move the folder SimpleUI16x2 into the folder libraries of your Sketchbook-Folder. If this Folder doesn’t exist yet, you can simply create it. Maybe you also need the LiquidCrystal-Libary, if it is not included in your Arduino-Installation by default.[/en]

./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.