Hallo,

für mein derzeitiges Projekt <Laser Projektor> war ich auf der Suche nach dem passenden Zeichensatz in 5x7. Dummerweise konnte ich nur einen finden, der für mein Design auf dem Kopf stand. Also gab es zwei Möglichkeiten:
den Laser Projektor auf den Kopf stellen -> nicht schön !
oder den Zeichensatz umwandeln.
Gesagt getan und schnell mal ein Programm dafür geschrieben ... (na, ja so schnell war es nicht getan, aber immer noch schneller wie selbst gedottet)
Falls jemand mal in eine ähnliche Situation kommen sollte, möchte ich das Programm hier gerne sharen. Der gedrehte Zeichensatz wird seriell ausgegeben und kann von dort kopiert werden. Formatierung ist so, dass er direkt in eigene Programme eingebunden werden kann. Mit kleinen Modifikationen kann das Programm auch genutzt werden, um Zeichensätze zu spiegeln.

Code:

#include <avr/pgmspace.h>

// The 7-bit ASCII character set... found in PCD8544 library
const unsigned char charset[][5] PROGMEM = {
  { 0x00, 0x00, 0x00, 0x00, 0x00 },  // 20 space
  { 0x00, 0x00, 0x5f, 0x00, 0x00 },  // 21 !
  { 0x00, 0x07, 0x00, 0x07, 0x00 },  // 22 "
  { 0x14, 0x7f, 0x14, 0x7f, 0x14 },  // 23 #
  { 0x24, 0x2a, 0x7f, 0x2a, 0x12 },  // 24 $
  { 0x23, 0x13, 0x08, 0x64, 0x62 },  // 25 %
  { 0x36, 0x49, 0x55, 0x22, 0x50 },  // 26 &
  { 0x00, 0x05, 0x03, 0x00, 0x00 },  // 27 '
  { 0x00, 0x1c, 0x22, 0x41, 0x00 },  // 28 (
  { 0x00, 0x41, 0x22, 0x1c, 0x00 },  // 29 )
  { 0x14, 0x08, 0x3e, 0x08, 0x14 },  // 2a *
  { 0x08, 0x08, 0x3e, 0x08, 0x08 },  // 2b +
  { 0x00, 0x50, 0x30, 0x00, 0x00 },  // 2c ,
  { 0x08, 0x08, 0x08, 0x08, 0x08 },  // 2d -
  { 0x00, 0x60, 0x60, 0x00, 0x00 },  // 2e .
  { 0x20, 0x10, 0x08, 0x04, 0x02 },  // 2f /
  { 0x3e, 0x51, 0x49, 0x45, 0x3e },  // 30 0
  { 0x00, 0x42, 0x7f, 0x40, 0x00 },  // 31 1
  { 0x42, 0x61, 0x51, 0x49, 0x46 },  // 32 2
  { 0x21, 0x41, 0x45, 0x4b, 0x31 },  // 33 3
  { 0x18, 0x14, 0x12, 0x7f, 0x10 },  // 34 4
  { 0x27, 0x45, 0x45, 0x45, 0x39 },  // 35 5
  { 0x3c, 0x4a, 0x49, 0x49, 0x30 },  // 36 6
  { 0x01, 0x71, 0x09, 0x05, 0x03 },  // 37 7
  { 0x36, 0x49, 0x49, 0x49, 0x36 },  // 38 8
  { 0x06, 0x49, 0x49, 0x29, 0x1e },  // 39 9
  { 0x00, 0x36, 0x36, 0x00, 0x00 },  // 3a :
  { 0x00, 0x56, 0x36, 0x00, 0x00 },  // 3b ;
  { 0x08, 0x14, 0x22, 0x41, 0x00 },  // 3c <
  { 0x14, 0x14, 0x14, 0x14, 0x14 },  // 3d =
  { 0x00, 0x41, 0x22, 0x14, 0x08 },  // 3e >
  { 0x02, 0x01, 0x51, 0x09, 0x06 },  // 3f ?
  { 0x32, 0x49, 0x79, 0x41, 0x3e },  // 40 @
  { 0x7e, 0x11, 0x11, 0x11, 0x7e },  // 41 A
  { 0x7f, 0x49, 0x49, 0x49, 0x36 },  // 42 B
  { 0x3e, 0x41, 0x41, 0x41, 0x22 },  // 43 C
  { 0x7f, 0x41, 0x41, 0x22, 0x1c },  // 44 D
  { 0x7f, 0x49, 0x49, 0x49, 0x41 },  // 45 E
  { 0x7f, 0x09, 0x09, 0x09, 0x01 },  // 46 F
  { 0x3e, 0x41, 0x49, 0x49, 0x7a },  // 47 G
  { 0x7f, 0x08, 0x08, 0x08, 0x7f },  // 48 H
  { 0x00, 0x41, 0x7f, 0x41, 0x00 },  // 49 I
  { 0x20, 0x40, 0x41, 0x3f, 0x01 },  // 4a J
  { 0x7f, 0x08, 0x14, 0x22, 0x41 },  // 4b K
  { 0x7f, 0x40, 0x40, 0x40, 0x40 },  // 4c L
  { 0x7f, 0x02, 0x0c, 0x02, 0x7f },  // 4d M
  { 0x7f, 0x04, 0x08, 0x10, 0x7f },  // 4e N
  { 0x3e, 0x41, 0x41, 0x41, 0x3e },  // 4f O
  { 0x7f, 0x09, 0x09, 0x09, 0x06 },  // 50 P
  { 0x3e, 0x41, 0x51, 0x21, 0x5e },  // 51 Q
  { 0x7f, 0x09, 0x19, 0x29, 0x46 },  // 52 R
  { 0x46, 0x49, 0x49, 0x49, 0x31 },  // 53 S
  { 0x01, 0x01, 0x7f, 0x01, 0x01 },  // 54 T
  { 0x3f, 0x40, 0x40, 0x40, 0x3f },  // 55 U
  { 0x1f, 0x20, 0x40, 0x20, 0x1f },  // 56 V
  { 0x3f, 0x40, 0x38, 0x40, 0x3f },  // 57 W
  { 0x63, 0x14, 0x08, 0x14, 0x63 },  // 58 X
  { 0x07, 0x08, 0x70, 0x08, 0x07 },  // 59 Y
  { 0x61, 0x51, 0x49, 0x45, 0x43 },  // 5a Z
  { 0x00, 0x7f, 0x41, 0x41, 0x00 },  // 5b [
  { 0x02, 0x04, 0x08, 0x10, 0x20 },  // 5c backslash
  { 0x00, 0x41, 0x41, 0x7f, 0x00 },  // 5d ]
  { 0x04, 0x02, 0x01, 0x02, 0x04 },  // 5e ^
  { 0x40, 0x40, 0x40, 0x40, 0x40 },  // 5f _
  { 0x00, 0x01, 0x02, 0x04, 0x00 },  // 60 `
  { 0x20, 0x54, 0x54, 0x54, 0x78 },  // 61 a
  { 0x7f, 0x48, 0x44, 0x44, 0x38 },  // 62 b
  { 0x38, 0x44, 0x44, 0x44, 0x20 },  // 63 c
  { 0x38, 0x44, 0x44, 0x48, 0x7f },  // 64 d
  { 0x38, 0x54, 0x54, 0x54, 0x18 },  // 65 e
  { 0x08, 0x7e, 0x09, 0x01, 0x02 },  // 66 f
  { 0x0c, 0x52, 0x52, 0x52, 0x3e },  // 67 g
  { 0x7f, 0x08, 0x04, 0x04, 0x78 },  // 68 h
  { 0x00, 0x44, 0x7d, 0x40, 0x00 },  // 69 i
  { 0x20, 0x40, 0x44, 0x3d, 0x00 },  // 6a j
  { 0x7f, 0x10, 0x28, 0x44, 0x00 },  // 6b k
  { 0x00, 0x41, 0x7f, 0x40, 0x00 },  // 6c l
  { 0x7c, 0x04, 0x18, 0x04, 0x78 },  // 6d m
  { 0x7c, 0x08, 0x04, 0x04, 0x78 },  // 6e n
  { 0x38, 0x44, 0x44, 0x44, 0x38 },  // 6f o
  { 0x7c, 0x14, 0x14, 0x14, 0x08 },  // 70 p
  { 0x08, 0x14, 0x14, 0x18, 0x7c },  // 71 q
  { 0x7c, 0x08, 0x04, 0x04, 0x08 },  // 72 r
  { 0x48, 0x54, 0x54, 0x54, 0x20 },  // 73 s
  { 0x04, 0x3f, 0x44, 0x40, 0x20 },  // 74 t
  { 0x3c, 0x40, 0x40, 0x20, 0x7c },  // 75 u
  { 0x1c, 0x20, 0x40, 0x20, 0x1c },  // 76 v
  { 0x3c, 0x40, 0x30, 0x40, 0x3c },  // 77 w
  { 0x44, 0x28, 0x10, 0x28, 0x44 },  // 78 x
  { 0x0c, 0x50, 0x50, 0x50, 0x3c },  // 79 y
  { 0x44, 0x64, 0x54, 0x4c, 0x44 },  // 7a z
  { 0x00, 0x08, 0x36, 0x41, 0x00 },  // 7b {
  { 0x00, 0x00, 0x7f, 0x00, 0x00 },  // 7c |
  { 0x00, 0x41, 0x36, 0x08, 0x00 },  // 7d }
  { 0x10, 0x08, 0x08, 0x10, 0x08 },  // 7e ~
  { 0x00, 0x00, 0x00, 0x00, 0x00 }   // 7f
};

void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.println("Prog startet");
  for (int i=0x20;i<=0x7f;i++) {
    Serial.print("  { ");
    for (int k=4;k>0;k--) {
      Serial.print("0x");
      char actchar = pgm_read_byte(&(charset[i-0x20][k]));
      byte actbyte = byte(actchar);
      byte mirror = mirrorbyte(actbyte);
      if (mirror>0xF) Serial.print(mirror,HEX);
      else {
        Serial.print("0");
        Serial.print(mirror,HEX);
      }
      Serial.print(", ");
    }
    char actchar = pgm_read_byte(&(charset[i-0x20][0]));
    byte actbyte = byte(actchar);
    byte mirror = mirrorbyte(actbyte);
    Serial.print("0x");
      if (mirror>0xF) Serial.print(mirror,HEX);
      else {
        Serial.print("0");
        Serial.print(mirror,HEX);
      }
    Serial.print(" },  // ");
    Serial.print(i,HEX);
    Serial.print(" ");
    Serial.write(i);
    Serial.print("\n");   
  }
delay(5000); 
}

byte mirrorbyte(byte actbyte) {     // special thanks to http://www.c-plusplus.de/forum/191237-full
  byte mirror = ((actbyte & 1) << 6)
            | ((actbyte & 2) << 4)
            | ((actbyte & 4) << 2)
            | ((actbyte & 8) << 0)
            | ((actbyte & 16) >> 2)
            | ((actbyte & 32) >> 4)
            | ((actbyte & 64) >> 6);
  return mirror;
}

Immerhin kann ich jetzt mit meinem Laser schon mal einzelne Zeichen darstellen. Hier mal 2 Fotos. Next step ist jetzt eine Laufschrift zu programmieren.
Die auf dem Foto zu sehende Ziffer ist ca. 7 cm hoch und die Projektionsfläche ca. 1,20 m entfernt.

Gruß
Reinhard

Hallo,
ntp-Dienste geben immer UTC zurück. Da wir momentan Sommerzeit haben ist die Differenz +2 Stunden (sonst +1 Stunde).

Hallo Barny,

was willst du denn überhaupt machen?
Wenn das nicht zu diesem Beitrag passt, dann mach besser ein neues Topic auf.

Gruß
Reinhard

Hi Dani,
diesen Link hättetst du senden sollen.
http://antwerpes.it/fotos-vom-physical-computing-lab-lot-it-2013/2013/04/
Da werden einige Projekte näher beschrieben.
@Huepfer
einfach mal überlegen, welche Sensoren und Aktoren angeboten werden sollen.
Töne erzeugen und per Piezo ausgeben ist sicher auch interessant. Mit Lichtschranken kann man auch nette Sachen machen.
Gruß
Reinhard

Hallo invisible09
diese Schaltung moduliert die LED mit 38kHz und lässt sich per Arduino Digitalausgang ein- und ausschalten.
Genau, die Dreiecke sind GND.
Gruß
Reinhard

Hallo Bernward
zur Datenübertragung benutzt du besser die VirtualWire http://www.pjrc.com/teensy/td_libs_VirtualWire.htmlBibliothek
Gruß
Reinhard

Hallo prinzolo,

es gibt immer wieder Features, wo man dachte, die gibt's gar nicht....  Hatte ich vorher noch nie gehört. Man lernt eben nie aus.
Wenn du den Teiler im Programm änderst musst du daran denken, dass alle zeit-relevanten Funktionen nicht mehr stimmen.

Gruß

Ein ATTiny85V funktioniert laut Datenblatt schon ab 1,8V und bei 1MHz internem Takt stabil.
Auf den selben Wert kann man auch die Brown-Out Detection einstellen. Die Brown-Out Detection hat eine Hysterese und sollte also für stabiles Anlaufen sorgen. (Ausprobiert hab ich das noch nicht)
Aber spendier deiner Schaltung einen großzuügig bemessenen Kondensator, damit die nicht bei jeder Wolke direkt aussteigt.

Power-On Reset und Brown-Out Detection sollten die richtigen Schlüsselwörter sein.
Schau mal was das Datenblatt dazu sagt.

Die Frage ist: wenn der Power-On Reset "gelaufen ist", der uC aber noch unterhalb der Schwelle des Brown-Out hängt - was passiert dann?

Ja, +3 Euro Versand. Bei meinem eBay Link ist der Versand für 5,99 inkl.

Hallo Helmuth,

-> http://fluuux.de/2012/10/arduino-temperatur-und-luftfeuchtigkeit-mit-dem-dht22-prufen/
-> http://learn.adafruit.com/dht
der DHT22 ist zwar etwas teurer als der DHT11, dafür aber genauer.
http://www.ebay.de/itm/DHT22-AM2302-digital-Sensor-Feuchtigkeit-Temperatur-Feuchte-Temperatur-Sensor-/290738840660?pt=Mess_Pr%C3%BCftechnik&hash=item43b162a454
Die 2-3 Euro mehr sollte es wert sein.

Gruß
Reinhard

avrdude -v -v -pattiny85 -cusbasp -Pusb  zeigt das an

Ist das die gesamte Ausgabe? Da müsste auch was bzgl des ATTiny ausgegeben werden.
Den User configuration file brauchst du nicht, lösch den mal wieder.
Vielleicht kann avrdude mit dem leeren File nichts anfangen.

Es gibt ein ActiveX -> http://www.parallax.com/tabid/393/Default.aspx
Das ist zwar mehr zur Datenerfassung gedacht bietet aber auch einige Möglichkeiten der Rückmeldung.
Das habe ich für mein Projekt Pulsmonitor http://dingfabrik.de/2012/11/19/ding-des-monats-112012-biofeedback-mit-arduino/ benutzt.

Hallo prinzolo,

eine gute und kurzgehaltene Erklärung der Fuses findest du hier http://www.ladyada.net/learn/avr/fuses.html.

Ich glaube, die Taktfrequenz konnte ich durch einen Befehl im Programm ändern.

Das hab ich noch nie gehört, würde mich wundern, wenn das geht.

Zum Fuses programmieren benötigt man wohl einen extra Programmer

Ja, das ist korrekt, aber du kannst den Arduino Uno als Programmer programmieren und dann mit dem Pro über die ISP Schnittstelle verbinden.
Wie das prinzipiell geht findest du hier: http://arduino.cc/en/Tutorial/ArduinoISP
Die notwendigen Eingänge MISO, MOSI, SCK sind auf dem Pro Mini herausgeführt. Wahrscheinlich solltest du dann aber den Pro mit 5V betreiben, damit das zum UNO passt.
Die Programmierung geht dann aus der Konsole mit dem Programm avrdude.
Aber Vorsicht !! Beim ändern der Fuses kann man auch Fehler machen und den Chip quasi unbrauchbar machen, geh da also nur ran, wenn du wirklich weißt, was du tust.

Ich glaube, dass du mehr erreichen kannst, wenn du den Pro möglichst lange und oft in den Sleep-Modus schickst und ihn nur für die Messung aufweckst. Vielleicht kannst du einen dicken Kondensator vor den Pro hängen, damit die Spannung über die Messzeit gepuffert wird. Suche mal nach "Goldcap". Das gleiche Pronzip wird für das Nachleuchten von Fahrradrücklichtern angewendet.
Gruß
Reinhard

Hallo prinzolo,
die Fuses sind nichtflüchtige Speicher im Microcontroller, in denen bestimmte Eigenschaften, so z.B. auch die Taktfrequenz (intern oder externer Takt) gespeichert werden.
Das Programm bzw der Compiler muss dann wiederum auch wissen, mit welchem Takt der Controller läuft. Um die Fuses zu setzen ist ein zweiter Programmer notwendig.
Man kann dafür auch einen Arduino mit einem speziellen Programm als Programmer nutzen.
Wenn du die Taktfrequenz umstellst, musst du einen neuen Eintrag in die Datei boards.txt eintragen.
Gruß
Reinhard