PIC 10F200, Anfänger

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
im Prinzip hatte ich früher viel mit Prozessoren programmiert, Z80, 
6809, bitslice2901 in Assembler, etwas C.

Schwierigkeiten machen mir die Handbücher und die Entwicklungsumgebung.

Laufende Programme neu crossassemblen oder compilieren nach 
Erweiterungen war nie ein Problem. Teilweise auf "mainframe SDS" mit 
Lochstreifeneingabe für das zu assemblierende Programm und Bändern für 
das Betriebsystem, bootstraploader mit Kippschaltern starten usw.

Jetzt möchte ich den PIC10F200 für ein einfache Zeitverzögerung 
eisnsetzen:

Beschreibung mit bestimmt falscher Syntax:

Kommentar, 2 asynchron unabhängige Eingänge sollen wenn beide mal 
Ereigniss waren einmal den Ablauf mit Ausgang 1 und Ausgang 2 auslösen,
Wenn beides passierte erst nach 3200ms wieder neu auf Ereigniss warten.

loop

und eingang 1 setze bit 1
und eingang 2 setze bit 2

bit 1 und bit 2 setze bit 3

undnicht bit 3 goto end

warte 2000ms  setze ausgang 1

warte 1000ms setze ausgang 2

warte 200ms

reset bit 1
reset bit 2
reset bit 3
reset ausgang 1
reset ausgang 2

end: goto loop


Wer kann mir helfen den PIC entsprechend zu versorgen, auch interne 
Taktgebung, Zeitparametrierung usw. Wie rufe ich Beblothekfunktionen auf 
um die Timer verfügbar zu habnen

[udo (Gast)]

In welcher Sprache willst du programmieren ?
Welcher Compiler willst du benutzen ?
Was kannst du ?

[Sebastian Hepp (Gast)]

Ich zweifel daran, dass es überhaupt Compiler für so kleine PICs gibt. 
Du müsstest das in Assembler programmieren. Und Bibliotheksfunktionen... 
vergiss es. Das schreibt sich am einfachsten und schnellsten selber.

Wie genau müssen die Timings stimmen? Eventuell reicht ja der interne 
4MHz Oszillator.

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
ich habe die MPLAB IDE 2.30 installiert, habe die Programmieradapter und 
auch c-compiler und Assemblerpakete von MPLAB.

Assembler oder C, im Prinzip egal.

Wie geschrieben die Logik einer CPU usw. ist mir klar, mir fehlt es an 
dem "garnieren" (  zuweisen ob I, O oder analog in oder out, wie heissen 
die Bits oder Bytes im RAM )  so daß der Prozessor rundlaufen würde mit 
dem comolierten oder assmblierten programm.

Fertige Programme auch strukturiert aufblasen, davor habe ich keine 
Angst.

Zeitfunktionen, dafür gibt es doch bestimmt makrobefehle, nicht das ich 
eine Schleife abwärtzähend programmieren müsste und die durchläufe 
zählen bis zerobit und jump if zero, gar mit Dopppelwort 32bit

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
klar der interne Takt wäre mehr als ausreichend genau, ob 2s, 1,5s, oder 
3s im Prinzip egal.

Biblotheken, auch nicht für Banalitäten wie Zeitverzögerung in 
Assemblerprogrammen?

Für den 6809 hatten wir vor 25 Jahren Biblotheken, also fertige 
Unterprogramme mit integer-mathematik sqr, sin, tan für word und 
doppelwort, sin und tan nominiert auf n/2exp16 oder n/2exp32  sin 
89,999° = 7FFF oder 7FFFFFFF

[Sebastian Hepp (Gast)]

>Für den 6809 hatten wir vor 25 Jahren Biblotheken, also fertige
>Unterprogramme mit integer-mathematik sqr, sin, tan...

Naja, der PIC10F200 ist der kleinste PIC, den es gibt. Der hat Platz für 
256 Instruktionen und auch nur 16 Byte RAM - mehr nicht.

Das Programm zu schreiben ist nicht schwer. Du kannst zum Beispiel GPIO 
einlesen, die Ausgänge mit AND verwerfen, dann den Bitcode für die 
Eingänge davon subtrahieren und testen, ob das Zero Flag gesetzt ist. 
Wenn nicht, dann springe an den Anfang. Falls doch, dann setze die 
Ausgänge entsprechend.

Es gibt aber noch einige Fallstricke: Zum Beispiel musst du den Reset 
(MasterClear) als Eingang konfigurieren. Dadurch kannst du den nur durch 
die Versorgungsspannung resetten.

[Bernd K. (Gast)]

http://microchip.wikidot.com/

mfg

[Sebastian Hepp (Gast)]

Um Energie zu sparen könntest du auch Wake-Up on Pin Change benutzen.

Ob Ein- oder Ausgang definierst du mit dem TRIS register. Lesen und 
Schreiben kannst du dann mit dem Port GPIO. Davor solltest du den 
Comparator deaktivieren. Die restlichen Dinge werden über die 
Konfigurations-Bits gesteuert. Diese werden beim Programmieren 
beschrieben.

Die ganzen Registernamen und -adressen findest du alle im Datenblatt.

[Michael K. (Gast)]

Sebastian Hepp schrieb:
> Ich zweifel daran, dass es überhaupt Compiler für so kleine PICs gibt.

Geht super.
http://www.ccsinfo.com/content.php?page=compilers

[Wolfgang S. (ws01)]

Sebastian Hepp schrieb:

> Ich zweifel daran, dass es überhaupt Compiler für so kleine PICs gibt.

Gibt es. Um die Kollegen zu Weihnachten mit einer Lichtbastelei zu 
erfreuen, habe ich letztes Jahr mit einer einzelnen APA 102 ein 
batteriebetriebenes "Regenbogenlicht" gebaut. Selbst die gekrippelte 
kostenlose Version des XC8 belegt für Umrechnung HSV -> RGB, Ansteuerung 
einer APA 102 per SPI usw. nur 366 Worte Code und 16 Bytes RAM.

Vom RAM her wuerde es also sogar in einen 10F200 hineinpassen. Da der 
202 z.B. bei Reichelt aber sogar billiger ist (50 Cent) als der 200 (58 
Cent), hatte ich aber nur ein paar von ersteren rumliegen.

> Du müsstest das in Assembler programmieren.

Kaum. Ich habe aufgrund des auf zwei Level beschraenkten Stacks ziemlich 
tricksen muessen was den Code ziemlich aufgeblaeht hat. Eine simple 
Ablaufsteuerung duerfe erheblich kompakter ausfallen.

> Und Bibliotheksfunktionen...
> vergiss es. Das schreibt sich am einfachsten und schnellsten selber.
>
> Wie genau müssen die Timings stimmen? Eventuell reicht ja der interne
> 4MHz Oszillator.

Die PIC sind mit dem internen Oszillator erstaunlich genau. Microchip 
verspricht unter normalen Bedingungen  +- 1%.

[Christian M. (Gast)]

Hallo,

ich programmiere meine 10F2xx mit:

http://www.oshonsoft.com/pic10.html

geht prima, mit der Demoversion kann man allerdings nur 10 
Programmstarte machen, aber hat für mein erstes Projekt längstens 
gereicht! Weil es einfach auf Anhieb lief!

Gruss Chregu

[Michael L. (michaelx)]

Immer diese Zweifler ...

Es gibt mehr als genug C-Compiler für die kleinen und kleinsten PICs.
Der CC5X wurde noch nicht genannt, hat bisher bestens funktioniert.

http://www.bknd.com/cc5x/index.shtml

[Peter D. (peda)]

Sebastian Hepp schrieb:
> Ich zweifel daran, dass es überhaupt Compiler für so kleine PICs gibt.

Zumindest für die pinkompatiblen ATtiny10 von Atmel gibt es das 
AVR-Studio mit C-Compiler.
Ich benutze auch für kleinste Projekte nur noch C, weil es viel bequemer 
ist.
Ich kann z.B. für Timer die Formel für den Comparewert für eine 
Zeitdauer bei einer bestimmten Taktfrequenz direkt hinschreiben und der 
Compiler rechnet es für mich aus. Oder ich nehme delay_us, delay_ms, 
wenn die Task eh nichts anderes tun muß.

Allerdings sind mir die SOT-23/6 zu winzig zum Löten und ich nehme 
lieber die SO-8 (ATtiny25).

[WehOhWeh (Gast)]

Doch, den 10F200 kann man in C programmieren. Der wird in MPLABx 
unterstützt. Als Compiler geht der XC8.
Möglicherweise braucht man einen Debug-Header, aber da kann dir das 
Manual mehr sagen.

Ob das was gescheites wird, weiß ich aber nicht. Aber eine simple 
Zeitverzögerung sollte man doch hinbekommen.

Ich würde dazu nicht einmal einen Timer nehmen, sondern einfach diese 
delay() makros.

Dann sind das wenige Zeilen.

PS:
Ich persönlich würde mindestens den 10F320 empfehlen, der ist moderner 
und hat auch nur 6 Haxen.

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
in meiner Unwissenheit habe ich schon ein paar 10F200 gekauft.

Ich wiederhole meine Bitte nochmals
was muß im C-Programm ( oder Assembler ) am Programmanfang gesetzt 
werden

für internen Takt,
watchtdog aus ( daß der stören kann las ich ).
2 Pin als Eingang, welche wie?  pullup,pulldown intern, extern?
2 Pin als Ausgang, welche wie?  pullup,pulldown intern, extern?
Timergrundfunktionen um den
Befehl "delay mit ungefähr Millisekunden anweden zu können 20% mehr oder 
weniger wären egal .


Die Assmbler- oder C-Programmstruktur der Anwendug als Schleife, die 
macht mir keine Schwierigkeiten.

Grüsse

[udo (Gast)]

Siehe Datenblatt.
Da findest du alles.
Sogar Beispiele.

[Michael K. (Gast)]

Wolfgang S. schrieb:
> Die Assmbler- oder C-Programmstruktur der Anwendug als Schleife, die
> macht mir keine Schwierigkeiten.

Dann bin ich überzeugt das Du es schaffts die passenden Register und 
Bitmuster mit Hilfe des Datenblattes zu finden und zu setzen.

Geht sogar noch kompfortabler mit:
MPLAB XC8 C Compiler User's Guide
5.3.5 Configuration Bit Access

Ein wenig must Du Dich schon mit Toolchain und Device beschäftigen um 
weiterzukommen.

[Volker S. (vloki)]

Wolfgang S. schrieb:
> Ich wiederhole meine Bitte nochmals
> was muß im C-Programm ( oder Assembler ) am Programmanfang gesetzt
> werden

Für Assembler gibt es Templates im installationsordner von MPLABX
...\Microchip\MPLABX\v3.20\mpasmx\templates\Object\10F200TMPO.ASM

;**********************************************************************
;   This file is a basic code template for object module code         *
;   generation on the PIC10F200. This file contains the               *
;   basic code building blocks to build upon.                         *
;                                                                     *
;   Refer to the MPASM User's Guide for additional information on     *
;   features of the assembler and linker.                             *
;                                                                     *
;   Refer to the respective PIC data sheet for additional             *
;   information on the instruction set.                               *
;                                                                     *
;                                                                     *
;**********************************************************************
;                                                                     *
;    Filename:      xxx.asm                                           *
;    Date:                                                            *
;    File Version:                                                    *
;                                                                     *
;    Author:                                                          *
;    Company:                                                         *
;                                                                     * 
;**********************************************************************
;                                                                     *
;    Files required: P10F200.INC                                      *
;                                                                     *

;**********************************************************************
;                                                                     *
;    Notes:                                                           *
;                                                                     *
                                                                  *
;**********************************************************************

  list      p=10F200            ; list directive to define processor
  #include <p10F200.inc>        ; processor specific variable definitions

  __CONFIG   _MCLRE_ON & _CP_OFF & _WDT_OFF

; '__CONFIG' directive is used to embed configuration word within .asm file.
; The lables following the directive are located in the respective .inc file. 
; See respective data sheet for additional information on configuration word.


;***** VARIABLE DEFINITIONS
TEMP_VAR    UDATA
temp        RES     1             ;example variable definition



;**********************************************************************
RESET_VECTOR  CODE   0xFF       ; processor reset vector

; Internal RC calibration value is placed at location 0xFF by Microchip
; as a movlw k, where the k is a literal value.
  
MAIN  CODE    0x000
  movwf   OSCCAL            ; update register with factory cal value 


start  
  nop                       ; example code
  movlw   0xFF              ; example code
  movwf   temp              ; example code

; remaining code goes here


  END                       ; directive 'end of program'

C Code findet man meistens in den kleinen Entwicklungskits.
Für den 200er weiß ich jetzt keines, aber ich habe ein
PIC10F32x Development Board (AC103011)
Da gibt es dann auch ein kleines MPALBX Projekt für den XC8 dazu.
Selber habe ich aber Assembler benutzt.

PS: Wenn du nur "eine Handvoll" 200er gekauft hast und du nie große 
Stückzahlen haben wirst, dann leg die irgendwohin (Müll) und kauf dir 
10F320 oder 10F322

[Wolfgang S. (ws01)]

Wolfgang S. schrieb:

> in meiner Unwissenheit habe ich schon ein paar 10F200 gekauft.

Man kann das sportlich sehen und schauen, wie weit man damit kommt.

Wie viele hast Du denn gekauft und womit hast du vor, diese 10F200 zu 
programmieren aka "flashen"?

>
> Ich wiederhole meine Bitte nochmals
> was muß im C-Programm ( oder Assembler ) am Programmanfang gesetzt
> werden

Gegenvorschlag. Du schriebst, Du könntest "etwas C".  Dann liefere doch 
mal das C-Programm ohne den Programmanfang, statt dieser mehrdeutigen 
Beschreibung des Ablaufs im Anfangsposting. Ich ergänze das dann gerne 
um die für den 10F200 noch fehlenden Initialisierungen für den 
kostenlosen XC8-Compiler von Microchip und verrate Dir sogar, wieviel 
ROM und RAM der dafür benötigt.  Bedanke aber, daß der 10F200, wie ich 
bereits anmerkte, nur zwei Stacklevel beherrscht.

Hilfreich wäre auch ein Schaltplan und/oder eine Präzisierung, welche 
der Pins des 10F200 für die beiden Inputs und beiden Outputs verwendet 
werden sollen.

>
> für internen Takt,
> watchtdog aus ( daß der stören kann las ich ).
> 2 Pin als Eingang, welche wie?  pullup,pulldown intern, extern?

Wenn Du nicht weißt, was Du willst oder brauchst, sehe ich schwarz. Was 
soll denn konkret an die Eingänge bzw. Ausgänge angeschlossen werden?

> 2 Pin als Ausgang, welche wie?  pullup,pulldown intern, extern?
> Timergrundfunktionen um den
> Befehl "delay mit ungefähr Millisekunden anweden zu können 20% mehr oder
> weniger wären egal .

Das ist doch schon mal eine Aussage.  Der interne Oszillator des 10F200 
ist, wie ich bereits schrieb, unter vernünftigen Betriebsbedingungen ca 
1% genau.

>
>
> Die Assmbler- oder C-Programmstruktur der Anwendug als Schleife, die
> macht mir keine Schwierigkeiten.

Das wäre noch zu zeigen.  Wie gesagt, liefere die besagte Schleife als 
C-Schnipsel, dann kann man weitersehen.

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
so stelle ich mir das C-Programm für den 10F200 vor.

Gruß wolfgang

/* Automatische Zugkreuzung an einleisiger Strecke mit PIC 10F200.
Egal welcher Zug als erster im Bahnhof ist, erst wenn beide eingefahren 
sind gibt es freie Ausfahrten 5s später in 1,2s Abstand */

void setup() {
  pinMode(Pin4, OUTPUT);   // Ansteuerung Ausfahrtsignal 2
  pinMode(Pin3, OUTPUT);   // Ansteuerung Ausfahrtsignal 1
  pinMode(Pin2, INPUT);    // Zugerkennung 2
  pinMode(Pin1, INPUT);    // Zugerkennung 1
  int Zug1 = 0;            // Variabele1 merkt wenn Zug 1 angekommen
  int Zug2 = 0;            // Varaibele2 merkt wenn Zug 2 angekommen
  int Zug1u2 = 0;      // Varaibele3 merkt wenn beide Züge angekommen 
sind

}

// Schleife beginnt hier.
void loop() {

if (Pin1 == HIGH)
{ Zug1 == TRUE;    }
if (Pin2 == HIGH)
{ Zug2 == TRUE;    }
if (Zug1 && Zug2 == TRUE)
{ Zug1u2 == TRUE;  // Beide Züge sind im Bahnhof angekommen.
  delay(5000);     // warte 5s, solange sollen beide Züge stehen 
bleiben.
  digitalWrite(Pin4, HIGH); /* Ausfahrsignal 2 auf grün, nur Trigger, 
bleibt auf grün, Rotstellung erfolgt duch den Zug */
  delay(200);
  digitalWrite(Pin4, LOW); // Rücknahme Grünschaltimpuls Signal2
  delay(1000);
  digitalWrite(Pin3, HIGH); /* Ausfahrtsignal 1 auf grün, Zug 1 fährt 
1,2s nach Zug 2 ab. */
  delay(200);    /* 200ms für den Signaleinschaltpulse 1, es sind 
selbstahltende Relais */
  digitalWrite(Pin3, LOW); // Rücknahme Grünschaltimpuls Signal1
  digitalWrite(Zug1, FALSE);
  digitalWrite(Zug2, FALSE);
  digitalWrite(Zug1u2, FALSE);  // Rücksetzen der Merker
    }
}

[vloki (Gast)]

Sieht scheußlich aus - so Arduinostyle ;-)

Wozu sich den Pinzustand (Zugerkennung) nochmal irgendwo merken, und 
dann auch noch als int? Ganz oben war es doch noch ein Bit!


loop() heißt eigentlich main(). Das müsstests du als alter 
C-Programmierer doch schon mal irgendwo gesehen haben. Da steht bei 
einem uC dann meist so was wie

void main(void)
{
    init();
    while(1){
        ...
    }
}

[Volker S. (vloki)]

Wolfgang S. schrieb:
> void setup() {
>   pinMode(Pin4, OUTPUT);   // Ansteuerung Ausfahrtsignal 2
>   pinMode(Pin3, OUTPUT);   // Ansteuerung Ausfahrtsignal 1
>   pinMode(Pin2, INPUT);    // Zugerkennung 2
>   pinMode(Pin1, INPUT);    // Zugerkennung 1
>   int Zug1 = 0;            // Variabele1 merkt wenn Zug 1 angekommen
>   int Zug2 = 0;            // Varaibele2 merkt wenn Zug 2 angekommen
>   int Zug1u2 = 0;      // Varaibele3 merkt wenn beide Züge angekommen
> sind
>
> }

wäre dann init(). Angenommen du hättest einen 10F322 vieleicht ungefähr 
so

#define SIGNAL_1   LATAbits.LATA0
#define SIGNAL_2   LATAbits.LATA1
#define ZUG_1      PORTAbits.PORTA2
#define ...

void init(void)
{
    TRISAbits.TRISA0 = 0;   // Ausfahrtsignal -> Output
    TRISAbits.TRISA1 = 0;
    TRISAbits.TRISA2 = 1;   // Zugerkennung -> Input
    ...

}

void main(void)
{
    init();
    while(1){
        if(ZUG_1){
            ...
        }
        ...
    }
}

[Peter D. (peda)]

Wolfgang S. schrieb:
> so stelle ich mir das C-Programm für den 10F200 vor.

Wenn dieser Code wirklich von Dir wäre, warum hast Du dann keine 
ATtiny25 gekauft?
So sieht das doch arg abgekupfert aus.

[Wolfgang S. (ws01)]

Peter D. schrieb:
> Wolfgang S. schrieb:
>> so stelle ich mir das C-Programm für den 10F200 vor.
>
> Wenn dieser Code wirklich von Dir wäre, warum hast Du dann keine
> ATtiny25 gekauft?
> So sieht das doch arg abgekupfert aus.

Das stimmt. Da ich keine Arduinos benutze, ist mir das Idiom 
("DigitalWrite") nicht ins Auge gesprungen. Entsprechende Schnipsel 
findet man haufenweise im Web, z.B. hier
http://forum.arduino.cc/index.php?topic=145392.0

Anyway, da mich mir schon mal die Mühe gemacht habe und um zu zeigen, 
daß es relativ unaufwendig auch mit einem PIC10F200 geht, nachfolgend 
die 1:1-Umsetzung für die PIC10F20x. Wie man sieht, passt dergleichen 
drei mal rein.

/*  W.Strobl 4.2.2016. Simple Ablaufsteuerung,
    siehe https://www.mikrocontroller.net/topic/388907#4454480
    Vorgabe asis angepasst für Microchip PIC 10F202. Sollte unverändert auch mit dem
    PIC 10F200 laufen. 
    
F:\e\pic\eisenbahn>xc8 --chip=10F202 --outdir=eisenbahn --ASMLIST --opt=default,+asm,+asmfile,+debug eisenbahn.c
Microchip MPLAB XC8 C Compiler (Free Mode) V1.33
Part Support Version: 1.33 (A)
Copyright (C) 2014 Microchip Technology Inc.
License type: Node Configuration

(1273) Omniscient Code Generation not available in Free mode (warning)

Memory Summary:
    Program space        used    52h (    82) of   200h words   ( 16.0%)
    Data space           used     8h (     8) of    18h bytes   ( 33.3%)
    EEPROM space         None available
    Data stack space     used     0h (     0) of    10h bytes   (  0.0%)
    Configuration bits   used     1h (     1) of     1h word    (100.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)    
    
resp.

F:\e\pic\eisenbahn>xc8 --chip=10F200 --outdir=eisenbahn --ASMLIST --opt=default,+asm,+asmfile,+debug eisenbahn.c
Microchip MPLAB XC8 C Compiler (Free Mode) V1.33
Part Support Version: 1.33 (A)
Copyright (C) 2014 Microchip Technology Inc.
License type: Node Configuration

(1273) Omniscient Code Generation not available in Free mode (warning)

Memory Summary:
    Program space        used    52h (    82) of   100h words   ( 32.0%)
    Data space           used     8h (     8) of    10h bytes   ( 50.0%)
    EEPROM space         None available
    Data stack space     used     0h (     0) of     8h bytes   (  0.0%)
    Configuration bits   used     1h (     1) of     1h word    (100.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)
   
*/

#include <xc.h>         /* XC8 General Include File */

#define SYS_FREQ        4000000L
#define _XTAL_FREQ      4000000
#define FCY             SYS_FREQ/4

// CONFIG1
#pragma config WDTE = OFF       // Watchdog Timer (WDT enabled)
#pragma config CP = OFF         // Code Protect (Code protection off)
#pragma config MCLRE = OFF      // Master Clear Enable (GP3/MCLR pin fuction is digital I/O, MCLR internally tied to VDD)

/* Automatische Zugkreuzung an einleisiger Strecke mit PIC 10F200
egal welcher Zug als erster im Bahnhof ist, erst wenn beide eingefahren 
sind gibt es freie Ausfahrten 5s später in 1,2s Abstand */

// Eine sprechendere Benennung der Pins wäre sinnvoll und weniger fehlerträchtig 

#define Pin1  GPIObits.GP2
#define Pin2  GPIObits.GP3
#define Pin3  GPIObits.GP0
#define Pin4  GPIObits.GP1

static struct
{
    unsigned Zug1: 1;
    unsigned Zug2: 1;
} state;

void setup(void)
{
    TRIS = 0b00001100;    // GP0 & GP1 Output, GP3, GP4 Input
    state.Zug1 = 0;           // Zug angekommen        
    state.Zug2 = 0;           // "
    Pin3 = 0;           // Ansteuerung Ausfahrsignal
    Pin4 = 0;           // "
}

void main(void) 
{
    setup();
   
    while (1)
    {
        if (Pin1)
        { 
            state.Zug1 = 1;
        }
        if (Pin2)
        { 
            state.Zug2 =1 ;
        }
       
        if (state.Zug1 && state.Zug2)
        { 
            __delay_ms(5000);           // warte 5s, solange sollen beide Züge stehen bleiben.
            Pin3 = 1;                   // Ausfahrsignal 2 auf grün, nur Trigger, bleibt auf grün, Rotstellung erfolgt duch den Zug
            __delay_ms(200);
            Pin3 = 0;                   // Rücknahme Grünschaltimpuls Signal2
            __delay_ms(1000);
            Pin4 = 1;                   // Ausfahrtsignal 1 auf grün, Zug 1 fährt 1,2s nach Zug 2 ab.
            __delay_ms(200);            // 200ms für den Signaleinschaltpulse 1, es sind selbstahltende Relais
            Pin4 = 0 ;                  // Rücknahme Grünschaltimpuls Signal1
            state.Zug1 = 0;
            state.Zug2 = 0;
        }
    }
}

[Volker S. (vloki)]

Peter D. schrieb:
> warum hast Du dann keine ATtiny25 gekauft?

Ist ja gut jetzt. Außer dir interressiert sich in diesem Thread 
anscheinend niemand dafür ;-)

[Wolfgang S. (ws01)]

Volker S. schrieb:
> Peter D. schrieb:
>> warum hast Du dann keine ATtiny25 gekauft?
>
> Ist ja gut jetzt. Außer dir interressiert sich in diesem Thread
> anscheinend niemand dafür ;-)

Warum sollte man 1,25 EUR für eine Trivialsteuerung ausgeben, wenn es 
auch 0,50 EUR tun?

Oder andersrum, wenn man noch 5 Cent drauflegt, bekommt man den PIC 
12F1840 der etwas besser ausgestattet ist. (Alle Preise Reichelt)

Woher kommt eigentlich dieses zwanghafte Verhalten auf Seiten der 
Atmel-Fans, den Leuten das Herumspielen mit den Microchip-Prozessoren 
ausreden zu wollen und auf jede auch noch so umpassende Gelegenheit 
anzuspringen?

[Michael K. (Gast)]

Wolfgang S. schrieb:
>>> warum hast Du dann keine ATtiny25 gekauft?

Peter D. schrieb:
> Wenn dieser Code wirklich von Dir wäre, warum hast Du dann keine
> ATtiny25 gekauft?
> So sieht das doch arg abgekupfert aus.

Wenn Du richtig zitierst dann erschliesst sich gleich eine ganz andere 
Aussage.
Der TE posted AVR Code will aber einen Pic einsetzen.

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

vloki schrieb:
> Sieht scheußlich aus - so Arduinostyle ;-)
>
> Wozu sich den Pinzustand (Zugerkennung) nochmal irgendwo merken, und
> dann auch noch als int? Ganz oben war es doch noch ein Bit!
>
Hallo vloki,
die zusätzlichen Bits als Merker weil die Zugerkennung eine 
Durchfahrtserkennung mit Reed-Kontakt durch einen Magnet im letzen Wagen 
ist.

Die Eingänge für beide Zugerkennungen dürften kaum je beide gleichzeitig 
highlevel haben.

Wichtig ist daß je Zyklus beide Ereignisse gewesen sein müssen.

Gruß

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Wolfgang S. schrieb:


Hallo ws01
danke, sehr hilfreich.

Wolfgang S

[Wolfgang S. (ws01)]

Michael K. schrieb:

> Der TE posted AVR Code will aber einen Pic einsetzen.

Quark. Wenn überhaupt, dann Arduino-Code. Weder muß man die ursprünglich 
vom Arduino-Projekt verwendeten AVR-Prozessoren auf diese Weise 
verwenden, noch ist inzwischen die Arduino-Plattform weiterhin auf die 
AVr-Prozessoren beschränkt. Siehe z.B. 
https://www.arduino.cc/en/ArduinoCertified/IntelGalileo

Im übrigen hat der OP ursprünglich nur Pseudocode gezeigt und das nach 
Arduino aussehende Stück erst auf meine Nachfrage hin nachgereicht.

Mir kommt zwar das Schweigen bezüglich doch naheliegender Fragen (etwa: 
wie willst Du die Dinger eigentlich flashen?) auch etwas merkwürdig vor, 
man sollte aber nicht gleich hinter jeder etwas unbeholfenen Frage eine 
Hausaufgabenschwindelei vermuten.  Daß jemand, der neu auf dem Gebiet 
ist, sich auf die Nachfrage nach konkretem Code hin etwas aus dem Netz 
zusammenklickt, erscheint mir auch nicht ganz unplausibel.

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Wolfgang S. schrieb:
> Volker S. schrieb:
>> Peter D. schrieb:
>>> warum hast Du dann keine ATtiny25 gekauft?
>>
>> Ist ja gut jetzt. Außer dir interressiert sich in diesem Thread
>> anscheinend niemand dafür ;-)
>
> Warum sollte man 1,25 EUR für eine Trivialsteuerung ausgeben, wenn es
> auch 0,50 EUR tun?
>
> Oder andersrum, wenn man noch 5 Cent drauflegt, bekommt man den PIC
> 12F1840 der etwas besser ausgestattet ist. (Alle Preise Reichelt)
>
> Woher kommt eigentlich dieses zwanghafte Verhalten auf Seiten der
> Atmel-Fans, den Leuten das Herumspielen mit den Microchip-Prozessoren
> ausreden zu wollen und auf jede auch noch so umpassende Gelegenheit
> anzuspringen?


Hallo,
bitte nicht streiten, als Anfänger macht man Fehler, jetzt liegen aber 
hier einige 10F200 und die möchte ich als Ersatz für TTL-74xx oder 
CD40xx verwenden, programmieren statt NOR, NAND, XOR, JK-flip-lops 
verlöten und CD4020 für timer-Funktionen dazuverdrahten.

Gruß

[Wolfgang S. (ws01)]

Wolfgang S. ("stackpointer") schrieb:
> Wolfgang S. schrieb:
>
>
> Hallo ws01
> danke, sehr hilfreich.

Bitte. Wäre es Dir möglich, etwas mehr Kontext zu verraten, was Du nun 
genau mit diesen Informationen anfängst?

Zu "die zusätzlichen Bits als Merker weil die Zugerkennung eine
Durchfahrtserkennung mit Reed-Kontakt durch einen Magnet im letzen Wagen
ist.

Die Eingänge für beide Zugerkennungen dürften kaum je beide gleichzeitig
highlevel haben.

Wichtig ist daß je Zyklus beide Ereignisse gewesen sein müssen."

eine Frage. Hast Du Unterschiede zwischen Deinem Codeschnipsel im 
Arduionostyle und meinem lauffähigen Programm bemerkt? Wenn ja, welche?

Außerdem würde mich immer noch interessieren, woher Du diese 
Arduiono-Librarycalls herhast und wie Du den PIC eigentlich flashen 
willst.

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Wolfgang S. schrieb:

> eine Frage. Hast Du Unterschiede zwischen Deinem Codeschnipsel im
> Arduionostyle und meinem lauffähigen Programm bemerkt? Wenn ja, welche?
>
> Außerdem würde mich immer noch interessieren, woher Du diese
> Arduiono-Librarycalls herhast und wie Du den PIC eigentlich flashen
> willst.


Hallo,

Unterschiede, neben der besseren Lesbarkeit fällt mir auf daß setup am 
Anfang von main keine Befehle enthält sondern als Unterprogramm 
aufgerufen wird und in jedem Durchlauf in spezielle Register abgelegt 
wird.

Jetzt wird mir auch der Unterschied zwischen Arduino und PIC klar, 
Arduinos haben ein Minibetriebssystem um die per USB ankommenden 
Programmcodes zu speichern und zu starten.

PIC macht das wohl durch die I/O-Pins und hardware-Spannungsfunktionen 
um in den flash-mous zu gelangen.  Also wohl eine Art Flashmemory mit 
serial I/O

Flashen, dafür kaufte ich mir PicKit3.

Danke

[Wolfgang S. (ws01)]

Wolfgang S. schrieb:

> Außerdem würde mich immer noch interessieren, woher Du diese
> Arduiono-Librarycalls herhast und wie Du den PIC eigentlich flashen
> willst.

Ooops. Sehe gerade "ich habe die MPLAB IDE 2.30 installiert, habe die 
Programmieradapter und auch c-compiler und Assemblerpakete von MPLAB.".
weiter oben.

Nun, die IDE mit der Versionsnummer heisst "MPLAB X" und aktuell ist da 
eher V 3.2. Und "Programmieradapter" gibt es eine ganze Reihe, genau so 
wie C-Compiler.  Wahrscheinlich habe ich das deswegen als "nicht 
informativ" überlesen.

Wenn Du von den wenigen, die sich hier freiwillig mit PIC beschäftigen, 
noch irgend eine weitere Unterstützung erwartest, solltest Du nicht 
derart sparsam mit konkreten Informationen umgehen. Wenn Du tatsächlich 
die eingangs geschilderten Erfahrungen hast, solltest Du wissen, wie 
sehr es auf Details ankommt.

Sehe gerade die nachfolgende Antwort:

> Unterschiede, neben der besseren Lesbarkeit fällt mir auf daß im Bereich
> setup keine Befehle nötig sind, das wird wohl vom  compiler und beim
> flashvorgang in spezielle Register abgelegt.

Lies für die Grundlagen das "Midrange-Manual" 
(http://ww1.microchip.com/downloads/en/DeviceDoc/33023a.pdf, keine 
Ahnung, ob das die aktuelle Version ist, ich hab das vor vielen Jahren 
mal durchgelesen und bin zu faul, hinterherzurecherchieren).

Darauf wollte ich aber nicht hinaus, nicht auf den Initalisierungs-Teil, 
sondern auf die Loop.


>
> Jetzt wird mir auch der Unterschied zwischen Arduino und PIC klar,
> Arduinos haben ein Minibetriebssystem um die per USB ankommenden
> Programmcodes zu speichern und zu starten.

Du vergleichst Äpfel und Birnen. Was genau, sagtest Du, hast Du früher 
programmiert?

Arduinos sind keine Prozessoren, sondern eine spezifische Anwendung 
bestimmter Prozessoren, zumeist bzw. anfänglich Atmel megaAVR.   Es hat 
aber auch Versuche gegeben, Arduino-Systeme mit Microchip-Prozessoren zu 
etablieren: 
http://www.microchip.com/pagehandler/en-us/chipkit-development-platform.html 
"Microchip and Digilent Launch First Arduino™ Compatible 32-bit 
Microcontroller Development Platform"

>
> PIC macht das wohl durch die I/O-Pins und hardware-Spannungsfunktionen
> um in den flash-mous zu gelangen.  Also wohl eine Art Flashmemory mit
> serial I/O

Alles über AVR ISP:

http://www.atmel.com/images/doc0943.pdf

Noch Fragen?

Was das Pickit 3 angeht, spricht etwas dagegen, mein Programm zu 
übersetzen, auf einen 10F200 zu schreiben und das ganze auf einem 
Steckbrett mal auszuprobieren? Mehr als fünf Minuten sollte das nicht 
kosten ...

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
und danke, wird in den nächsten Tagen aufgebaut und getestet.

Gruß

[Volker S. (vloki)]

Wolfgang S. schrieb:
> Hallo vloki,
> die zusätzlichen Bits als Merker weil die Zugerkennung eine
> Durchfahrtserkennung mit Reed-Kontakt durch einen Magnet im letzen Wagen
> ist.
Ja, habe ich mir dann auch gedacht ;-)



Wolfgang S. schrieb:
> Unterschiede, neben der besseren Lesbarkeit fällt mir auf daß setup am
> Anfang von main keine Befehle enthält sondern als Unterprogramm
> aufgerufen wird und in jedem Durchlauf in spezielle Register abgelegt
> wird.
Beim Arduino wird die Funktion Setup() auch aufgerufen. Das siehst du 
nur nicht. In beiden Fällen wird das nur ein einziges mal aufgerufen, 
weil in main() danach eine Endlosschleife kommt. Die Arduinoumgebung 
macht daraus (für dich unsichtbar) vermutlich so was wie:

void main(void){
    setup();
    while(1){
        loop();
    }
}

In der Main-Schleife wird also die Funktion Schleife aufgerufen ;-)

Mit Befehlen meinst du vermutlich die "Funktionen" wie z.B
    pinMode(Pin4, OUTPUT);
Da passiert genau das gleiche wie wenn man einfach das entsprechende Bit 
im Richtungsregister des uC setzt.
    TRISAbits.TRISA0 = 0;   // Ausfahrtsignal -> Output
Nur wird im ersten Fall eventuell noch ein Haufen unnötiger Overhead 
erzeugt, falls da wirklich eine Funktion aufgerufen werden sollte.
Möglicherweise machen die das aber auch über Makros...
Egal es geht in diesem Thread ja nicht um Arduino



Wolfgang S. schrieb:
> Jetzt wird mir auch der Unterschied zwischen Arduino und PIC klar,

Ganz unten auf der uC Ebene gibt es eigentlich so gut wie keinen 
Unterschied.
Der Arduino uC kommt meistens von Atmel ein PIC halt von Microchip. Wen 
juckt's.
Wie du richtig vermutet hast, ist auf einem Arduino uC ein Programm (du 
hast es Betriebssystem gennant), dass der Hersteller schon drauf 
gespielt hat, damit der User kein Programmiergerät braucht.
Das nennt man im Allgemeinen Bootloader. Kann man auf alle uC drauf 
machen, die in der Lage sind ihren eigenen Programmspeicher zu 
schreiben.
Bei einem 10F200 macht das keinen Sinn, weil dieser Bootloader den 
ganzen Programmspeicher füllen würde, aber schon der speichermäßig immer 
noch  winzige 10F32x kann das.
Heißt dann "Flash Program Memory with self read/write capability"
(brauchst du aber gar nicht, der 10F200 reicht erst mal völlig aus)

[Peter D. (peda)]

Wolfgang S. schrieb:
> #define Pin1  GPIObits.GP2
> #define Pin2  GPIObits.GP3
> #define Pin3  GPIObits.GP0
> #define Pin4  GPIObits.GP1

Auch bei einfachen Programmen sollte man beschreibende Namen vergeben, 
dann lassen sich die Programme viel besser lesen und viele Kommentare 
werden überflüssig.

[Volker S. (vloki)]

Peter D. schrieb:
> Auch bei einfachen Programmen sollte man beschreibende Namen vergeben...
Noch nicht ganz wach heute, Augen noch bisschen verklebt?


Wolfgang S. schrieb:
> nachfolgend die ***1:1-Umsetzung*** für die PIC10F20x...
> ...
> // Eine sprechendere Benennung der Pins wäre sinnvoll und weniger
> fehlerträchtig
>
> #define Pin1  GPIObits.GP2
> ...

[W.S. (Gast)]

Wolfgang S. schrieb:
> Hallo,
> bitte nicht streiten, als Anfänger macht man Fehler, jetzt liegen aber
> hier einige 10F200 und die möchte ich als Ersatz...

Nö, hat ja keiner was dagegen. Aber wenn ich das hier lese:

Wolfgang S. schrieb:
> Schwierigkeiten machen mir die Handbücher und die Entwicklungsumgebung.

..dann kommen mir so ein paar Zweifel auf. Wie willst du einen 
Mikrocontroller denn benutzen, wenn dir die Manuals Schwierigkeiten 
bereiten? Schließlich mußt du ja wissen, wie man damit was macht und 
dazu ist Lesen und Verstehen angesagt. Da kommst du nicht dran vorbei.

Was die IDE anbelangt, da wirst du bei den neueren PIC's eben auch durch 
müssen, weil die Zeiten der separaten PIC-Assembler und PIC-Brenner ein 
bissel vorbei ist und man zur Verwendung der PICkit2 und PICkit3 eben um 
die Software von Mikrochip nicht drumherum kommt.

Allerdings scheint mir der PIC10F200 mit seinem 12 Bit breiten 
Maschinenbefehlssatz durchaus den sehr viel älteren PIC's zu entsprechen 
und mit maximal 256 Programmschritten ist schlichtweg Assembler 
angesagt. Sollte bei einem 5 Beiner ja wohl kein wirkliches Problem 
darstellen. Da kann man dann doch noch nen älteren Standalone-Assembler 
benutzen (die Assembler-Syntax von MicroChip ist mMn. nämlich ein bissel 
grauselig).

Bitte keine Kommentare von C-Leuten dazu - das wäre albern.


Wolfgang S. schrieb:
> Wer kann mir helfen den PIC entsprechend zu versorgen, auch interne
> Taktgebung, Zeitparametrierung usw. Wie rufe ich Beblothekfunktionen auf
> um die Timer verfügbar zu habnen

Das Manual zum Controller ist dein Freund.
Und irgendwelche Bibliotheksfunktionen zum Einrichten der Timer brauchst 
du auch nicht. Die wenigen Hardware-Register, die dazu gehören, spricht 
man direkt an und sie sind auch gut dokumentiert.

Eines noch: Das, was du da als angezieltes Programm skizziert hast, ist 
mir nicht wirklich verständlich. Wenn überhaupt, dann schreib die 
logischen Anweisungen hin. Also erstmal so etwa:

Ausgang1 =  Eingang2 and (not EIngang3) xor Eingang1;

Der sinn solcher Notation ist es, daß du dir erstmal klar wirst darüber, 
was am Ende dabei herauskommen soll. Wie sich das in eine µC-Quelle 
übersetzt, kriegen wir später.

W.S.

[Manuel W. (multisync)]

@Wolfgang:

Du schreibst, dass du Pensionist bist. Kann es sein, dass dir die Infos 
in den Datenblättern nicht zugänglich sind, weil diese in englischer 
Sprache sind?

Sag's einfach geradeaus wenn's so ist. Ist ja kein Ding. Wenn ich ein 
paar Jahre älter wär und es in der Schule nicht gelernt hätte, könnt 
ich's wohl auch nicht.

[Wolfgang S. (ws01)]

W.S. schrieb:
> Wolfgang S. schrieb:
>> Hallo,
>> bitte nicht streiten, als Anfänger macht man Fehler, jetzt liegen aber
>> hier einige 10F200 und die möchte ich als Ersatz...
>
> Nö, hat ja keiner was dagegen. Aber wenn ich das hier lese:
>
> Wolfgang S. schrieb:
>> Schwierigkeiten machen mir die Handbücher und die Entwicklungsumgebung.
>
> ..dann kommen mir so ein paar Zweifel auf. Wie willst du einen
> Mikrocontroller denn benutzen, wenn dir die Manuals Schwierigkeiten
> bereiten? Schließlich mußt du ja wissen, wie man damit was macht und
> dazu ist Lesen und Verstehen angesagt. Da kommst du nicht dran vorbei.

Hier stimme ich uneingeschränkt zu. Man muß die Handbücher nicht 
auswendig lernen. Wer aber schon Schwierigkeiten hat bzw. keine 
Anstalten macht, fallweise und nach Bedarf einzelne Seiten oder Kapitel 
der Manuals bzw. Datenblätter zu studieren, sollte die die Finger vom, 
wie man so sagt, "nackten Metall" lassen.

>
> Was die IDE anbelangt, da wirst du bei den neueren PIC's eben auch durch
> müssen, weil die Zeiten der separaten PIC-Assembler und PIC-Brenner ein
> bissel vorbei ist und man zur Verwendung der PICkit2 und PICkit3 eben um
> die Software von Mikrochip nicht drumherum kommt.

Erstaunlich. Ich besitze sowohl ein originales PICkit2 als auch einen 
PICkit3-Clone (den von Olimex), und ziehe die .net-basierten 
Standalone-Programme dem plumpen IPE allemal vor.  Probleme beim 
Gebrauch unter Windows 8.1 (x64) sind mir bislang nicht aufgefallen. 
Und einen PIC10/12/16/18/24, der sich nicht zumindest mit dem PICkit3 
und der Standalone Application 
(http://ww1.microchip.com/downloads/en/DeviceDoc/PICkit3%200.2.0.3%20Setup.zip) 
programmieren ließe, hatte ich bislang noch nicht auf dem Schirm.   Und 
da die Quellen vorhanden sind, bestehen durchaus Chancen, sich auf die 
Funktionsfähigkeit der Software noch eine Weile verlassen zu können.

>
> Allerdings scheint mir der PIC10F200 mit seinem 12 Bit breiten
> Maschinenbefehlssatz durchaus den sehr viel älteren PIC's zu entsprechen

Soweit noch richtig.

> und mit maximal 256 Programmschritten ist schlichtweg Assembler
> angesagt.

Habe ich im vorliegenden Thread nicht bereits den Beweis erbracht, daß 
diese Behauptung unzutreffend ist? Die simple Zugsteuerung des OP läßt 
sich mit dem PIC10F200 mit links erledigen, das schreibt man einfach so 
runter.  Und hat noch viel Luft.

> Sollte bei einem 5 Beiner ja wohl kein wirkliches Problem
> darstellen. Da kann man dann doch noch nen älteren Standalone-Assembler
> benutzen (die Assembler-Syntax von MicroChip ist mMn. nämlich ein bissel
> grauselig).

Wozu sollte man?  Ich kann mir ohne Weiteres Aufgaben für einen 10F200 
denken oder konstruieren, die von der Programmierung auf 
Maschinensprachen- bzw. Assemblerniveau profitieren oder diesen nötig 
machen könnten.

Das konkrete Problem, das den Ausgangspunkt dieses Threads bildet, 
gehört aber sicher nicht dazu.

>
> Bitte keine Kommentare von C-Leuten dazu - das wäre albern.

Was bitte sind "C-Leute"?  Ein merkwürdiges Schubladendenken haben 
manche Leute ...

[Wolfgang S. (ws01)]

Volker S. schrieb:
> Peter D. schrieb:
>> Auch bei einfachen Programmen sollte man beschreibende Namen vergeben...
> Noch nicht ganz wach heute, Augen noch bisschen verklebt?
>
>
> Wolfgang S. schrieb:
>> nachfolgend die ***1:1-Umsetzung*** für die PIC10F20x...
>> ...
>> // Eine sprechendere Benennung der Pins wäre sinnvoll und weniger
>> fehlerträchtig
>>
>> #define Pin1  GPIObits.GP2
>> ...

Genau das. Danke.

Manchmal kann man nur den Kopf schütteln.

[Wolfgang S. (ws01)]

Volker S. schrieb:

> Bei einem 10F200 macht das keinen Sinn, weil dieser Bootloader den
> ganzen Programmspeicher füllen würde, aber schon der speichermäßig immer
> noch  winzige 10F32x kann das.

Wie das? Der 10F320 hat genau so viel bzw. genau so wenig Flash wie der 
10F200, 256 Worte. Der Unterschied ist also gerade nicht der vorhande 
Platz, sondern zu wenig Stack, zu wenig RAM und deswegen vermutlich auch 
die fehlende Fähigkeit der Selbstprogrammierbarkeit.

> Heißt dann "Flash Program Memory with self read/write capability"
> (brauchst du aber gar nicht, der 10F200 reicht erst mal völlig aus)

Aber danke für den Hinweis - ich habe den 10F320 zwar schon ein paar mal 
benutzt (z.B. für Spielereien wie die 
http://www.mystrobl.de/Plone/basteleien/10f320/stridulator hier und die: 
http://www.mystrobl.de/Plone/basteleien/10f320/duet.mp4/view), daß der 
ebenfalls seinen Flash beschreiben kann, war mir aber gar nicht 
aufgefallen.

Wäre mal eine nette Fingerübung, ein Bootloader für den 10F320. :-)
Viel Sinn hat das aber wohl nicht, außer man verbucht das unter 
"Demoszene".

[Michael L. (michaelx)]

W.S. schrieb:
> Allerdings scheint mir der PIC10F200 mit seinem 12 Bit breiten
> Maschinenbefehlssatz durchaus den sehr viel älteren PIC's zu entsprechen
> und mit maximal 256 Programmschritten ist schlichtweg Assembler
> angesagt. Sollte bei einem 5 Beiner ja wohl kein wirkliches Problem
> darstellen. Da kann man dann doch noch nen älteren Standalone-Assembler
> benutzen (die Assembler-Syntax von MicroChip ist mMn. nämlich ein bissel
> grauselig).
>
> Bitte keine Kommentare von C-Leuten dazu - das wäre albern.

Albern ist es, sich Kommentare zu verbitten.

Ich habe sowohl mit Assembler als auch C hinreichende Erfahrungen und 
kann guten Gewissens sagen:

C hat den Charme, dass man in einer gewohnten Sprache auf verschiedenen 
µC-Plattformen hardwarenah und assembler-like programmieren kann, ohne 
sich jedes Mal mit der spezifischen Syntax des jeweilgen Assemblers 
herumschlagen zu müssen. Der Maschinencode den man mit C-Code erzeugen, 
ist gar nicht so selten sehr nah am Optimum. Eine gewisse Vorstellung 
darüber, wie der Compiler funktioniert und was der µC kann, ist 
natürlich hilfreich. Wer z.B. Bitwerte in einem 8-Bit-µC in 16-Bit-Int 
speichert, macht definitiv was falsch. Beherzigt man solche Dinge, 
finden selbst erfahrene Assemblerprogrammierer meist nur wenig 
Möglichkeiten zur Verbesserung. Und wenn es doch mal auf Taktzyklen 
ankommt, kann man immer noch den Inline-Assembler verwenden.

Wer C natürlich nur im Zusammenhang mit sperrigen Bibliotheken kennt und 
sieht, der kommt zwangsläufig dem falschen Schluss, dass C für so kleine 
µC völlig ungeeignet sei.

Ich habe selbst schon ein Programm für den 10F200 geschrieben. In kaum 
mehr als der Hälfte des Programmspeichers habe ich den PIC 
initialisiert, und in einer Schleife ein Eingangssignal abgefragt, dazu 
einen Taster mit kurz, mittel und langem Tastendruck, eine LED und einen 
Pizo zur Ausgabe, sowie ein automatisches Power-Off bei Nichbenutzung. 
Und das alles bedurfte keiner Verrenkungen, einfach nur gerade herunter.

Also: C ist OK.

[Michael K. (Gast)]

W.S. schrieb:
> und mit maximal 256 Programmschritten ist schlichtweg Assembler
> angesagt.
>
> Bitte keine Kommentare von C-Leuten dazu - das wäre albern.

Okay, dann bin ich halt albern, aber es stimmt einfach nicht das man die 
nicht in C Programmieren kann.
Das geht nämlich ganz hervorragend ohne eine Zeile ASM.
Nicht nur weil es explizit in der XC8 Doku steht sonder weil ich das 
auch schon mehrfach gemacht habe.

[Thomas E. (picalic)]

Wolfgang S. schrieb:
> Wäre mal eine nette Fingerübung, ein Bootloader für den 10F320. :-)

Gibt's schon: Tiny Multi Bootloader 
(https://sourceforge.net/projects/tinypicbootload/)

[Wolfgang S. (ws01)]

Thomas E. schrieb:
> Wolfgang S. schrieb:
>> Wäre mal eine nette Fingerübung, ein Bootloader für den 10F320. :-)
>
> Gibt's schon: Tiny Multi Bootloader
> (https://sourceforge.net/projects/tinypicbootload/)

Interessant. Die da konkret abgelegte Fassung ist zwar für den doppelt 
so grossen 10F322, da der Boatloader aber nur 84 Worte belegt, müsste 
man das durch Ändern von "max_flash" von 0x200 auf 0x100 (und vermutlich 
ein paar andere technische Kleinigkeiten) unschwer auch für den 10F320 
anpassen können. Dann blieben immer noch 172 Worte für das nachzuladende 
Programm.

M.a.W. die weiter oben demonstrierte simple Ablaufsteuerung mit ihren 82 
Worten, geschrumpft bei Anpassung an den 10F320 auf 76 Worte, das ließe 
dann immer noch 96 Worte für irgendwelche Erweiterungen.

Faszinierend. Danke für den Hinweis!

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
an alle danke für die Unterstützung, zum löten/stecken/flashen der 
hardware bin ich noch nicht gekommen.

Heute morgen liess ich die simulation der MPLAB-IDE laufen, mir kam es 
vor daß die ca. 10 - 20 mal schneller lief.

Daher die Frage, ist der timer nicht richtig parametriert oder ist das 
eine Eigenart der IDE mit ihrem Simulator NICHT auch die Echtzeit des 
chips zu simulieren. Simulationszeit in Abhängigkeit der 
PC-Geschwindigkeit?

Grüsse an alle.

[Witkatz :. (wit)]

Wolfgang S. schrieb:
> ist der timer nicht richtig parametriert oder ist das
> eine Eigenart der IDE mit ihrem Simulator NICHT auch die Echtzeit des
> chips zu simulieren.

Ob der Simulator richtig parametriert ist, kann natürlich keiner wissen 
ausser dir ;-)
Die Simulation läuft viel schneller ab als in der Echtzeit. Für 
Zeitmessungen kannst du das Stopwatch benutzen. Um z.B. die Zeit 
zwischen zwei Eregnissen zu messen, kannst du z.B. Breakpoints setzen 
und das Stopwatch ablesen. Die gemessene Zeit stimmt mit der echten 
überein, wenn in den Projekteigenschaften die "Instruction execution 
frequency" des Simulators richtig eingestellt ist.

[Volker S. (vloki)]

Wolfgang S. schrieb:
> Volker S. schrieb:
>
>> Bei einem 10F200 macht das keinen Sinn, weil dieser Bootloader den
>> ganzen Programmspeicher füllen würde, aber schon der speichermäßig immer
>> noch  winzige 10F32x kann das.
>
> Wie das? Der 10F320 hat genau so viel bzw. genau so wenig Flash wie der
> 10F200, 256 Worte.

Ja, es ging mir nur um die Fähigkeit.
Ich habe mit den 10F20x ehrlich gesagt fast noch gar nichts gemacht, 
obwohl ich auch davon ein paar Typen rumliegen habe.
Da gab es mal so ein Bundle mit PICKIT2 und 10 verschiedenen PICs das 
auch noch billiger war als das nackte PICKIT2.
Als ich dann den 10F32x gesehen habe und ich was gaaaanz kleines bauen 
wollte, hat der mich schon mehr interressiert. Der 32x ist auch den 
PIC18 und den neueren PIC16 ähnlicher (mit LAT und so), mit denen ich 
mich mehr beschäftige.

[W.S. (Gast)]

Michael L. schrieb:
> Ich habe sowohl mit Assembler als auch C hinreichende Erfahrungen und
> kann guten Gewissens sagen:..

Ach, immer diese Fanboys, die es nicht lassen können - selbst dann, wenn 
es bereits zuvor ausdrücklich unerwünscht ist.

Nochmal im Klartext:
Wenn man eines der PICkit's benutzen will, dann muß man sich auch auf 
die Software von MicroChip einlassen. Mir ist jedenfalls keine 
Fremdsoftware bekannt, die mit den PICkit's problemlos umgeht.

Für ältere PIC's sieht das anders aus, da gibt es (ähemm.. gab es) ne 
Menge PIC-Programmierer unterschiedlichster Provenienz.

Ebenso gibt/gab es einiges an PIC-Assemblern, die zu dieser Generation 
von Tools passen - sowohl kommerzielle als auch nichtkommerzielle 
Assembler.

Dasselbe kann man jedoch von (vintage) C-Compilern nicht sagen. Da ist 
denn wohl wieder die IDE von MicroChip nebst deren Compilern und 
sonstigen Tools angesagt.

So. Das war meine Antwort auf die Bedenken des TO bezüglich Manuals und 
IDE, siehe dieses:

Wolfgang S. schrieb:
> Schwierigkeiten machen mir die Handbücher und die Entwicklungsumgebung.

Ist das nun endlich klar genug?

W.S.

[Scotty (Gast)]

Nun zumindest die IDEs kann man immer noch umgehen.
Ich verwende Notepad++ mit dem CC5X Compiler ubd zum Flashen die PICkit3 
Programmer Application v3.10 aus dem Microchip Archiv. Man muss dort 
lediglich eine aktuelle PK2DeviceFile.dat reinkopieren, dann klappt es 
auch mit aktuellen PICs wie 10F320, 12F1501, etc.

[Peter D. (peda)]

W.S. schrieb:
> Ist das nun endlich klar genug?

Es gibt hier im Forum einige bekannte Gesichter, für die C ein rotes 
Tuch ist und die jedesmal unbedingt ihren Senf dazugeben müssen.
Das kann man nicht ändern, daher einfach diese Postings ignorieren.
In einer Demokratie gehört es sich, daß jeder seine Meinung äußern kann, 
ohne zensiert zu werden.

[Volker S. (vloki)]

Peter D. schrieb:
> In einer Demokratie gehört es sich, daß jeder seine Meinung äußern kann,
> ohne zensiert zu werden.

Und wenn es voll am Thema vorbeigeht, darf man aber auch mal drauf 
hinweisen. Das ist miener Meinung nach dann keine Zensur und sollte auch 
nicht negativ bewertet werden (wer immer das war ;-)

[Volker S. (vloki)]

Scotty schrieb:
> Nun zumindest die IDEs kann man immer noch umgehen.
> Ich verwende Notepad++ mit dem CC5X Compiler ubd zum Flashen die PICkit3
> Programmer Application v3.10 aus dem Microchip Archiv. Man muss dort
> lediglich eine aktuelle PK2DeviceFile.dat reinkopieren, dann klappt es
> auch mit aktuellen PICs wie 10F320, 12F1501, etc.

Ich habe diese Spielereien inzwischen aufgegeben. Das kann man unseren 
Studierenden einfach nicht zumuten und es geht ja auch ganz gut mit den 
"regulären" Tools  (MPLABX, C18, XC8). Sogar auf mehreren 
Betriebssystemen...

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
nochmals ein Hilferuf!

Ich schaue mir vor dem Brennen/Flashen die Beschriftung auf dem 
Microchip-Programmieradapter aus dem Kit mit Pickkit 3 gerade genau an:

Dort ist für die 8-Pin-Gehäuse Vdd auf Pin 1, Vss auf Pin 8 beschriftet, 
von I/O RA0 bis I/O RA5 die Pins 7 bis Pin 2.

Es handelt sich um das board: Teilenummer: DM164130-9 - PICkit Low Pin 
Count Demo Board

Im Datenblatt bei Microchip:

http://pdf1.alldatasheet.com/datasheet-pdf/view/140263/MICROCHIP/PIC10F200.html

Auf seite 4 steht aber Pin 2 für Vdd, Pin 7 für Vss

Und auf dem Programmieradapter sieht es aus wie fest verdrahtet im 
layout der gedruckten Schaltung.


Gruß

[Volker S. (vloki)]

Wolfgang S. schrieb:
> Ich schaue mir vor dem Brennen/Flashen die Beschriftung auf dem
> Microchip-Programmieradapter aus dem Kit mit Pickkit 3 gerade genau an:

Das ist nicht gerade ein allgemeiner Programmieradapter und ist leider 
auch anscheinend nicht PIC10 kompatibel :-(

[Wolfgang S. (ws01)]

Volker S. schrieb:

> Als ich dann den 10F32x gesehen habe und ich was gaaaanz kleines bauen
> wollte, hat der mich schon mehr interressiert. Der 32x ist auch den
> PIC18 und den neueren PIC16 ähnlicher (mit LAT und so), mit denen ich
> mich mehr beschäftige.

Ich weiß. Anfang 2014 hatte Reichelt den 10LF320-IP für 39 Cent (incl. 
MWSt.) angeboten. Da habe ich dann gleich zwanzig Stück von in den 
Schrank gelegt, gut die Hälfte davon sind schon für alle möglichen 
Spielereien verbraucht. Rein interessehalber habe ich auch zwei 10F202 
mitbestellt, die kosteten damals wie heute 50 Cent. Weitere werde ich 
sicherlich nicht kaufen, außer mir fällt irgend eine absonderliche 
Spielerei mit sehr vielen einzelnen Prozessoren ein, bei der es auf den 
Preis pro Stück ankommt.

[Volker S. (vloki)]

Volker S. schrieb:
> Das ist nicht gerade ein allgemeiner Programmieradapter und ist leider
> auch anscheinend nicht PIC10 kompatibel :-(

Als Programieradapter würde ich eher so was bezeichnen, wie der Sockerl 
der hier 
http://www.aliexpress.com/item/Free-shipping-PICKIT3-Programmer-PIC-ICD2-PICKit-2-PICKIT-3-Programming-Adapter-Universal-Programmer-Seat/32372215543.html?spm=2114.40010308.4.223.WmgvHD 
dabei ist. Habe ich auch einen, aber noch nie ausprobiert. Der PK3 Klon 
funktioniert jedenfalls bisher bestens!

Wolfgang S. schrieb:
> Rein interessehalber habe ich auch zwei 10F202
> mitbestellt, die kosteten damals wie heute 50 Cent. Weitere werde ich
> sicherlich nicht kaufen...
Das ist bei Reichelt aber auch echt günstig (wenn man auf den Cent 
schaut). Bei den meisten Distriubtoren und Microchip Direct ist da für 
kleine Stückzahlen kein nennenswerter Unterschied zwischen 200er und den 
320er.

[Michael L. (michaelx)]

W.S. schrieb:
> Michael L. schrieb:
>> Ich habe sowohl mit Assembler als auch C hinreichende Erfahrungen und
>> kann guten Gewissens sagen:..
>
> Ach, immer diese Fanboys, die es nicht lassen können - selbst dann, wenn
> es bereits zuvor ausdrücklich unerwünscht ist.

Und weißt du was: Das geht mir ausdrücklich am A**** vorbei.

Ich hab schon bei deinem vorherigen Posting verstanden, dass du keine 
Ahnung hast, wie das im Internet funktioniert.

> Nochmal im Klartext:
> Wenn man eines der PICkit's benutzen will, dann muß man sich auch auf
> die Software von MicroChip einlassen. Mir ist jedenfalls keine
> Fremdsoftware bekannt, die mit den PICkit's problemlos umgeht.

Dein "Argument" gegen C ist also, dass man fürs PICkit SW von Mircochip 
bracht. Was für ein Stuss.

Aber bitte. Von mir aus kannst du weiter deine merkwürdigen Ansichten 
hier absondern, wenn du glaubst, dass sie dadurch wahrer würden.

> Dasselbe kann man jedoch von (vintage) C-Compilern nicht sagen. Da ist
> denn wohl wieder die IDE von MicroChip nebst deren Compilern und
> sonstigen Tools angesagt.

ACK. Du hast selbstredend keinen Schimmer.
Ich verrate dir mal was gaaanz Neues:

In MPLAB konnte man schon vor Jahren fremde C-Compiler (und auch 
Assembler ;-) ) einbinden, die nicht von Microchip sind, und man muss 
dazu nicht mal ein Meerschweinchen bei Vollmond schlachten. :-P

[Wolfgang S. (ws01)]

Wolfgang S. schrieb:
> Hallo,
> nochmals ein Hilferuf!
>
> Ich schaue mir vor dem Brennen/Flashen die Beschriftung auf dem
> Microchip-Programmieradapter aus dem Kit mit Pickkit 3 gerade genau an:

Sehr vernünftig.

>
> Dort ist für die 8-Pin-Gehäuse Vdd auf Pin 1, Vss auf Pin 8 beschriftet,
> von I/O RA0 bis I/O RA5 die Pins 7 bis Pin 2.

Für das Flashen ("In-Circuit Serial Programming", ICSP) der 
Midrange-Prozessoren sind neben den beiden Versorgungspins i.A. immer 
dieselben drei Pins zuständig: Vpp, ICSPDAT, ICSPCLK und die liegen 
geometrisch gesehen immer an der selben Stelle, bei einem DIP-8-Gehäuse 
sind Vdd und Vss Pin 1 und 8, Vpp ist Pin 4, ICSPDAT Pin 7 und ICSPCLK 
Pin 6.  Details in dem schon mal von mir erwähnten Midrange-Manual in 
Kapitel 28. Das ist zwar uralt und es gibt neuere Texte, Variationen, 
Low Voltage Programming etc. pp., aber das ist die Grundlage.

M.a.W, wenn man diese Pins entweder nur zum Flashen benutzt oder "in 
circuit" die an anderer Stelle ausführlich dokumentierten 
Entkopplungshinweise berücksichtigt, reicht ein fünfpoliger Stecker, der 
an immer die selben fünf Pins an der Stirnseite des Prozessors geht, für 
die unterschiedlichsten Prozessoren der Familie aus.

So weit, so gut.

Nun sind die 10Fxxx-Prozessoren aber zwar elektrisch und logisch 
durchaus kompatibel mit dem Verfahren, haben aber leider eine andere 
Pinbelegung.  Was sich Microchip dabei gedacht hat, weiß ich nicht, 
zumindest bei der Gehäuseform DIP8 hätte man m.E. problemlos bei der 
standardisierten Belegung bleiben können.

Bei den 10Fxxx liegt Vdd auf 2, Vss auf 7, Vpp auf 8, sowie ICSPDAT und 
CSPCLK auf 5 und 4.



>
> Es handelt sich um das board: Teilenummer: DM164130-9 - PICkit Low Pin
> Count Demo Board
>
> Im Datenblatt bei Microchip:
>
> http://pdf1.alldatasheet.com/datasheet-pdf/view/140263/MICROCHIP/PIC10F200.html
>
> Auf seite 4 steht aber Pin 2 für Vdd, Pin 7 für Vss
>
> Und auf dem Programmieradapter sieht es aus wie fest verdrahtet im
> layout der gedruckten Schaltung.

Also kannst Du diesen Adapter nur für die Standardbelegung verwenden.

Bau Dir also einen für 10Fxxx. Oder mach's wie ich, ich stecke kleine 
Testaufbauten einfach auf dem Steckbrett zusammen und programmiere in 
der Schaltung, ICSP halt, In-Circuit Serial Programming. :-)

Nach dem Test demontiere ich das dann irgenwann wieder. Die Abbildung 
zeigt ein Beispiel mit dem 10F202, wobei alles bis auf die 
ICSP-Verdrahtung schon wieder entfernt ist.

[Volker S. (vloki)]

Michael L. schrieb:
> Und weißt du was: Das geht mir ausdrücklich am A**** vorbei.
>
> Ich hab schon bei deinem vorherigen Posting verstanden, dass du keine
> Ahnung hast, wie das im Internet funktioniert.

Ääääähhhh, um was geht's eigenlich?

[Wolfgang S. (ws01)]

Ich schrieb:

> Nach dem Test demontiere ich das dann irgenwann wieder. Die Abbildung
> zeigt ein Beispiel mit dem 10F202, wobei alles bis auf die
> ICSP-Verdrahtung schon wieder entfernt ist.

Keine Ahnung, was da schiefgegangen ist, ich probiere es noch mal mit 
dem Bild ...

[Michael K. (Gast)]

W.S. schrieb:
> Ach, immer diese Fanboys, die es nicht lassen können - selbst dann, wenn
> es bereits zuvor ausdrücklich unerwünscht ist.

Du verrennst Dich da in etwas.
Erst stellt Du eine Behauptung auf die einfach nicht stimmt und dann ist 
von Dir ausdrücklich unerwünscht das man das richtigstellt auch wenn 
man es aus eigener Erfahrung besser weis.

Das ein Imperator W.S. her nicht so gut ankommt dürfte Dir klar sein.
Ich denke Du hast einen schlechten Tag erwischt.
Kehren wir also bitte zu einem vernünftigen Ton zurück.

[W.S. (Gast)]

Volker S. schrieb:
> Ääääähhhh, um was geht's eigenlich?

Eigentlich um was ganz Einfaches:

1. Der TO ist jemand, der in Assembler nicht unerfahren ist und offenbar 
davor auch keine Scheu hat, aber der mit seinen eignen Worten 
"Schwierigkeiten machen mir die Handbücher und die 
Entwicklungsumgebung." mit IDE's vielleicht im Allgemeinen, vielleicht 
aber auch nur mit der von Microchip seine Probleme hat.

2. Wenn er jedoch ein PICkit3 oder 2 benutzen will, wird er um die 
Installation und Verwendung vom Microchip's IDE nebst Brennprogramm wohl 
nicht herumkommen. Jedenfalls nicht leicht herumkommen.

3. Da der Chip aber offenbar den klassischen 12 Bit Code innehat, kann 
man es mit älteren (vintage) Tools in Assembler genausogut tun. In 
Assembler und nicht in C, weil es (ich rede von vor 20 Jahren!!!) damals 
keinen passablen Compiler gab, weswegen da Assembler angesagt ist, was 
dem TO wohl keine Schwierigkeiten bereiten dürfte. Dazu passen dann 
diverse andere Programmieradapter (David Tait, Sprut und Konsorten), die 
es in der Vergangenheit zuhauf gegeben hat.

4. Jetzt kommen C-Fanboys und labern hier herum, weil sie genau das 
nicht bleiben lassen können.

Wir reden hier nicht von einem ARM mit >128 K Flash, sondern von ganz 
winzig kleinen µC mit maximal 256 möglichen Programmschritten und 16 
Byte RAM  und 3 (DREI) I/O-Pins im SOT23-5. Dafür nen C-Compiler 
anwerfen? Ich halte das für voll daneben, quasi wieder mal mit Kanonen 
auf Spatzen.

W.S.

[Witkatz :. (wit)]

W.S. schrieb:
> Ich halte das für voll daneben,

https://youtu.be/uKtTdvXO_40

Bist du vielleicht so eine Art "Moby PIC"?

[Wolfgang S. (ws01)]

W.S. schrieb:
> Volker S. schrieb:
>> Ääääähhhh, um was geht's eigenlich?
>
> Eigentlich um was ganz Einfaches:
>
> 1. Der TO ist jemand, der in Assembler nicht unerfahren ist und offenbar
> davor auch keine Scheu hat, aber der mit seinen eignen Worten
> "Schwierigkeiten machen mir die Handbücher und die
> Entwicklungsumgebung." mit IDE's vielleicht im Allgemeinen, vielleicht
> aber auch nur mit der von Microchip seine Probleme hat.

So what. Er muß sie ja gar nicht benutzen.


> 2. Wenn er jedoch ein PICkit3 oder 2 benutzen will, wird er um die
> Installation und Verwendung vom Microchip's IDE nebst Brennprogramm wohl
> nicht herumkommen. Jedenfalls nicht leicht herumkommen.

Diese falsche Behauptung wird durch Wiederholung nicht besser.  Der TO 
möchte, ich zitiere, "den PIC10F200 für ein einfache Zeitverzögerung
einsetzen", es geht spezifisch um diesen. Er schrieb außerdem "... habe 
ich schon ein paar 10F200 gekauft" und erwähnte spezifisch C (und 
Assembler nur in Paranthese).

Die PIC10F20x kann man problemlso sowohl mit einem PICkit2 als auch 
einem PICkit3 programmieren, ohne dafür eine der beiden IDE (MPLAB bzw. 
MPLAB X) oder das zugehörige IPE ("Integrated Programming Environment") 
benutzen zu müssen.   Das habe ich mir nicht zusammengegoogelt, sondern 
das weiß ich aus eigener Erfahrung.

Daß Microchip die für die Pickit-Serie entwickelte, C#-basierte 
Standalone-Software nicht mehr weiterentwickelt, ist zwar bedauerlich, 
braucht einen aber nicht zu stören, so lange es um ältere Prozessoren 
geht oder solche, für die irgend jemand mit dem PICkit 2 Device Data 
File Editor ein passendes PK2DeviceFile.dat erzeugt hat.

[...]

> Wir reden hier nicht von einem ARM mit >128 K Flash, sondern von ganz
> winzig kleinen µC mit maximal 256 möglichen Programmschritten und 16
> Byte RAM  und 3 (DREI) I/O-Pins im SOT23-5. Dafür nen C-Compiler
> anwerfen? Ich halte das für voll daneben, quasi wieder mal mit Kanonen
> auf Spatzen.

Wir reden hier von einem Mikrocontroller, in den das in vom TO 
spezifizierte Programm, wenn man es einfach so in C herunterschreibt, 
drei mal hintereinander hineinpasst.  Selbst wenn man es mit dem 
gekrippelten kostenlosen XC8 von Microchip übersetzt.

Und das ist nicht dahergeschwätzt, quasi "voll daneben", sondern das 
habe ich weiter oben im Thread praktisch demonstriert.

Noch Fragen?


PS: Ich finde nicht, daß man sich irgendwem gegenüber reichtfertigen muß 
oder sollte, wenn man manche Sachen ganz oder teilweise mittels eines 
Assemblers angeht und finde die ensprechenden Pawlowschen Reflexe 
angesichts jedweder Erwähnung z.T. ziemlich überzogen.  Jedoch beginne 
ich langsam zu verstehen, woher diese Reflexe kommen ...

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

W.S. schrieb:

>
> Wir reden hier nicht von einem ARM mit >128 K Flash, sondern von ganz
> winzig kleinen µC mit maximal 256 möglichen Programmschritten und 16
> Byte RAM  und 3 (DREI) I/O-Pins im SOT23-5. Dafür nen C-Compiler
> anwerfen? Ich halte das für voll daneben, quasi wieder mal mit Kanonen
> auf Spatzen.
>


Hallo,
dann melde ich micht auch, C oder C++ ist gegenüber Assembler bequemer, 
für MEINE Anwendung im Hobbybereich ist das sonst ziemlich egal.

Ein Chip mit etwas mehr Programmflash ist nicht nenenswert teurer, und 
ein evtl. suboptimaler code des compilers spielt auch keine Rolle da bei 
meinem Anwendungen weit überwiegend auf Ereignisse, Eingänge oder 
Zeiten, gewartet wird.


Vor 30 Jahren war bei Werkezugmaschinenbahnsteuerungen mit Geometrie aus 
Kurven, Koordinatentransformationen in Echtzeit ( noch vor dem 
Coprozessor für die 68000-Motorola-CPU ) das anders. Da wurde genau 
abgewägt Tabelle und Interpolation oder Reihenentwicklung ähnlich des 
cordic-algorhitmus.

Jedes Bit war mit Vornamen bekannt.


C ist bequemer für den Einstieg, wer dagegen viele Projekte in Assembler 
mit der GLEICHEN CPU programmiert(e) hat(te) Biblotheken für nützliche 
subroutinen, z.B. auch timer.  Am Ede der Hauptroutine suborutinen für 
solche Funktionen als reentry abgespeichert, timer, hex to ascii, ln, 
sin usw..  Im Prinzip war das dann Anwendung einer eigenen "Hochsprache" 
bedingt.

[Wolfgang S. (ws01)]

Wolfgang S. schrieb:
> W.S. schrieb:
>
>>
>> Wir reden hier nicht von einem ARM mit >128 K Flash, sondern von ganz
>> winzig kleinen µC mit maximal 256 möglichen Programmschritten und 16
>> Byte RAM  und 3 (DREI) I/O-Pins im SOT23-5. Dafür nen C-Compiler
>> anwerfen? Ich halte das für voll daneben, quasi wieder mal mit Kanonen
>> auf Spatzen.

Btw., wo bekommt man denn diese Sonderausführung mit fünf Pins? 
Microchip baut die 10F200 mit 4 (in Worten "vier") I/O-Pins und schreibt 
im Datenblatt explizit "6-PIN SOT-23".


> Hallo,
> dann melde ich micht auch, C oder C++ ist gegenüber Assembler bequemer,
> für MEINE Anwendung im Hobbybereich ist das sonst ziemlich egal.
>
> Ein Chip mit etwas mehr Programmflash ist nicht nenenswert teurer, und
> ein evtl. suboptimaler code des compilers spielt auch keine Rolle da bei
> meinem Anwendungen weit überwiegend auf Ereignisse, Eingänge oder
> Zeiten, gewartet wird.

Bei den ganz kleinen Prozessoren ist das Ende der Fahnenstange schnell 
erreicht. Ich benutze gerne den 12F1840 in DIP-8 und bin schon mal daran 
gescheitert, daß es keine bzgl. Flash resp. RAM größere Version mit 
diesen Eigenschaften (i.e. Achtbeiner, DIP, 5V) gibt, jedenfalls keine, 
die Reichelt anbietet.

>
>
> Vor 30 Jahren war bei Werkezugmaschinenbahnsteuerungen mit Geometrie aus
> Kurven, Koordinatentransformationen in Echtzeit ( noch vor dem
> Coprozessor für die 68000-Motorola-CPU ) das anders. Da wurde genau
> abgewägt Tabelle und Interpolation oder Reihenentwicklung ähnlich des
> cordic-algorhitmus.
>
> Jedes Bit war mit Vornamen bekannt.
>
>
> C ist bequemer für den Einstieg, wer dagegen viele Projekte in Assembler
> mit der GLEICHEN CPU programmiert(e) hat(te) Biblotheken für nützliche
> subroutinen, z.B. auch timer.  Am Ede der Hauptroutine suborutinen für
> solche Funktionen als reentry abgespeichert, timer, hex to ascii, ln,
> sin usw..  Im Prinzip war das dann Anwendung einer eigenen "Hochsprache"
> bedingt.

Gäbe es brauchbar Makroprozessoren bzw. genauer gesagt -phasen in den 
Assemblern, so wie seinerzeit beim IBM-ASM-H, könnte man auch heute noch 
darüber nachdenken, sich quasi kleine DSL mit dem Assembler zu bauen. 
So wie die Dinge liegen, ist man in Ermangelung von dergl. fast immer 
besser bedient, mit C zu beginnen und nur bei Bedarf auf den Assembler 
auszuweichen.

[Wolfgang S. (Firma: Pensionär-Altes-Eisen) (stackpointer)]

Hallo,
egal ob Assembler oder C, C++ ( andere Hochsprachen werden kaum 
unterstützt ), einige Gatterunktionen mit Prozessoren zu erledigen kommt 
ir leichter vor als es mit flash-FPGA versuchen zuwollen.

[Volker S. (vloki)]

Wolfgang S. schrieb:
> Hallo, egal ob Assembler oder C, C++...

Und wie weit bist du?
Vergiss am besten die ganzen "Alternativen" die hier wie immer 
aufgezeigt werden. Nimm zumindest am Anfang das einfachste, MPLABX und 
den eingebauten Assembler oder eben den XC8 Compiler. Wozu sich noch mit 
zusätzlichen unnötigen Problemen plagen.

Es ist mir eh ein Rätsel wozu ein "Bastler" eine zusätzliche 
Programmiersoftware braucht und sich mit Kommandozeilen-Tools rum 
schlagen muss. Da nehme ich die IDE, die hat zwei Knöpfe, einen für den 
Debug- und einen für den Programmier- Mode und gut ist.

Eine reines Programmiertool (wie z.B. IPE) brauche ich erst dann, wenn 
ich ein fertiges Programm habe (das Hex-File), das ich auf weitere 
Controller brennen will.

[Thomas E. (picalic)]

Für so ein kleines ASM Projekt (und evtl. auch C), um das es hier geht, 
würde ich eher noch die alte MPLAB IDE 8.92 (ohne "X") empfehlen - die 
ist viel weniger aufgebläht und deutlich übersichtlicher.
Ich finde, das Debuggen (im Simulator) in der alten IDE ist deutlich 
weniger umständlich und im Gegensatz zum neuen MPLAB X kann man sich im 
Logic-Analyzer zwei Cursor anzeigen lassen und so z.B. mal eben die Zeit 
zwischen zwei Signalflanken messen, oder auch in ASM mit STEP OUT aus 
einem Unterprogramm springen (solche Kleinigkeiten hält Microchip 
offenbar für unwichtig, mich nervt das ungemein!)

[Volker S. (vloki)]

Thomas E. schrieb:
> (solche Kleinigkeiten hält Microchip
> offenbar für unwichtig, mich nervt das ungemein!)

Mich nervt auch so manches. Oder hat zumindest genervt.
Irgendwann sieht man dann aber auch die Vorteile der neuen Tools.

Übersichtlicher finde ich persönlich eigentlich MPLAB-X, auch wenn ich 
das erst 5-6 Jahre benutze und das alte MPLAB davor bestimmt doppelt so 
lange.