Knight Rider Blinklicht mit Verilog

Auf der Uni muss man ja immer wieder lustige Sachen, aber diesmal macht mir wieder eine Lehrveranstaltung besonders Spaß. In Rechnerorganisation lernen wir Hardware mit der Beschreibungssprache Verilog zu modellieren. Aus meiner HTL-Zeit weiß ich, dass ein gutes Helloworld-Beispiel für hardwarenahe Sachen ein Knightrider-Blinklicht (Lauflicht) oder eine Ampelschaltung ist. Daher hab ich mich gleich mal hingesetzt und versucht so ein Lauflicht zu modellieren.

// knight rider blink light

module krider (clk, light);
    input clk;
    output light;
    reg [7:0] out;
    reg left;
    
    wire clk;
    wire [7:0] light;
    assign light = out;
    
    always begin
        out <= @(posedge clk) 1;
        
        while (1) begin
            
            @ (posedge clk) begin
                if (out == 'b10000000) begin
                    left = 0;
                end
                else if (out == 'b00000001) begin
                    left = 1;
                end
                out <= @(posedge clk) 
                        left ? out << 1 : out >> 1;
            end
        end
    end
    
endmodule 

module top;
    reg clk;
    wire [7:0] light;
    krider k(clk, light);
    
    initial begin
        clk = 0;
        #10000 $finish();
    end
    
    
    always begin
        #50 clk = ~clk;
    end
    
    always begin
        @ (posedge clk) begin
            $write("%b %d\n", light, $time); 
        end
    end


endmodule 

Ich bin mir zwar nicht ganz sicher ob ich alles richtig gemacht habe, aber der Output sieht schon mal nicht so schlecht aus... (Auf jeden Fall sollte man diesen Code nicht bedenkenlos übernehmen, da es mein erster Versuch war und ich noch eher Halbwissen in Verilog habe)

C:\Users\christoph>vlogcmd krider.v
VeriLogger simulation log created at Sat May 05 17:30:21 2012
Beginning Compile
Beginning Phase I
Compiling source file: krider.v
Finished Phase I
Entering Phase II...
Finished Phase II
Entering Phase III...
Finished Phase III
Highest level modules:   top
Compile Complete
.
Running...
xxxxxxxx                   50
00000001                  150
00000010                  250
00000100                  350
00001000                  450
00010000                  550
00100000                  650
01000000                  750
10000000                  850
01000000                  950
00100000                 1050
00010000                 1150
00001000                 1250
00000100                 1350
00000010                 1450
00000001                 1550
00000010                 1650
00000100                 1750
00001000                 1850
00010000                 1950
00100000                 2050
01000000                 2150
10000000                 2250
01000000                 2350
00100000                 2450
00010000                 2550
00001000                 2650
00000100                 2750
00000010                 2850
00000001                 2950
00000010                 3050
00000100                 3150
00001000                 3250
00010000                 3350
00100000                 3450
01000000                 3550
10000000                 3650
01000000                 3750
00100000                 3850
00010000                 3950
00001000                 4050
00000100                 4150
00000010                 4250
00000001                 4350
00000010                 4450
00000100                 4550
00001000                 4650
00010000                 4750
00100000                 4850
01000000                 4950
10000000                 5050
01000000                 5150
00100000                 5250
00010000                 5350
00001000                 5450
00000100                 5550
00000010                 5650
00000001                 5750
00000010                 5850
00000100                 5950
00001000                 6050
00010000                 6150
00100000                 6250
01000000                 6350
10000000                 6450
01000000                 6550
00100000                 6650
00010000                 6750
00001000                 6850
00000100                 6950
00000010                 7050
00000001                 7150
00000010                 7250
00000100                 7350
00001000                 7450
00010000                 7550
00100000                 7650
01000000                 7750
10000000                 7850
01000000                 7950
00100000                 8050
00010000                 8150
00001000                 8250
00000100                 8350
00000010                 8450
00000001                 8550
00000010                 8650
00000100                 8750
00001000                 8850
00010000                 8950
00100000                 9050
01000000                 9150
10000000                 9250
01000000                 9350
00100000                 9450
00010000                 9550
00001000                 9650
00000100                 9750
00000010                 9850
00000001                 9950
Exiting VeriLogger at simulation time 10000000
0 Errors, 0 Warnings
Compile time = 0.00100, Load time = 0.00100, Execution time = 0.07400

Normal exit

Zum "Veriloggen" habe ich unter Windows vlogcmd.exe (Verilogger) verwendet. In Wirklichkeit sieht so ein KnightRider-Lauflicht etwa so aus ;): http://www.youtube.com/watch?v=N17Y4VvpYpA

Erstes Semester Informatik auf der TU Graz geschafft (WS2011/12)

2011 war für mich wieder einmal eine mittelgroße Veränderung angesagt. Ich habe mich aus verschiedenen Gründen dazu entschlossen meinen Fulltimejob zu vierteln und hauptberuflich ein Studium der Informatik an der TU Graz zu beginnen. Die letzte Klausur ist nun schon wieder fast eine Woche her und nun habe ich Zeit gefunden ein bisschen Resümee zu ziehen.

Grundsätzlich muss ich sagen, dass Informatikstudium ist doch recht zeitintensiv auch wenn man Vorkenntnisse in der Programmierung hat und mathematisch nicht ganz daneben ist. Erschwerend kam dieses Semester sicher die Studien Eingangs und Orientierungs Phase (STEOP) dazu. Das ist quasi eine Art Aufnahmeprüfung während des Semesters die aus einer leichten allgemeinen Einführungs-LV und einer schwierigeren LV (meist mittels Multiplechoicetest geprüft) besteht. Der Multiplechoice den ich zu lösen hatte ist hier einsehbar. Zugegebenermaßen war der Test diesmal nicht besonders schwierig, allerdings ist der psychische Druck und die Minuspunkte bei Falschantworten nicht zu verachten. Glücklicherweise ist bei mir alles glatt gegeangen und konnte die STEOP sogar mit 1.0 abschließen :). Generell will ich die Sinnhaftigkeit der STEOP aber bezweifeln, darauf will ich hier jedoch nicht weiter eingehen.

Besonders lästig erscheint den meisten Studierenden die Mathematik-VU Analysis T1 Die Vorlesungen dafür sind seit einigen Jahren bereits um 08:15 angesetzt was vor allem für Leute die schon länger die Schulbank nicht gedrückt haben und ein Gleitzeitsystem genossen sehr störend empfunden wird. Bald wurde mir aber klar, dass der Besuch der Vorlesung meist wenig bringt und man durch diverse Videos im Internet effektiver lernt. Wöchentlich müssen für manche LVs wie eben auch Analysis T1 Beispiele online angekreuzt werden und ein Zufallsgenerator wählt dann Studierende zum Vorrechnen aus. Dieses System macht nicht gerade Spass, aber wer die Übungen gewissenhaft macht (bzw. gewissenhaft abschreibt ;)) braucht nicht mehr so viel für die Klausur lernen.

Lustiger waren für mich die Übungen zu Grundlagen der Informatik. Hier hatte man schon relativ früh ein recht schwieriges Problem mit einem liebevoll gestalteten Roboterprogrammiersystem zu lösen. Der berüchtigte Marvin-10 Neptunroboter musste aus einem komplexen Labyrinth sämtliche Diamanten einsammeln und wieder herausfinden. Für diese Aufgabe hatte man eigentlich auch mit Vorkenntnissen in der Programmierung nicht unbedingt große Vorteile gegenüber den anderen Studenten.

Weiters ist zu sagen, die TU Graz verfolgt eine Nulltoleranzpolitik gegenüber Plagiaten. Und das ist tatsächlich so wie einige Teilnehmer bei dieser Übung wohl leidvoll erfahren mussten. Generell finde ich das ganz ok, allerdings trauen sich einige Studenten dann schon untereinander oft nicht mehr über den Übungsstoff zu unterhalten, da niemand gerne Informationen weitergibt um dann eines Plagiats überführt zu werden. Es würde mich auch gar nicht wundern wenn sich früher oder später jemand bei mir über den oben gezeigten Screenshot beschwert. Man könnte ja schon Teile der Lösung sehen...

Viel habe ich auch über das universitäre System und Leben als Student im allgemeinen gelernt. So ist zum Beispiel jede LV mit einer gewissen Menge an ECTS bemessen. Wobei ein ECTS ungefähr 25 Arbeitsstunden sein sollten. Natürlich kann man den Aufwand nie genau abschätzen, dass weiß ich auch von meinem Job in der professionellen Softwareentwicklung. Erstaunt war ich allerdings wie weit die Schätzungen der TU Graz daneben liegen. Natürlich gleichen sich diese Fehlschätzungen in Summe teilweise aus (und jeder Mensch ist unterschiedlich), allerdings finde ich es nicht ganz ok wenn dieselbe LV in verschiedenen Studienrichtungen nicht gleich viel wert ist. Und auch der Stipendienstelle wird es wohl relativ egal sein, wenn man erklärt, dass man in Wirklichkeit viel mehr Aufwand hatte. Allgemein ist der Aufwand aber auf der TU Graz wohl zu nieder bemessen. Ich kann mir zum Beispiel beim besten Willen nicht vorstellen, dass man in 3*25 Stunden so perfekt in C-Programmierung ist wie es verlangt wird. Wenn man aber viel Eigeninteresse und Vorkenntnisse mitbringt ist es nicht so ein großes Problem (man tut es ja schließlich gerne) und das erwarten die Professoren wohl auch.
Erstaunt war ich auch über die große Offenheit und Hilfsbereitschaft der meisten Mitstudierenden. Man lernt schnell neue Leute kennen (oft auch gezwungenermaßen durch Gruppenübungen) und ich denke die meisten fanden die tolle Vernetzung über Facebook und Newsgroups recht nützlich. (E-Learning quasi ;)) Die Vorlesungen habe ich auch größtenteils aus sozialen Aspekten besucht und nicht um den großen Wissensgewinn zu erfahren.

Generell bereue ich den Schritt das Informatik-Studium zu beginnen nicht auch wenn es natürlich ein bisschen ein finanzieller Einschnitt ist. Aber da es in Österreich ja auch das Selbsterhalterstipendium gibt, komme ich mit ein bisschen arbeiten ganz gut über die Runden. Und die Ferien sind mir persönlich sehr viel wert, auch wenn es Phasen im Jahr gibt wo man als Student mehr als in einem 40 Stunden Job gefordert ist.
Mal sehen was das zweite Semester bringen wird. Vermutlich wird es mittelfristig nicht leichter werden. In der Regelstudienzeit werde ich aber höchstwahrscheinlich sowieso nicht fertig werden wenn ich noch nebenher arbeite. Man will ja schließlich nicht komplett vernerden und man lernt ja nicht nur auf der Uni.

Python: built in binary search

Despite it is quite easy to implement a binary search algorithm I was looking for a built in algorithm in python. I did not really find what I was looking for, but there is the bisect module. If you want to find out if an element already exits in a sorted list you can use bisect like this:

import bisect

def index(array,element):
    i=bisect.bisect_left(array,element)
    if i != len(array) and array[i]==element:
        return i
    return -1
    
array=[0,3,5,6,7,9]
print index(array,3)
print index(array,8)

Output:

1
-1

The function index() returns the index of an element or -1 if the element is not in the list.

YESSS Handyabzocke durch "fehlerhafte" Abrechnung

Der Mobilfunkanbieter yesss machte sich in den letzten Jahren in Österreich durch relativ günstige Prepaidtarife beliebt. In letzter Zeit fällt YESSS aber eher negativ auf.

Abzocke Nummer 1:
Man verwendet ein Datenpaket für 100MB/Monat Tarif 3€/Monat aktiviert durch ein SMS mit dem Inhalt "paket daten ein". Läuft das Prepaidguthaben aus verlängert sich das Datenpaket nach dem Wiederaufladen nicht. YESSS arbeitet dann so als hätte man den Befehl "paket daten aus" geschickt und verrechnet horrende Summen für wenige Kilobyte. Nach dem Wiederaufladen des Guthabens ist es innerhalb von Stunden im Regelfall weg.
Anmerkung: Auf diese Abzocke bin ich vor einigen Monaten reingefallen. YESSS hat nach meiner Beschwerde ihren Text auf ihrer Homepage ergänzt, mir allerdings kein Guthaben gutgeschrieben. Ich drückte nochmal ein Auge zu und blieb vorerst treuer Yesss-Kunde.

Abzocke Nummer 2:
Man verbraucht mehr als 100MB/Monat. Auch hier verlängert sich das Datenpaket nicht und es werden wieder sehr hohe Summen für wenige Daten verlangt.
Anmerkung:
Auf yesss.at hat man als Yesss-Kunde Einsicht in die verbrauchten Daten und verrechneten Gebühren. Nach dieser Auflistung habe ich niemals mehr als 100MB verbraucht. Das Guthaben war in windeseile weg. Allerdings stimmten weder die verbrauchten Daten noch die verrechneten Gebühren. Nach meinen Beschwerden kam immer wieder die Antwort, dass ihre Abrechnung von Technikern überprüft wurde und alles korrekt sei. Heute (nach mehren Wochen) kam wieder eine Mail von yesss. Sie haben die Abrechnung überprüft und tatsächlich einen Fehler gefunden. Mir wurden lächerliche 4,24€ gutgeschrieben. Späte Einsicht ist zwar besser als keine, allerdings telefoniere ich nicht mehr mit YESSS und die Gutschrift hätte nach meinen Berechnungen auch ca. 20€ betragen müssen. Von Entschuldigungszahlungen einmal abgesehen.

Entweder ist die YESSS-Abrechnung also sehr buggy oder YESSS zockt die Kunden bewusst ab. Ich bin ja sicher nicht der Einzige dessen Guthaben immer wieder viel zu schnell abgezogen wurde.

Python pitfall: Default Parameters

Yesterday I wrote a simple graph algorithm and I was wondering why every node of the graph had the same edges. After a little time of print-debugging I found the reason: Default parameter values are evaluated when the function definition is executed. This means that the expression is evaluated once, when the function is defined, and that that same “pre-computed” value is used for each call. This is especially important to understand when a default parameter is a mutable object, such as a list or a dictionary: if the function modifies the object (e.g. by appending an item to a list), the default value is in effect modified. This is generally not what was intendedpython-docu

The problem was the following constructor:

def __init__(self,weight=0,edges=[]):
    self.weight=weight
    self.edges=edges

I always created nodes without the edges parameter. (Node(1234)) I added the nodes later and so every Node had the same reference of the edges list.

Confusing slice-operator in Python

The Python slice operator is convinent but in my opinion a little bit confusing. The slice operator is used to get an area from a sequence. As in C indeces start to count from zero in Python. If you want to get the first two characters from a string you can write string[0:2]. 0 is the start index and 2 the end index which is not included in the substring. But there is a python feature which allows you to replace an area of a list. list[0:1]=[1,2] Here the end index is included...

Edit:
Ok, the slice operator at the list replace example works the same. If the range of the list is too small for the values on the right side, the values will be inserted not replaced. If the range of the list is too big to replace it with the values on the right side, the list will be reduced.

>>> list
['x', 'y', 1, 2, 3]
>>> list[0:2]=['z','_']
>>> list
['z', '_', 1, 2, 3]
>>> list[0:2]=['z','_','f']
>>> list
['z', '_', 'f', 1, 2, 3]
>>> list[0:5]=['z','_','f']
>>> list
['z', '_', 'f', 3]
>>> list[0:2]=[0]
>>> list
[0, 'f', 3]
>>>

see interactive python shell:

>>> str="123456"
>>> str[1:1]
''
>>> str[1:0]
''
>>> str[1:2]
'2'
>>> str[-1]
'6'
>>> str[-2]
'5'
>>> str[2:]
'3456'
>>> list=[0,1,2,3]
>>> list
[0, 1, 2, 3]
>>> list
[0, 1, 2, 3]
>>> list
[0, 1, 2, 3]
>>> list[0:1]=[8,9]
>>> list
[8, 9, 1, 2, 3]
>>>

Interview mit Daniel Suarez (Autor von Daemon und Darknet)

Nachdem ich auch Darknet,die Fortsetzung von Daemon gelesen habe, fand ich auf youtube ein Interview mit dem genialen Autor Daniel Suarez.