Druckbare Version
Hallo zusammen,
ich habe heute meinen Robby bekommen und würde ihn gerne in C programmieren. Leider habe ich weder hier im Forum noch in den FAQ einen Hinweis darauf gefunden. Ich bin allerdings auch ein Neuling im Bezug auf Microcontroller und habe vielleicht auch die falschen Begriffe gesucht.
Für ein paar Tips wäre ich dankbar.
Gruß
Sascha
Soweit ich weiss kann man Robby nur in Basic programmieren.
Oder mußt Dir einen Controller ohne Basic kaufen, diesen kannst Du dann frei Programmieren :wink: .
Der Austausch vom Controller auf dem Board ist kein Problem, habe es schon mehrfach auf dem Controllerboard durchgeführt(noch nicht auf bei einem CCRP5).
Ist dann halt mit der Programmierung natürlich einiges umfangreicher als den Controller in Basic zu Programmieren.
Krischan100
Oder die Erweiterungsplatine und ne C-Control II kaufen. Geht zwar etwas ins Geld, aber die Programmierung ist doch wesentlich angenehmer
Die CC1 ist beim Robby nicht gesockelt - da würde ich als Anfänger nicht mit dem Lötkolben rangehen! Sonst wär ein Tausch schon interessant.
Die CC2 wird meines Wissens nicht in C programmiert, sondern in "C2". Aber immerhin!
Soweit ich weiss kann man Robby nur in Basic programmieren.
Schade eigentlich.
Kann mir eigentlich jemand den Sinn erklären einen Basic Interpreter für einen Microcontroller zu entwickeln? Wäre es nicht flexibler gewesen einen Compiler zu entwicklen der Basic compiliert?
Gruß
Sascha
Einen MC wie die CC1 in Basic zu programmieren, ist nicht ganz blöd; vor allem, weils die die Alternative "Basic compilieren und dann als Maschinencode laufen lassen" in dieser Form bei der CC1 gar nicht gibt:
1. Die CC1 hat zwar "viel" ROM (so um die 6KB), aber da kann man ja nix reinladen. Drum ist da die CBASIC Runtime drin.
2. Die CC1 hat nur wenig EEPROM in der CPU (256 B); da kann man zwar bisschen was reinladen, aber kaum ein "sinnvolles" Programm. Drum werden da bei Bedarf nur Assembler Hilfsroutinen geladen.
3. An die CC1 kann man aber ganz leicht ein EEPROM anschliessen (über I2C bus), aber da kann man nur BIT-SERIELL zugreifen - na ja: die CC1 hat ja auch keinen "Adress-Bus" wie eine "richtige" CPU (ist halt ein MC, kein PC). In diesem EEPROM kann die CPU deshalb keine Programme ausführen. Drum werden da die CBASIC tokens reingeladen, und die CBASIC runtime, die im CPU ROM läuft, liest diese token dann bei Bedarf raus und führt sie aus.
Also: viel Alternativen gibts eh nicht, um ein Programm in Maschinencode direkt auf der CC1 auszuführen.
Und: Direkter Maschinencode im Gegensatz zu Interpreter für "tokens" (CBASIC) oder "PCODE" (Pascal) oder "virtuelle Op-Codes" (Java VM) ist sowieso mehr eine Philosophie-Frage als ein Performance-Problem: "gute" Interpreter sind ähnlich schnell wie Maschinencode, und "gute" runtime ist ähnlich kompakt wie Interpreter.
Aber Interpreter-Sprachen haben einige Vorteile "per Konstruktion": leichter zu lernen, schneller zu programmieren, wartungsfreundlicher, weniger fehleranfällig und liefern auf jeden Fall "mehr Leistung pro Op-Code".
Trotzdem ist CBASIC um Dimensionen (!) langsamer als Maschinencode. Aber das liegt vermutlich ganz stark daran, dass ja jedes Byte eines Tokens einzeln und bit-weise über den I2C - Bus aus dem EEPROM gelesen werden muss, bevor es verarbeitet werden kann. Und für jedes einzelne Byte werden dabei schon einige CPU-Zyklen verbraten...
Danke für die Informationen.
Nun ja wenn es schon nicht direkt in C geht werde ich wohl mal C3C ausprobieren. Auch wenn der C Code danach in Basic token umgewandelt wird so kann ich mein Programm doch besser strukturieren als unter Basic direkt. Hat schon jemand Erfahrungen damit gemacht? Gibt es Einschränkungen? Gibt es schon fertige Programme? Nutzt es überhaupt jemand?
Gruß
Sascha
Nein
Es gibt offensichtlich eine Menge Leute die sowas kaufen und damit ist der Sinn für denjenigen der es entwickelt und vertreibt dann schon erfüllt ;-)Zitat:
Kann mir eigentlich jemand den Sinn erklären einen Basic Interpreter für einen Microcontroller zu entwickeln?
Hat jemand ein Assembler Beispiel wie man die LEDs anspricht die am 74hc4094 hängen? Ich würde das gerne mit C3C nachprogrammieren. Mit Hilfe des Basicbeispiels bekomme ich das aber nicht hin. Ein paar Ideen wie die Kommunikation zu verwirklichen wäre sind auch willkommen. :idea:
Gruß
Sascha
Im P5DRIV wird's so gemacht:
-- Hast Du das gesucht?Code:*IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
*III EXTPORT, LEDPORT: shift data out III
*IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
*III on entry: DATA line is DDR=OUT III
*III on entry: CLOCK line is DDR=OUT, ON III
*III on entry: STROBE line is DDR=OUT, OFF III
*III on entry: LSTROBE line is DDR=OUT, OFF III
*III in CCBASIC: must pulse selected STROBE III
*IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
* REMAINS PA3=0, PA2=1
; init: index of EXTPORT relative EXTPORT
PDRIVE:
CLRX ; EXTPORT is at index 0
BRA PDSHIFT ; shift out 8 bits
LDRIVE: ; init: index of LEDPORT relative EXTPORT
LDX #2 ; LEDPORT is EXTPORT + 2
; fall thru
; shift out 8 bits to indexed PORT
PDSHIFT:
LDA #8 ; shift out 8 bits
* BSET 0,PADDR ; DATA LINE IS OUTPUT
LP2: ROL EXTP,X
BCLR 0,PADAT ; OUT = lo
BCC LP1
BSET 0,PADAT ; OUT = HI
LP1: BCLR 2,PADAT ; pulse CLOCK out
BSET 2,PADAT
DECA
BNE LP2
; restore cached value
ROL EXTP,X
; NOTE: must pulse STROBE line in CCBASIC
* BSET 3,PADAT ;STROBE
* BCLR 3,PADAT
; NOTE: input not supported any more
* BCLR 0,PADDR ;DATA LINE IS INPUT
RTS
@Jörg
Ja Danke. Genau das hatte ich gesucht. Letzten Endes habe ich mich aber an die Spezifikation im Datenblatt des 74HC4094 gehalten. und die einzelnen Ports direkt angesteuert.
Und es hat funktioniert. Das Ergebnis ist im Anhang zu finden.
Als nächstes werde ich versuchen den Antrieb anzusteuern.
Gruß
Sascha
Code://////////////////////////////////////////////////////////////
//
// LED Lauflicht f. Robby mit 74hc4094 Ansteuerung
//
// Sascha Becker 2004
//
//////////////////////////////////////////////////////////////
#define PORT1 0
#define STROBE 3
#define CLOCK 2
// 8 Bit an 74hc4094 senden
void BitMuster(bit b1, bit b2, bit b3, bit b4)
{
OutBit(STROBE,0); // Strobe
OutBit(PORT1,b1); // Data
OutBit(CLOCK,0); // Clock
OutBit(CLOCK,1);
OutBit(PORT1,b2); // Data
OutBit(CLOCK,0); // Clock
OutBit(CLOCK,1);
OutBit(PORT1,b3); // Data
OutBit(CLOCK,0); // Clock
OutBit(CLOCK,1);
OutBit(PORT1,b4); // Data
OutBit(CLOCK,0); // Clock
OutBit(CLOCK,1);
// 4 Leerbits hinterher
OutBit(PORT1,0); // Data
OutBit(CLOCK,0); // Clock
OutBit(CLOCK,1);
OutBit(CLOCK,0); // Clock
OutBit(CLOCK,1);
OutBit(CLOCK,0); // Clock
OutBit(CLOCK,1);
OutBit(CLOCK,0); // Clock
OutBit(CLOCK,1);
OutBit(STROBE,1); // Strobe
Wait(5);
}
void main()
{
while(1)
{
BitMuster(1,0,0,0);
BitMuster(0,1,0,0);
BitMuster(0,0,1,0);
BitMuster(0,0,0,1);
BitMuster(0,0,1,0);
BitMuster(0,1,0,0);
}
}