Newsgroup: it.hobby.elettronica.digitale
Titolo: Programmare con PICCLITE

Salve a tutti,
sto studiando come programmare in PIC in linguaggio C visto che di
questo ho gia le basi che invece non ho con l'assembler.
Ho moltissimi dubbi riguardanti lo stato delle porte, i comandi per
scrivere e leggere in memoria flash, e l'utilizzo delle routine che
stanno gia nel compilatore.
C'č qualcuno che possa darmi un indirizzo in cui trovare codici semplici
pronti per PICCLITE magari con qualche riga di commento in modo tale da
poterli studiare e capire finalmente l'utilizzo dei comandi?
Ad esempio se io volessi mettere ad uno la porta configurata per uscita
RA1 cosa dovrei scrivere nel mio codice? e cosa se devo metterla a zero?
se voglio depositare in memoria lo stato di una porta quali comandi devo
usare?se voglio mandare in uscita un carattere char da un piedino(tipo
comunicazione seriale) quale istruzione devo usare e quale per leggere
il carattere?
Altrimenti dove posso trovare questi comandi all'interno della directory
del compilatore?
Queste cose purtroppo non fannno parte del C standard e quindi scusatemi
se ho fatto domande stupide o banali!
Spero che qualcuno possa aiutarmi, con gli esempi che stanno nel
compilatore non sono riuscito a capire questi funzionamenti.

Scaricati la guida del compilatore dal sito della HiTECH: contiene anche un
piccolo tutorial che č l'ideale per partire.
bye
crbit
PS. Se sei proprio disperato ecco uno spezzone di codice commentato ...
spero non si inc***zi nessuno per la lunghezza del messaggio
/*
 * digidie.c
 *
 * A digital die.  A random number between 1 and 6 is displayed
 * on a 7-segment display when a button is pressed and also for a
 * few seconds after the button is released.  Otherwise a rotating
 * pattern is displayed.  If there have been no button presses
 * for around 30 seconds the processor goes to sleep but will wake
 * again when the button is pressed.  A random number generator isn't
 * used; the randomness arises from the uncertainty in the time
 * the button is pressed relative to the state of an internal timer.
 *
 * The program can be used to try out the PIC C compiler from HI-TECH
 * Software (a time-limited demo is available: 
http://www.htsoft.com
).
 * Compile for the 16F84 using full optimization.
 *
 * The digital die can use either the 16C84 or 16F84 and was designed
 * to be programmed in-circuit using very simple hardware (see:
 * 
http://www.man.ac.uk/~mbhstdj/icp84.html
 for more details).  A
 * common anode 7-segment LED display is attached to the PIC via
 * 470 ohm resistors as follows:
 *
 *    RA0 segment a
 *    RA1 segment b
 *    RA2 segment c
 *    RA3 segment d
 *    RA4 segment e
 *    RB4 segment f
 *    RB5 segment g
 *
 * The common connection goes to VDD.  A normally open switch is
 * connected from RB7 to GND via a 470 ohm resistor.  The PIC
 * configuration word is set for a crystal oscillator (the Xtal
 * frequency should be communicated to the program via the FREQ
 * macro below).
 *
 * Copyright (C) 1998 David Tait (
david...@man.ac.uk
)
 *
 */
#include <pic.h>
#define FREQ    3579454.                // crystal frequency in Hz
// #define FREQ    4000000.
#define TICKSIZ (1024./FREQ)
#define SECS(x) ((unsigned)((x)/TICKSIZ))
#define WAIT()  do delay(SECS(0.1)); while ( button == 0 )
#define SLEEP() asm("\tsleep")
typedef unsigned char BYTE;
bit volatile button @ (unsigned) &PORTB*8+7;    // button on RB7
BYTE volatile pressed;          // set by button press interrupt
BYTE volatile number;           // a number grabbed from TMR0
const BYTE segtab[10] =         // convert digit to segment form
{
    0x40, 0x79, 0x24, 0x30, 0x19,       // only entries 1 to 6 used here
    0x12, 0x02, 0x78, 0x00, 0x10
};
void interrupt grab_timer(void)         // grab TMR0 when button pressed
{
    if ( button == 0 && !pressed ) {
 number = TMR0;
 pressed = 1;
    }
    RBIF = 0;
}
void display(BYTE segs)
{
    PORTA = segs;
    PORTB = (segs>>1)&0x30;
}
void delay(unsigned ticks)      // waste time in ticks (256us @ 4MHz)
{
    while ( ticks-- ) {
 T0IF = 0;
 while ( T0IF == 0 )
     continue;
    }
}
void roll(void)                 // display a rotating pattern
{
    unsigned i = 0;
    BYTE segs = 1;
    pressed = 0;
    for (;;) {
 display(~segs);
 delay(SECS(.05));
 if ( (segs <<= 1) == 0x40 )
     segs = 1;
 if ( ++i > 600 ) {      // power-down after 30 secs
     i = 0;
     display(0xFF);      // turn off all segments
     SLEEP();            // sleep until button pressed
     WAIT();             // wait for button release
     pressed = 0;        // and continue
 }
 if ( pressed )
     break;              // return if button pressed
    }
}
BYTE mod6(BYTE n)               // compute n%6 without using library
{
    BYTE count, m6 = 6<<5;
    for ( count = 0; count < 6; ++count, m6 >>= 1)
 if ( n >= m6 )
     n -= m6;
    return n;
}
void main(void)
{
    static BYTE bias = 0;       // used to ensure equal probabilities
    BYTE n;
    __CONFIG(0x3FF9);           // XT oscillator (and PWRTE if 16C84)
    TRISA = 0;                  // PORTA all outputs
    TRISB = 0x80;               // PORTB all outputs except RB7
    OPTION = 8;                 // enable weak pullups, TMR0 rate 1:1
    INTCON = 0x88;              // enable change on RB<4:7> interrupt
    for (;;) {
       if ( ++bias >= 6 )       // update bias
    bias = 0;
       roll();                  // wait for a button press
       n = mod6(number);
       n = mod6(n + bias) + 1;
       display(segtab[n]);      // display die value
       WAIT();                  // wait for button release
       delay(SECS(3.0));        // hold display for 3 seconds
    }
}

Grazie mille!! sei stato gentilissimo, il manuale l'ho scaricato ma ci ho
trovato poco oppure ho scaricato quello sbagliato!! cercherň meglio!!
Adesso intanto mi studio questo codice che mi hai mandato.
crbit ha scritto:


 > crbit

> quale significato hanno i simboli '>>' oppure'<<' e la tilde '~'
Sono operatori del C standard:
 >> sta per "shift right": esegue l'operazione di shift verso destra dei 
bit di un byte (es. da 00110011 a 00011001): elimina il bit più a 
destra, sposta ogni bit di una posizione a destra e mette 0 nel bit più 
a sinista
<< sta per "shift left": come lo shift right, ma inverso: elimina bit 
più a sinistra, sposta ogni bit di una posizione a sinistra, mette uno 0 
nel bit più a destra
~ sta per xor: l'operazione che dato un byte inverte tutti i suoi bit: 
da 10101100 a 01010011.
-marco-
-- 
Fontani Marco aka RoZe}[R]{@IRCNet & Shanks@IrcOp@IrcItalia
Phone 
+393288355236
 - Okram@Av3MUD - ProgrammerInSearchOfJob
AthlonXP2000+@2100+ on K7VTA3/KT333 512MBRam 20GB+30GBHD
Linux *è* user friendly, ma selettivo sui propri amici.
x = x^y; y = x^y; x = x^y; <-= swap with no need for 3rd var.

 stanno gia nel compilatore.
http://www.microchipc.com/HiTechCFAQ/
Qui trovi moltissimo materiale.
Bye

 questo ho gia le basi che invece non ho con l'assembler.
Senza la pretesa di rispondere a tutte le domande ti invio il link al 
mio corso di C per Pic
http://web.tiscali.it/robofun/
ciao
S

 S
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Grazie mille a tuttu per i preziosi consigli
Enrico_b ha scritto:


 da 10101100 a 01010011.
Uh, non era NOT?
se non sbaglio viene usato come operatore unario...
--
...:::Zmaster:::...
DSL powered
zmast[ANTISPAMSYSTEM]@
freemail.it
www.zmasterworld.8m.com
Collaboratore del Media Player Project