Tips & Tricks

Hallo!

Ich habe das Thema geöffnet mit einer Hoffnung, dass mit der Zeit es eine Art von FAQ für alle, die sich mit PIC Mikrokontroller beschäftigen, seien wird.

Es soll eine Sammlung von kleinen sowohl Software als auch Hardware Ideeen sein, die aus Erfahrung vorkommt und hilfreich ist.

Für guten Anfang möchte ich als Beispiel zwei vorstellen:

Kopieren von eizelnem Bit vom Regiter1 (z.B. Bit 3) ins Register2 (z.B. Bit 5):

bcf Register2,5
btfsc Register1,3
bsf Register2,5

"Togglen" vom Timer1 um Prescaler auszulesen:

bsf Register,T0SE
bcf Register,T0SE

Wobei Register ist der, der TOSE Bit enthält z.B. OPTION_REG beim PIC16F84(A).

Ich bedanke mich im voraus für alle Posts, die (hoffentlich) dazu beitragen werden, dass die Sammlung wächst! :)

MfG

du musst dich bei der wiki neu anmelden, also du brauchst einen zusätzlichen wiki-Benutzername für das wiki (kann aber der gleiche sein wie hier im forum)

SEIDL.

Schaut mal dort (und Umgebung), ev.
http://www.talkingelectronics.com/te...ive_index.html
Da kann man einiges übernehmen (übersetzen), natürlich mit Quellen angabe (oder halt link)

Hallo PicNick!

Vielen Dank für den interesanten Link! :)

MfG

Hallo!

Die alle im ASM Programm ungebrauchten SFRs können als "normale" Register (GPR) verwendet werden. Wenn zum Beispiel Timer1 nicht benutzt wird, können seine Register TMR1H und TMR1L für Speicherung von Daten benutzt werden. Oder wenn keine indirekte Adressierung benutzt wird, kann für Daten Speicherung Register "FSR" angewendet werden, u.s w.

Es könnte aber gefährlich werden, wenn mehrere Programme gebindet sind. Deswegen muss es immer am Ende, beim volständigen Programm, geprüft werden, welche SFRs tatsächlich benutzt werden dürfen.

MfG

Hallo!

Wenn mann ein Menü auf dem Grafikdisplay erstellt, kann bestimmter Menüpunkt invers dargestellt werden, wenn mann vor der Ausgabe durch UP "DispOut" ein "_Finv" (invers) Flag setzt. Wenn es gesetzt ist, werden alle Bits des ausgegebenden Bytes im Register "R" mit "comf R" negiert, sonst wird der Befehl übersprungen und das Byte aus "R" normal ausgegeben. Nach der inversen Ausgabe wird das "_Finv" Flag gelöscht. Ein Beispielcode dazu:

Code:

---

#define        _Finv  Flags,0    ; Flag definieren
              ...............


DispOut        btfsc  _Finv        ; prüfen, ob _Finv gesetzt (invers) ist
              comf  R,1            ; wenn ja, alle bits im "R" negieren,
              .............        ; sonst normal ausgeben
                return

---

MfG

Hallo!

Wenn gleicher Pin durch Umschalten von TRISX Bit zum Eilesen einer Taste und Ausgabe auf ein Display benutzt werden sollte, muss seriel mit der Taste ein Widerstand geschaltet werden, da die Taste während der Ausgabe den Portpin an GND kurzschliessen kann.

Wenn interne pull-ups benutzt werden, entfällt der pull-up Widerstand 10k.

MfG

Code:

---



                VCC
                +
                |
                .-.
                | | 10k
                | |
                '-'
  zum PIC      |
  Portpin <-----+-----> zum Display
                |
                .-.
                | | 1k
                | |
                '-'
                |
              \  o
              \
                \.
                o
                |
                ===
                GND

---

Hallo!

Bei Entwicklungsboards, um Defekte von Ports zu vermeinden, sollte zwischen jedem Portpin und dem Anschluss von externer Hardware ein Widerstand 270 Ohm, der den Kurzlussstrom auf ca. 20 mA begrenzt, geschaltet werden.

MfG

Code:

---


  .-----.  ___  .---.
  |    |-|___|---o | Anschluss-
  |    |  270  |  | buchse für
  |    |.......| o | externe
  |    |  ___  |  | Hardware
  |    |-|___|---o |
  | PIC |  270  '---'
  |    |
  |    |
  |    |
  |    |
  |    |
  '-----'

---

Hallo!

Jeder PIC, welcher für HS oder XT Oszillator konfiguriert ist, funktioniert genauso, wenn anstatt eines Quarzes und zwei Kondensatoren, die auf Pins OSC1 und OSC2 angeschlossen sind, auf Pin OSC1 ein Rechteck aus einem Quarzoszillator zugeführt wird.

Die PICs aus der 18FXXX Familie funktionieren sogar wenn sie für HSPLL Oszillator konfiguriert sind. Die Frequenz ist dann gleich 4x Frequenz des Quarzoszillators.

Das ermöglichst ein Austausch eines Quarzes mit einem Quarzoszillator ohne Änderung der Konfiguration und die Option _EXT_OSC scheint überflüssig zu sein.

MfG

Hallo!

Aus meiner eigener Erfahrung zeigt es sich, dass wenn man nicht in der Konfiguration _BODEN_OFF einsetzt, fast alle Programme (vor allem die mit Displays) beim Einschalten der Betriebspannung besser (sicherer) starten.

MFG

Hallo!

Man kann Tasten auch ohne unnötigen Zeitverlust und Verzögerungsschleife abfragen (testen). Im Code habe ich ein PAD dafür skizziert. Bei dieser Methode geschieht aber nichts, wenn die Taste gedrückt gehalten wird, da der PIC unendlich aufs Loslassen wartet. Deswegen eignet sie sich nicht für alle Programme.

Der PIC prüft eine Taste und wenn sie nicht gedrückt ist, geht er sofort weiter/zurück. Wenn sie gedrückt wird, geht er in die endlose Schleife und wartet, bis sie los gelassen wird. Erst dann macht er was, z.B. erhöht ein Zähler usw.

Die Art der Tastenentprellung habe ich mehr praktisch als theoretisch entdeckt. Erst danach habe ich nachgedacht und festgestellt, dass es menschliche "Verzögerungsschleife" ab drücken bis zum Loslassen der Taste ausnutzt.

Ich habe es aus dem Tread entnommen und modifiziert:
https://www.roboternetz.de/phpBB2/ze...ght=entprellen


MfG

Code:

---

                  V
          Taste gedrückt ? N > weiter bzw."return"
                  J
                  V
                  |
                  |
                  |
    .----------->V
    |  Taste losgelassen ? J >.
    |            N            |
    |            V            |
    `------------´            |
                                V
                          Zähler erhöhen
                              usw.
                                V
                      weiter bzw."return"
  J = ja
  N = nein

---

Hallo!

Um sich schreiben von vielen unnötigen Zeichen im Quellcode für MASM zu ersparen, dürfen alle Hexzahlen, die mit dezimalen Ziffern (0 bis 9) anfangen ohne führenden 0x geschrieben werden. :)

Einige Beispiele: 2, 1D, 0A, 3F, 4B, 5D, 68, 7C, 8E, 95, usw.

Die Hexzahlen die mit Buchstaben (A bis F) anfangen müssen leider immer mit führenden 0x geschrieben werden. :(

Einige Beispiele: 0xA0, 0xBF, 0xC5, 0xDB, 0xE7, 0xFA, usw.

MfG

Hallo!

Wenn die zwei Pins, die zum Programmieren des PICs benötigt sind (PGC und PGD) frei sind oder an sie normal geöfnete Kontakte (z.B. Taster) angeschlossen sind und der VPP Pin eine Diode zwischen VCC und VPP hat, dann kann man den PIC ohne extra ICSP Anschlusses in einer fertiger Schaltung programmieren.

Dazu habe ich mir ein ICSP Anschlussadapter (siehe Foto) mit mini Klemprüfspitzen von Conrad gebaut, der dank dem DIP Schalter beim Arbeiten des PICs dran hängen darf. Das kann man auch bei SO PIC Typen im SMD Gehäuse verwenden. Der Adapter wird einfach an Kabel vom Brenner angeschlossen.

Seit dem werden ich in meinen Projekten, wenn möglich, diese zwei Pins entweder frei oder nur mit normal geöffneten Taster und ich kann jeden PIC ohne ICSP Anschluss umprogrammieren.

MfG

Zitat:

---

Zitat von PICture

Man kann Tasten auch ohne unnötigen Zeitverlust und Verzögerungsschleife abfragen (testen). [...]

---

Wie soll das von dir Skizzierte PAD funktionieren? Die Abfolge ein/aus/ein/aus solltest du auch bei einem prellenden Taster bekommen.
Oder verstehe ich da etwas grundlegend falsch?

mfG
Markus

Hallo markusj!

Sorry, aber ich verstehe leider Deine Frage nicht ganz. :)

Mein PAD sollte das Programmablauf bei Tastenentprellung zeigen, selbstverständlich für prellende Tasten.

MfG

Und ich verstehe nicht, wie ein Programm, welches sich an deinem PAD orientiert eine Tastenentprellung durchführen können soll.
Wenn du mit dem oben angegebenen Algorithmus auf den Eingangspin losgehst, bekommst du imho alles aber bestimmt keine Entprellung. Sobald der Eingangspin auf High geht, wartest du so lange bis er wieder Low geht und führst dann die asoziierte Aktion aus. Wenn die Taste prellt, rauscht du aber genauso durch dein PAD und führst im ungünstigsten Fall die Aktion mehrfach aus.

Oder sehe ich ein wichtiges Element nur nicht?

mfG
Markus

@PICture nette ideh muss ich mir mal merken da ich auf meinen smd schaltungen selten nen icsp drauf mache und vorsichtzalber ne diode geht ja noch kostet ja net viel

Ich hab dafür immer vorsichtshalber sonen smd lötjumper aber des ist auch immer ne frikkelei

Hallo!

@ theborg

Genauer gesagt sollte die VPP Pin (evtl. ohne Taster), so wie dort beschrieben:

https://www.roboternetz.de/wissen/in...undbeschaltung

beschaltet werden, dann funktioniert es immer.

Übrigens, das habe ich bisher nur mit PICs, die mit +5 V versorgt waren, ausprobiert. Wenn der PIC bei niedrigerer eigener Versorgungsspannung sich nicht programmieren lässt, müsste man die +5 V Spannung z.B. vom Brennen dem PIC zuführen. Bei einiger Schaltungen, die +5V beschädigen könnte, darf man das natürlich nicht machen.

@ markusj

Nicht alles auf der Welt kann und muß man verstehen.:)

Das habe ich mehrmals selber ausprobiert und es hat immer funktioniert. Die Schleifen können bei jedem Tastendruck mehrmals durchlaufen, aber das ist doch nicht wichtig. Geht es bei dir nicht?

MfG

Ich hab es noch nicht ausprobiert, das Problem ist meiner Ansicht nach aber: Wenn du die Schleifen bei einem Tastendruck mehrfach durchläufst, wird die eigentlich zu entprellende Aktion mehrfach ausgeführt, außer sie dauert länger wie das Prellen anhält.

mfg
Markus

Bei der ersten Schleife ist es praktisch unmöglich, dass ein Mensch die Taste innerhalb von ein paar ms, also vorm Ende des Prellens, loslassen könnte. In dieser Zeit kann sich die erste Schleife wiederholen. Hier wird die natürliche menschliche Trägheit ausgenutzt.

Wenn der PIC sich schon in der zweiten Schleife befindet und auf das Loslassen der Taste wartet, nach dem ersten Unterbrechen der Taste wird er schon die Schleife verlassen egal ob die Taste noch weiter prellt. Er hat eben keine Möglichkeit in die erste Schleife zurückspringen.

Hoffentlich ist es jetzt schon klar. :)

MfG

Hallo!

Während der Entwicklung eines mit 3 Micro Akkus betriebenen Messgerätes mit einem Zeichendisplay (Matrix) ohne Hintergrundbeleuchtung ist mir im Code skizzierte Schaltung eingefallen. Nach dem ausprobieren, habe ich sie angewendet, auf meiner Entwicklungsplatine aufgebaut und die Kontrastspannung an bisher freien Pin des Hardwareanschlusses angeschlossen, weil ich mit verschiedenen PICs, Displays und Versorgungsspannungen arbeite.

Kurzbeschreibung:

Der ICL7660 erzeugt die nötige negative -VCC Spannung, die bei geringer Strombelastung, wahrscheinlich für konkrete Anwendung auch als auf CLKOUT hängende Ladungspumpe aus zwei Dioden und zwei Kondensatoren realisiert werden könnte.

Ich habe auf meiner Entwicklungsplatine den ICL7660 benutzt um von einer Taktfrequenz des PICs unabhängig zu sein. Das Display hat zwischen Konrastpin und VCC fast gleiche durch die Zenerdiode Dz stabilisierte Spannung. Für 5 V Displays ist es 4,7 V und für andere Displays, die z.B. negative Kontrastspannung brauchen, muss die Spannung der Dz angepasst werden.

Der Widerstand R, wenn nötig, sollte evenuell für jedes Display berechnet/ermittelt werden, mein Display hat Stromverbrauch um 1 mA. Für grösseren Stromverbrauch des Displays muss der Widerstand R natürlich kleiner werden. Bei höchster VCC wird mit dem R der maximale gewünschte Kontrast eingestellt.

Das Display, ausser Kontrastpin, wird unverändert Beschaltet und seine Ansteuerung vom PIC wird nicht beeinflüsst. Ich habe es mit dem PIC16F630 getestet und es hat im VCC Bereich von 2 bis 5,5 V einwandfrei funktioniert, wobei unter 2,5V, wegen unausreichender negativer Spannung, der Kontrast schon schwächer war. Es sollte auch mit Grafikdisplays und anderen µCs funktionieren, aber bisher ich es nicht ausprobiert habe.

Übrigens, ich habe mir auch die negative Spannung -VCC vom ICL7660 (Pin 5) auf die hardware Anschlußbuchse meiner Entwicklungsplatine ausgeführt, die ich eventuell für OpAmps brauchen könnte. Wenn mehr Strom (bis zum 80 mA) benötigt wird (z.B. für eine Displaybeleuchtung), kan man anstatt des ICL7660 in den Sockel pinkompatiblen MAX660 einstecken.

MfG

Code:

---

                              .-----------------.
                              |                |
                              |  D i s p l a y  |
                              |                |
                              |                |
                              '-----------------'
                      VCC      | | |Kontrastpin
                      +      ===| |
    ICL7660 bzw. MAX660|      GND| |
          +--+        +----------+ |
          |+ |  .-u-. |          | |
    10µ === |  -|1 8|-+          z*|Dz
        /-\ +---|2 7|-          A |4V7
          |    +-|3 6|-  -VCC___  | |
          +----|-|4 5|-+----|*__|-+/
              | '---' |    R 510
              ===    \-/
              GND    === 10µ
                      +|
                      GND

---

Hallo!

Bei Erstellung von ASM Programmen, um mir das Kompilieren zu vereinfachen, verwende ich folgende Prozedur:

Zuerst erstelle ich mir in gleichem Verzeichnis, wo die Sammlung meiner Unter/Programme sich befindet, eine Textdatei (z.B. Test.txt) wo ich meinen einspaltigen PAD mit Pfeilen nach oben und unten schreibe/skizziere. In der Datei mache ich mir auch ganz oben ständig aktualisierte Liste aller Register, die in diesem Unter/Programm verwendet sind.

Wenn das PAD fertig ist, speichere ich diese Datei mit gleichem Namen als *.asm Datei (z.B. Test.asm) und erzetze alle PAD "Symbole" mit Befehlen für bestimmten PIC/Assemblerprogramm (z.B. für MPASM um die Register für ihm zu benennen).

Bei Änderungen mache ich sie gleich in beiden Dateien, damit sie am Ende wirklich aktuell sind. Letztendlich habe ich dann beide, wenn ich später etwas ändern muß. Dank dessen brauche ich ausser eventuellen Namen der UPs keine Kommentare im Programm schreiben, was seine Erstellung deutlich beschleinigt.

Mit diesem Prinzip in umgekehrter Richtung lassen sich auch "fremde" Programme leicht analisieren.

Als Beispiel habe ich ein UP aus meiner Sammlung für PIC18F252 in Code kopiert. Als einige PAD Symbole sind wegen Einfachheit von mir Mnemonics verwendet und die verwendete Register (Tmp und Tmp1) weggelassen, da sie schon in gemeinsamem Programm benannt sind. Bei PAD Erstellung darf man eben beliebige Symbole verwenden, die man selber am besten versteht.

Wahrscheinlich eignet sich die Prozedur auch für Hochsprachen.

MfG

Code:

---

WriteFlash      0x100 -> FSR0                        ; copy 1024 bytes from RAM (100h-500h)
                0 -> TBLPTRU                    ; in Flash (7C00h-7FFFh)
                0x7C -> W
                W ->        TBLPTRH
                0 ->        TBLPTRL
                tblrd*-
                0x80 -> W
                W ->        Tmp1
FlashProgL      8 -> W <------------------------+
                W ->        Tmp                    |
WriteFL    +-> POSTINC0 -> W                          |
            |        W ->        TABLAT                  |
            |        tblwt+*                        |
            |        dec        Tmp                    |
            |  Tmp = 0? j >----------+        |
            +----------< n            |        |
                1 ->        EECON1,EEPGD <-+        |
                0 ->        EECON1,CFGS            |
                0 ->        EECON1,WREN            |
                0 ->        INTCON,GIE              |
              +----------+                      |
              | standard |                      |
              +----------+                      |
                1 ->        EECON1,WR              |
                0 ->        PIR2,EEIF              |
                1 ->        INTCON,GIE              |
                dec        Tmp1                    |
                Tmp1 = 0? j >---------+        |
                          n >---------|---------+
                0 ->        EECON1,WREN <--+
                return


WriteFlash                lfsr        FSR0,0x100          ; copy FFh=1024d bytes from RAM (100h-500h)
                        clrf        TBLPTRU          ; in Flash (7C00h-7FFFh)
                        movlw        0x7C
                        movwf        TBLPTRH
                        clrf        TBLPTRL
                        tblrd*-
                        movlw        0x80
                        movwf        Tmp1
FlashProgL                movlw        8
                        movwf        Tmp
WriteFL                movf        POSTINC0,0
                        movwf        TABLAT
                        tblwt+*
                        decfsz        Tmp,1
                        bra        WriteFL
                        bsf        EECON1,EEPGD
                        bcf        EECON1,CFGS
                        bsf        EECON1,WREN
                        bcf        INTCON,GIE
                          +----------------+
                          | movlw        0x55  |
                          | movwf        EECON2 |<- standard
                          | movlw        0xAA  |
                          | movwf        EECON2 |
                          +----------------+
                        bsf        EECON1,WR
                        bcf        PIR2,EEIF
                        bsf        INTCON,GIE
                        decfsz        Tmp1,1
                        bra        FlashProgL
                        bcf        EECON1,WREN
                        return

---

Hallo!

Mit wachsender Erfahrung um Zeit zu sparen, baue ich immer öfter Schaltungen mit PICs gleich auf Platinen für fertige Geräte, die kein Display besitzen.

Um Programme mit Hilfe von PIC Miniterminal, wie auf dem Entwicklungsboard erstellen zu können bzw. ein Display während dieser Zeit zu benutzen, habe ich mir eine einfache Platine gebaut. Sie ist zwischen den Umschalter von ICSP, der bisher direkt mit dem Entwicklunsboard verbunden war, und der Platine mit PIC geschaltet. Der Schaltplan, wie es verbunden ist, habe ich im Code skizziert.

Auf der Skizze ist der Umschalter in der Position "Programmieren", weil das Netzteil ausgeschaltet ist. Man kann auch den Umschalter um 4 Stifte ergänzen und keine Zwischenplatine verwenden. Damit das Display auch für niedrige Versorgungsspannungen (z.B. 2 V) des PICs arbeitet, muss an sein VCC versorgende Spannung 5V zugeführt werden.

Die einzige Einschrenkung ist, dass der PIC Miniterminal immer mit PIC-Pins PGC und PGD, die für s Programmieren vorgesehen sind, verbunden ist. Meistens könnte man das bei der Entwicklung der Hardware berücksichtigen bzw. auf das verzichten und wie bisher mit dem Entwicklungsboard arbeiten.

Im unterem Code befinden sich zwei kurze Programme zum Prüfen der Hardware. Ich habe das Testprogramm für PIC16F870 und 2x16 Display geschrieben, weil ich mich gerade mit solchen beschäftige, aber es leicht für andere PICs und Displays umgeschrieben werden kann. Der "Minidisplay" muss in ein Programm, in dem das "PIC Miniterminal" als Display benutzt wird, eingebunden sein und "goto @Init" am Ende der Initialisierung vom Programm sein. Wenn das Programm schon fertig ist, kann man das entfernen.

Für Ausgabe in biliebigem Programm werden die UPs von "Minidisplay" benutzt. Damit sie nicht mit anderen UPs mit gleichen Namen kolidieren fangen sie alle mit "@" an. Die alle "@TmpX" Register können auch am oberem Ende des Speichers plaziert werden damit sie beim Erstellen des Programms nicht stören

MfG

Code:

---

                                PIC Miniterminal
                              .-----------------.
                              |.---------------.|
                              ||              ||
                              |'---------------'|
                              |  o    o    o  |
                              |                |
                              | GND _DT _CK VCC |
                              '-----------------'
                                  A  A  A  A
                  .--------.      |  |  |  |
        / VCC <-----o__    |      |  |  |  |      .-------------.
      |          |    --o---<<---|---|---|---|---<<--- VCC (PIC)  |
      |          | o      |      |  |  |  |      |            |
    B  |          |  \-------<<---|---|---|---+---<<--- Netzteil  |
      |  VPP <-----o__    |      |  |  |          |            |
    r  |          |    --o---<<---|---|---|-------<<--- VPP (PIC)  |
      |          | o      |      |  |  |          |            |
    e  |          |  \-------<<---|---|---|-------<<--- PIC?      |
      /  PGC <-----o__    |      |  |  |          |            |
    n \          |    --o---<<---|---|---|-------<<--- PGC (PIC)  |
      |          | o      |      |  |  |          |            |
    n  |          |  \-------<<---|---|---+-------<<--- PIC?      |
      |  PGD <-----o__    |      |  |              |            |
    e  |          |    --o---<<---|---|-----------<<--- PGD (PIC)  |
      |          | o      |      |  |              |            |
    r  |          |  \-------<<---|---+-----------<<--- PIC?      |
      |          |        |      |                  |            |
        \ GND <--------------<<---+---------------><--- GND (PIC)  |
                  '--------'                        '-------------'
                  Umschalter                        Platine mit PIC

---

Code:

---

; Testprogramm für PIC Miniterminal als externes 2-pin Display
        LIST      P=16F870
        include "P16F870.inc"
        __CONFIG        _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_ON & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _PWRTE_ON & _WDT_OFF & _HS_OSC
                org        0
                call        Init
Main                call        @Fst
                movlw        "P"
                call        @Char
                movlw        "I"
                call        @Char
                movlw        "C"
                call        @Char
                movlw        " "
                call        @Char
                movlw        "M"
                call        @Char
                movlw        "i"
                call        @Char
                movlw        "n"
                call        @Char
                movlw        "i"
                call        @Char
                movlw        "t"
                call        @Char
                movlw        "e"
                call        @Char
                movlw        "r"
                call        @Char
                movlw        "m"
                call        @Char
                movlw        "i"
                call        @Char
                movlw        "n"
                call        @Char
                movlw        "a"
                call        @Char
                movlw        "l"
                call        @Char
                call        @Snd
                movlw        "a"
                call        @Char
                movlw        "l"
                call        @Char
                movlw        "s"
                call        @Char
                movlw        " "
                call        @Char
                movlw        "D"
                call        @Char
                movlw        "i"
                call        @Char
                movlw        "s"
                call        @Char
                movlw        "p"
                call        @Char
                movlw        "l"
                call        @Char
                movlw        "a"
                call        @Char
                movlw        "y"
                call        @Char
                movlw        " "
                call        @Char
                movlw        "t"
                call        @Char
                movlw        "e"
                call        @Char
                movlw        "s"
                call        @Char
                movlw        "t"
                call        @Char
                sleep
Init                clrf        ADCON0                ; schalte ADC aus
                movlw        7                ; sperre ADC
                movwf        ADCON1                ; und definiere A0-A7 als digitale I/Os
                goto        @Init
                include        "Minidisplay.asm"
                end


;        "Minidisplay.asm" für PIC Miniterminal als externes 2-pin Display 
#define        @CK        PORTB,6
#define @DT        PORTB,7
@Tmp        equ        20
@Tmp1        equ        21
@Tmp2        equ        22       
@Tmp3        equ        23
@Fst                movlw        80                ; Adresse der 1. Zeile
                goto        @Cmd
@Snd                movlw        0xC0                ; Adresse der 2. Zeile
@Cmd                bcf        STATUS,C        ; Befehl an Display schicken
                goto        @Send
@Val                movwf        @Tmp1                ; Zahl (00-FF) an Display schicken
                swapf        @Tmp1,0
                call        @Num
                movf        @Tmp1,0
@Num                andlw        0F                ; Ziffer (0-F) an Display schicken
                movwf        @Tmp2               
                movlw        0A
                subwf        @Tmp2,0
                btfsc        STATUS,C
                addlw        7
                addlw        3A
@Char                bsf        STATUS,C
@Send                movwf        @Tmp2
                  movlw        9                ; Byte + RS aus @Tmp2 (9 Bits) an Display schicken
                movwf        @Tmp3
@Ser                bcf        @CK
                bcf        @DT
                btfsc        @Tmp2,7
                bsf        @DT
                bsf        @CK
                rlf        @Tmp2,1
                decfsz        @Tmp3,1
                goto        @Ser
                bcf        @DT                ; set
                bsf        @DT                ; Display Enable
                movlw        27       
                movwf        @Tmp3
                decfsz        @Tmp3,1
                goto        $-1
                bcf        @CK                ; clear
                bcf        @DT                ; Display
                bsf        @DT                ; Enable
                return
@Del                movlw        2
                movwf        @Tmp2
                clrf        @Tmp1
                clrf        @Tmp
                decfsz        @Tmp,1
                goto        $-1
                decfsz        @Tmp1,1
                goto        $-4
                decfsz        @Tmp2,1
                goto        $-7
                return
@Init                clrf        ADCON0                ; schalte ADC aus
                movlw        7                ; sperre ADC
                movwf        ADCON1                ; und definiere A0-A7 als digitale I/Os
                clrf        PORTB
                call        @Init1
                call        @Del
@Init1                bsf        STATUS,RP0
                movf        TRISB,0
                andlw        3F
                movwf        TRISB
                bcf        STATUS,RP0
                movlw        38                ; Display vom PIC Miniterminal initialisieren
                call        @Cmd
                movlw        0C
                call        @Cmd
                movlw        6
                call        @Cmd
                return
                end

---

@PICture: Ich finde diesen Beitrag wirklich Hammer.
Du gibst Deine Erkenntnisse jedem preis, damit er einfacher zurechtkommt. Meine Hochachtung!

(Leider nützt das mir persönlich nichts - AVR-Fan)

Hallo thewulf!

Danke für die Blumen! :)

Für mich ist es selbstverständlich und verliere damit nichts, wenn andere anstatt lange denken, das fertig und ausprobiert haben. Das wird mich immer freuen und Spass machen, anderen helfen zu können.

MfG

Das ist eine recht noble Einstellung.
Einziges Manko sind Deine ASCII-Art - Schaltpläne. Du erwähntest mal irgendwo, dass Du Dich nicht in ein CAD-Programm einarbeiten willst, oder so? Ich hatte sogar mal KURZ darüber nachgedacht, Dir ein eigenes, kleines abgespecktes zu schreiben, nur damit Du hier im Forum endlich Grafiken postest... :-)

Hallo!

Ich habe erfolglos ein Display mit größeren Zeichen für ein Messgerät gesucht und mir selber gewünschte mit 8 selbstdefinierten Zeichen auf einem 2x16 Zeichen erstellt und ausprobiert. Man könnte sich natürlich andere Zeichen selber definieren und der Code sollte nur als Beispiel dienen. Solche Zeichen lassen sich auch bei anderen µC anwenden.

MfG

Code:

---

;        Display Test im 4-bit Modus mit selbstdefinierten Zeichen (doppelte Zifferhöhe)
        LIST      P=16F84a
        include "P16F84a.inc"                  ; 4.000 MHz
        __CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
;                DB4        PORTB,0                ; Display Data-Bits
;                DB5        PORTB,1
;                DB6        PORTB,2
;                DB7        PORTB,3
#define        _RS        PORTB,4                        ; Display RS
#define        _E        PORTB,5                        ; Display Enable
#define        _Frs        Flags,0                        ; RS Flag
Tmp                equ        20       
Flags                equ        21
                org        0
                call        Init
Main                call        Fst
                movlw        0
                call        Char
                movlw        1
                call        Char
                movlw        3
                call        Char
                movlw        6
                call        Char
                movlw        4
                call        Char
                movlw        4
                call        Char
                movlw        1
                call        Char
                movlw        7
                call        Char
                movlw        5
                call        Char
                movlw        5
                call        Char
                movlw        1
                call        Char
                movlw        6
                call        Char
                movlw        4
                call        Char
                movlw        7
                call        Char
                movlw        5
                call        Char
                movlw        0
                call        Char
                call        Snd
                movlw        0
                call        Char
                movlw        4
                call        Char
                movlw        2
                call        Char
                movlw        0
                call        Char
                movlw        2
                call        Char
                movlw        6
                call        Char
                movlw        0
                call        Char
                movlw        6
                call        Char
                movlw        3
                call        Char
                movlw        6
                call        Char
                movlw        4
                call        Char
                movlw        0
                call        Char
                movlw        6
                call        Char
                movlw        6
                call        Char
                movlw        6
                call        Char
                movlw        0
                call        Char
                sleep
Fst                movlw        80                        ; Anfangsadresse der ersten Zeile
                goto        Cmd                       
Snd                movlw        0xC0                        ; Anfangsadresse der zweiten Zeile
Cmd                movwf        Tmp                        ; Befehl ins Tmp laden
                bcf        _Frs                        ; RS=0
                goto        Send
Char                movwf        Tmp                        ; Zeichen ins Tmp laden
                bsf        _Frs                        ; RS=1
Send                swapf        Tmp,0                        ; zuerst High Nibble (ab jetzt Low Nibble)
                andlw        0F                        ; (aktuelles Low Nibble ausblenden)
                movwf        PORTB                        ; an Port (Display) schicken
                btfsc        _Frs                        ; RS Flag ans Port kopieren
                bsf        _RS
                bsf        _E                        ; Enable erzeugen
                bcf        _E
                movf        Tmp,0                        ; Low Nibble
                andlw        0x0F                    ; (High Nibble ausblenden)
                movwf        PORTB                        ; an Port (Display) schicken
Enab            btfsc        _Frs                        ; RS Flag ans Port kopieren
                bsf        _RS
                bsf        _E                        ; Enable erzeugen
                bcf        _E
Del                movlw        10                        ; Verzögerung ca. 50µs
                movwf        Tmp
                decfsz        Tmp,1
                goto        $-1
                return
Init                clrf        PORTB                        ; PortB initialisieren
                bsf        STATUS,RP0              ; Bank 1
                clrf        TRISB                  ; alle Pins als Ausgänge
                bcf        STATUS,RP0              ; Bank 0
                bcf        _Frs
                movlw        2                        ; Display auf 4-bit umschalten und initialisieren
                movwf        PORTB
                call        Enab
                movlw        28                        ; 4 bit, 2 Zeilen, 5x7 Punkten
                call        Cmd
                movlw        0C                        ; display an, cursor aus, nicht blinken
                call        Cmd
                movlw        6                        ; incrementieren, nicht schieben
                call        Cmd
                movlw        40                        ; Zeichen selber definieren
                call        Cmd
                movlw        3                        ; 0.
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        1F                        ; 1.
                call        Char
                movlw        1F
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3                        ; 2.
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        1F
                call        Char
                movlw        1F
                call        Char
                movlw        1F                        ; 3.
                call        Char
                movlw        1F
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        3
                call        Char
                movlw        1F
                call        Char
                movlw        1F
                call        Char
                movlw        1F                        ; 4.
                call        Char
                movlw        1F
                call        Char
                movlw        18
                call        Char
                movlw        18
                call        Char
                movlw        18
                call        Char
                movlw        18
                call        Char
                movlw        1F
                call        Char
                movlw        1F
                call        Char
                movlw        1F                        ; 5.
                call        Char
                movlw        1F
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B                        ; 6.
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1F
                call        Char
                movlw        1F
                call        Char
                movlw        1F                        ; 7.
                call        Char
                movlw        1F
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1B
                call        Char
                movlw        1F
                call        Char
                movlw        1F
                call        Char
                return
                end

---

Wie wärs mit einem GLCD und einem großen Font?
Die Zeichen sehen Klasse aus - die Idee ist sehr gut!

Hallo thewulf00!

Ich habe mir eine Anwendung eines GLCD überlegt, aber solcher mit einem Kontroller der Grafik und Text kann (z.B. 128x128 mit T6963) war mi zu groß und bei einem kleinem (z.B. 32x128 ) müsste ich den ganzen Zeichensatz selber programmieren. Ausserdem brauche ich keine Grafik und so habe ich es sehr einfach realisiert.

MfG

Naja, man muss sie zwar selber Programmieren, aber sich nicht ausdenken. Ich benutze einen Java-Font-Creator. Der wurde geschrieben von dem Typ, der auch die Lib dafür schrieb. Da gibt man einfach an, welchen Font von seinem Rechner in welcher Größe und Style (Fett, Kursiv) und dann spukt der eine h-Datei aus, die man nur noch einbinden und die Konstante dem Fontinitialisator übergibt -fertig.

Wenn Du magst, bau ich Dir eine Schaltung, die immer das anliegende Byte auf einem GLCD anzeigt, und zwar riesig.

Herzlichen Dank für deine Bereitschaft. :)

Vor allem brauche ich sowas eigentlich nicht. Ausserdem habe ich bisher in meine Programme nichts "fremdes" eingebunden, weil ich es einfach nicht mag.

MfG

Ja, das kenne ich, aber das legst du ja dann nur an, wenn du mal einen Wert messen möchtest. :)

Hallo PICture, ich möchte auf eine böse Falle hinweisen.....

ich beziehe mich auf deinen Artikel vom Di 24-04-2007, 19:24

Du schriebst:
Die alle im ASM Programm ungebrauchten SFRs können als "normale" Register (GPR) ..... Oder wenn keine indirekte Adressierung benutzt wird, kann für Daten Speicherung Register "FSR" angewendet werden, u.s w.

Beim PIC18F252 zum Beispiel sollte man jedoch nicht die FSRxH Register benutzen, diese haben nur 4 Bits, da bin ich mal böse auf die Nase gefallen. Wollte einen 16 Bit Wert zwischenspeichern im FSR0L das Low Byte und im FSR0H das Highbyte. Das ging leider in Hose.
Hier hat man doch tatsächlich 4 Bits gespart. Nur als Hinweis...
Ich dachte es passt hier in diese Rubrik.
mfg. Siro

Hallo Siro!

Vielen Dank für deinen Beitrag. Es war mir immer klar, dass einziger Mensch nie alles ausprobieren kann, deswegen habe ich mit diesem Tread angefangen... :)

MfG

war ja auch kein Vorwurf oder ähnliches. Ich hoffe mal, daß es nicht falsch verstanden wurde. Hab aber über Jahre hinaus viele Erfahrungen mit den PICs gesammelt, die ich sicher nicht verheimlichen möchte. Und freue mich über Menschen, die tatsächlich so intensiv mit der Materie vertraut sind, wie ich es bei Dir mitbekommen habe. Hut ab... weiter so.
Ich helfe auch gern, sofern es mir möglich ist.

Ich habe es sicher richtig verstanden und frohe mich sehr, dass ich ab jetzt nicht allein bin... :)

MfG

hm wie wehre des mal ne art codeschnipsel Sammlung im wiki zu machen ich hab so dermaßen viele ansteuerungsrotinen die sich in den letzten jahren angesammelt haben.

Da ich alles komplett selber machen wird des immer mehr :P

Hallo theborg!

Du kannst es in dazu passenden "Codeschnipsel" von dem Artikel posten, wo die Authoren schon etwas veröffentlicht haben:

https://www.roboternetz.de/wissen/in.../PIC_Assembler

Oder du erstellst einen neuen Artikel, das hängt nur von dir ab. O:)

MfG

Hi ja hab nen neuen Artikel erstellt sonst wird es auch zu unübersichtlich ich weis auch wieder warum ich Wikis hasse scheiss syntax haben die und jedes wiki seine eigende :P

http://www.rn-wissen.de/index.php/PIC_ASM_Beispiele

Hallo!

Weil mir das auch schon passiert ist, dass aus unerklärlichem Grund der Wert von OSCCAL verloren gegangen ist, jadesmal wenn ich neue PICs mit internem Oszillator kaufe, lese ich den Wert vorm Brennen aus und notiere auf dem PIC Gehäuse. Somit kann ich den Wert (XX) immer wieder in Flasch brennen, indem ich ihn in den zwei letzten Zeilen der ".asm" Datei mit Programm mit "ORG 3FF" und "RETLW XX" schreibe.

MfG