Newsgroup: it.comp.lang.c
Titolo: motorola HCS12

Ciao a tutti, devo programmare questa scheda con la usb.
Devo usare il programma fornito in dotazione softec microsytem e 
codewarrior.
Avendo solo esperienza con la programmazione al pc(didattica) non saprei da 
dove cominciare con questa scheda.
In rete non ho trovato ne tutorial ne programmi fatti.
Potreste darmi qualche link introduttivo a queste schede?
grazie mille


Credo che sul sito del produttore, potrai trovare tutte le info 
necessarie, application notes, datasheet.

 necessarie, application notes, datasheet.
Ciao, cercavo piu che altro materiale semplice per capire come si programma, 
intendo capire le differenze con il c standard. Ho gia guardato gli esempi 
semplici in dotazione con l'ide ma non ci sono grandi spiegazioni.
Ora provo sul sito motorola e vedremo.
Grazie ciao ciao 

Premessa che ho lavorato solo con HC11 e quindi ï¿œ leggermente diverso.
In realtï¿œ non ï¿œ che ci sono molte differenze dal c standard.
Fondamentalmente dipende solo dal compilatore e io usavo il gcc.
Ovviamente quello che ï¿œ necessario conoscere sono le chiamate per 
eseguire il bit set and reset, e la corretta procedura per 
l'inizializzazione delle periferiche.
Per il resto non vi ï¿œ grande differenza.
In teoria il codice scritto in c dovrebbe essere compilabile anche su 
altre piattaforme.



Il problema che ho � di partenza. Non capisco che funzioni usare, come usare 
i pin del micro.
potresti almeno dirmi quale file h o c di base consultare? non saprei da 
dove iniziare.
Ho dato un occhiata al file h relativo al mio micro(incluso nel progetto del 
ide) ma non ci capisco nulla.
Non so nemmeno che compilatore sto usando.
Grazie 


Questo l'ho notato, infatti quando creo un nuovo progetto per il mio micro, 
vengono allegati dei file col nome del micro e altri ancora. Alcuni 
contengono define e strutture, altri delle funzioni incomprensibili(per me 
:-)).
Comunque grazie della risposta, in alternativa a del materiale a prova di 
idiota questo procedimento promette bene.
Ciao ciao 


Codewarrior e' l' ambiente Freescale per la programmazione
dei sui micro, di solito contiene anche esempi funzionali,
non molto commentati ma si rivolge a persone gia'
esperte.
Il problema e' che per questi micro, come ti hanno
gia' scritto e' che prima devi capire come funziona il micro
studiandoti il data-sheet ;-)
In codewarrior pero di solito e' presente un configuratore
che scrive le inizializzazioni per te: di solito e'
parecchio esplicativo ed istruttivo(Io lo uso per CPU ppc
MPC5xx un pochino piu' complesse dell HC12 e mi trovo bene).
A.

 grazie mille
come ti hanno gia' detto, leggiti il datasheet del micro, il datasheet
delle periferiche del micro (se e' separato da quello del micro), il
reference manual degli HCS12.
Poi apri codewarrior, cerchi il menu Help e leggi piu' o meno tutto
quello che c'e' dentro li.
Poi vai sul sito della freescale e cerchi le app note per l'HCS12,
normalmente hanno incluso anche del codice (non sempre ben fatto
purtroppo) che ti puoi studiare per capire come funziona.
In ogni modo se il source code dell'HCS12 (che non ho mai usato) e'
strutturato come quello degli HCS08 allora tutti i registri del micro
(configurazione, I/O,...) sono mappati tramite macro (col nome 1 a 1
come nel datasheet) che puoi usare come se fosero variabili.
Esempio:
se nel datasheet hai un registro chiamato PIPPO
per leggere quello che c'e dentro: unsigned char x = PIPPO;
per scriverci dentro: PIPPO = x;
Ciao Jack

Ciao, scrivo a te ma vale per tutti:
Allora, ho guardato le circa 600 pagine del datasheet, credo sia inutile 
studiarlo ma di volta in volta andro a vedere cosa mi serve giusto?
Quello che spero di aver capito fino ad ora � che se voglio avere un uscita 
ad 8 bit che mi indica il risultato di un ipotetica elaborazione di un 
ingresso(sempre 8 bit) io posso accedere all'hardware di ingresso e uscita 
tramite il nome dei registri che leggo sul datasheet(o i relativi indirizzi 
tipo 0xffff). Quindi se voglio sottrarre 1 all'ingresso e mandare il 
risultato in uscita faccio qualcosa del genere:
utilizzo il registro portA come input su 8 bit, portB come output e faccio
portB=portA - 1; quindi agendo sui registri agisco sui relativi pin dell' 
hardware? confermate?
Se confermate che ho capito il concetto posto il codice di base di un nuovo 
progetto cosi provo man mano ad aggiungere codice con la vostra 
supervisione:-)
Grazie a tutti.
P.S. ecco il datasheet
http://www.freescale.com/files/microcontrollers/doc/data_sheet/MC9S12E128V1.pdf
 

A memoria si fa cosï¿œ:
1) settare pin in condizione input o ouput sono i registri "Data 
Direction Register" vedi pag 142
ex:
  DDRP = 255; // setto tutto a output
  DDRP = 0; // setto tutto a input
2) settare il risultato in uscita "Port I/O register"
ex:
  PTP = 255; //setto a 1 tutto le uscite
  PTP = 0; // setto a 0 tutte le uscite
  PTP &= 0x02; //setto il pin 1 (PP1)
  PTP = PTP & 0x02 // come sopra
  PTP = PTP & 1<<1 // come sopra (la prima ï¿œ la meglio)
Nota: di solito ci sono comandi specifici per settare a 1 un bit perchï¿œ 
non ï¿œ detto che il compilatore converti automaticamente in 1 istruzione 
sola.
Mi spiego meglio:
il gcc che ho usato su avr convertiva automaticamente questo comando 
"PTP &= 0x02" nella chiamata asm da 1 comando per eseguire il bit set.
Se invece scrivi " PTP = PTP & 0x02" esegue una lettura da registro , 
una operazione logica AND e uno store su registro.
Su un microcontrollore che non va na chippa usare 3 comandi al posto di 
1 ï¿œ una bella differenza. Quindi non dico subito ma guardati che asm 
prodotto e scegli la sintassi + corretta.
Cordiali Saluti
Xeus32
Il 19/05/2010 19.14, Foley ha scritto:
 > Ciao, scrivo a te ma vale per tutti:
 > Allora, ho guardato le circa 600 pagine del datasheet, credo sia inutile
 > studiarlo ma di volta in volta andro a vedere cosa mi serve giusto?
 > Quello che spero di aver capito fino ad ora ï¿œ che se voglio avere un 


   PTP = PTP & 1<<1 // come sopra (la prima è la meglio)
negli HCS08 si puo' evitare di usare l' &= per settare i bit di una
porta, sono mappati tutti in una union.
esempio:
setto il bit 1 della porta A (che e' gia' configurata come output):
PTAD_PTAD1 = 1;
controlla il .h del micro, dovrebbe gia' essere incluso nel progetto
creato da codewarrior, li ci sono tutte le definizioni, inutile
ricrearle a mano oppure accedere ai registri usando l'indirizzo in
memoria.
Ciao Jack

Si, avevo gia detto che nel file h del micro incluso nel progetto vi sono 
tutte le struct e union dei vari pin e registri.
Posto un codice di esempio che ho trovato, sfrutta il convertitore analogico 
digitale e visualiza la conversione su 8 bit.
Provo a commentarlo io cosi mi correggete se sbaglio.
#include <hidef.h>
#include <mc9s12e128.h>
#pragma LINK_INFO DERIVATIVE "SampleS12"        // NON SO COSA FA
// ---------------------------------------------------------------------------
// Puts the following code into NOT BANKED FLASH MEMORY
// ---------------------------------------------------------------------------
#pragma CODE_SEG __NEAR_SEG NON_BANKED        // NON SO COSA FA
// ---------------------------------------------------------------------------
// Peripheral Initialization Routine
// ---------------------------------------------------------------------------
void PeriphInit(void)                //FUNZIONE CHE INIZIALIZZA LE 
PERIFERICHE E
{                                             //CHE DEFINISCE LE DIREZIONI 
DEI REGISTRI.
    PTT = 0x00;                    // AZZERA (REGISTRO O PORTA?) T
    DDRT = 0xFF;                   //  T USATO COME OUTPUT
    ATDCTL3 = 0x08;                // PONE IL 4�BIT A 1 QUINDI UNA 
CONVERSIONE PER
                                                  //SEQUENZA (CHE VUOL DIRE 
PER SEQUENZA?)
    ATDCTL4_SRES8 = 1;             // PONE L'8� BIT DEL ATDCTRL4 A 1 CIOE' 
USA SOLO 8 BIT
                                                      // PER RAPPRESENTARE 
LA CONVERSIONE.
    ATDCTL5_SCAN = 1;              // A 1 MODO DI CONVERSIONE CONTINUA
    ATDCTL2 = 0x80;                // 8� BIT A 1 QUINDI FUNZIONAMENTO 
NORMALE
}
// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------
void main(void)
{
    PeriphInit();                  // INIZIALIZZO QUELLO CHE MI SERVE VEDI 
SOPRA
    EnableInterrupts;           // ABILITO GLI INTERRUPTS CHE NON SO ANCORA 
COSA SONO
    for(;;)                        // LOOP INFINITO
    {
        if(ATDSTAT1_CCF0)          // L'UNICO BIT CHE CI INTERESSA E' IL 
CCF0 CHE VA A 1 QUANDO
                                                      // LA SEQUENZA E' 
STATA LETTA E IL RISULTATO VA IN ATDDR0
PTT = ATDDR0H;         // METTO IN T GLI 8 BIT PIU SIGNIFICATIVI  DI 
ATDDR0(16BIT) VISTO
                                        // CHE LA CONVERSIONE E' SU SOLI 8 
BIT.
    }
}
Ci ho messo circa 30min ad analizzarlo, mi sembra molto scomodo ma se ho 
fatto giusto forse ne vale la pena...
Di alcuni registri sono inizializzati solo alcuni bit, gli altri bit che non 
vengono inizializzati che valori avranno?
Grazie ancora
ciaooo

      ATDCTL2 = 0x80;                // 8ï¿œ BIT A 1 QUINDI FUNZIONAMENTO


 schema) ?????
non direi che questi tre micro sono piu' documentati dei HCS12.
sul sito della freescale c'e' parecchia roba a riguardo. Ovvio che
assumono che uno sappia gia' qualcosa riguardo l'architettura di un
microprocessore.
Qua il problema e' che il poster non ha idea di come funzioni un
micro, quindi (ovviamente) leggere il datasheet degi HCS12 e/o il
reference manual non lo aiuta piu' di tanto.
Ciao Jack


Fosse per me cambierei ambiente, pero devo realizzare un progettino per un 
corso, e il prof mi ha detto di utilizzare esclusivamente questo micro. Non 
devo diventare un super esperto, mi basta realizzare una scritta scorrevole 
su matrice di led o qualcosa di simile difficolt�.
Teoricamente so cosa sono gli interrupt, per� non ho idea di come vengono 
gestiti fisicamente, che comandi usare e come usarli quindi � come se non lo 
sapessi :-)
Il mio problema � che il prof spiega tutto teoricamente e non fa riferimento 
a un micro in particolare quindi devo vedermela da solo. Riguardo 
all'esempio che ho postato secondo voi ho capito qualcosa? 

  ha scritto nel messaggio
 > news:4bf5abf9$0$12131$4faf...@reader4.news.tin.it...
 >> Mi sa che devi studiare ancora parecchio se non sai cosa sono gli
 >> interrupts ma prenderti qualcosa di piï¿œ semplice e piï¿œ documentato tipo
 >> AVR, 80c31 o PIC (Anche se i pic hanno una logia completamente fuori
 >> schema) ?????
 >>
 >> Ciao e buono studio
 >>
 >
 > Fosse per me cambierei ambiente, pero devo realizzare un progettino 
per un
 > corso, e il prof mi ha detto di utilizzare esclusivamente questo 
micro. Non
 > devo diventare un super esperto, mi basta realizzare una scritta 
scorrevole
 > su matrice di led o qualcosa di simile difficoltï¿œ.
 > Teoricamente so cosa sono gli interrupt, perï¿œ non ho idea di come vengono
 > gestiti fisicamente, che comandi usare e come usarli quindi ï¿œ come se 
non lo
 > sapessi :-)
 > Il mio problema ï¿œ che il prof spiega tutto teoricamente e non fa 


 trovato H8 e ARM. Con gli arm mi trovo da dio sono una bomba!
giusto giusto lo stesso tipo di micro eh.
prova a programmare in assembler un ARM, poi cambi idea.
Ciao Jack

Onestamente non ho mai programmato l'arm in asm ma ho programmato x86 in 
HPC (MMX, SSE, cache, multicore ...) e ti dico che non � facile! Poi 
onestamente mi piacerebbe molto riprovare ad usare l'arm ma ho cambiato 
lavoro e onestamente sono un po' insoddisfatto! Ora per hobby mi 
piacerebbe provare il MIPS.
