// test per pic 16f877a
#define XTAL_FREQ 4MHZ
#include
// Fuses di configurazione
__CONFIG (HS & WDTDIS & PWRTEN & BORDIS & LVPDIS & DUNPROT & WRTEN & DEBUGDIS & UNPROTECT);

#include “delay.c” // routine per ritardi
#define LED1 RC0
#define LED2 RA5

// funzione principale, eseguita all’avvio del picmicro
void main(void)
{

// imposto i registri tristato in maniera tale che tutte le porte siano configurate come pin di uscita
TRISA=0b00000000;
TRISB=0b00000000;
TRISC=0b00000000;
TRISD=0b00000000;
TRISE=0b00000000;
LED1=0;
LED2=0;

while(1) // eseguo un ciclo finito
{

LED1=LED1^1;
DelayMs(50);
LED2=LED2^1;
DelayMs(50);

}// Fine ciclo continuo

} // Fine main

ora i due led, sia su porta “a” e su porta “c”, dovrebbero lampeggiare entrambi.
osservo che il led della porta “c “lampeggia, mentre il led della porta “a” rimane fisso.
ho seguito tutte le istruzioni per la compilazione o anche provato a reinstallare la versione vecchia di mplab(la 8.6), ma il problema persiste lo stesso, con entrambe le versioni.
non vorrei che vada in conflitto qualcosa, dato che uso window7 .
mi sapete dare delle spiegazioni? grazie!

http://www.settorezero.com/wordpress/hitec-c-compiler-i-nuovi-nomi-mnemonici-che-causano-errori-nei-vecchi-programmi/

Error [800] test.as; 45. undefined symbol “UNPROTECT”
Error [800] test.as; 45. undefined symbol “DEBUGDIS”
Error [800] test.as; 45. undefined symbol “WRTEN”
Error [800] test.as; 45. undefined symbol “DUNPROT”
Error [800] test.as; 45. undefined symbol “LVPDIS”
Error [800] test.as; 45. undefined symbol “BORDIS”
Error [800] test.as; 45. undefined symbol “PWRTEN”
Error [800] test.as; 45. undefined symbol “WDTDIS”
Error [800] test.as; 45. undefined symbol “HS”

********** Build failed! **********
cosa devo fare, il file è il main.c di esempio sulla lezione .
ti ringrazio!

Grazie.
Saluti Matteo

un saluto
fabio milano

un saluto
fabio milano

qualcuno ha provato?

plotino

mentre questo è il settaggio delle impostazioni del convertitore AD
ADCON0=0b10001000; //settato: fosc32, analoginput AN1, convertitore AD Off
ADCON1=0b10000100; //settato:risultato giustificato a destra, fosc32, AN0 AN1 AN3 INGRESSI ANALOGICI,AN2 AN4 AN5 AN6 AN7 INGRESSI DIGITALI

infatti Impostando i bit PCFG3:PCFG0 del registro ADCON1 a 0100 dovrei avere AN0 AN1 AN3 come ingressi analogici, mentre AN2 AN4 AN5(RE0) AN6(RE1) AN7(RE2) come I/O digitali in base anche al settaggio dei registri tristato.
Questo però non succede perchè (per fare una prova al volo) ho provato semplicemente ad attivare le tre uscite in questione (RE0=1; RE1=1; RE2=1;) e l’unico pin che si porta alto è RE2.
Non so davvero più dove sto sbagliando, perciò le chiedo se ha qualche suggerimento da darmi.
Grazie ancora

la mia necessità è quella di mandare in blinking solo una parte del testo presente sul display (+ precisamente 2 caratteri). L’idea è quella di impostare una data o ora usando due tasti: con il primo imposto progressivamente GG MM AA oppure hh mm ss con il secondo incremento il valore (un po’ come avviene quando si imposta ad esempio l’h sul cruscotto di una vettura).
Per sapere cosa incremento devo evidenziare in qualche modo il valore in questione. Io pensavo al blinking ma andrebbe bene anche il reverse ma penso che in questo caso mi complicherei la vita (potrei definire le cifre in reverse come custom char ma il massimo è 8 e servono 10 cifre)

un saluto
fabio milano

P.S. ti ho offerto il caffè, veramente con le cose che ho imparato dal sito avrei dovuto offrirti la cena …
purtroppo il mio stipendiuccio da prof …

Giovanni ha scritto:
>lavorare ad un certo livello con un pic 16bit non è la stessa cosa che lavorare con arduino e penso che avere >determinati esempi già pronti è una bella cosa

Spiegheresti questa cosa? con arduino e’ piu’ semplice?

Condivido quello che scrive Giovanni, per quanto riguarda la questione di persone (parassiti) che rivendono il lavoro altrui proporrei di mettere delle firme nei documenti che solo l’autore conosce, in modo da individuare il furbo, ad esempio Elektor fa scaricare dei documenti a pagamento le stesse riviste in formato PDF, in ogni pagina c’e’ il nome account di chi ha scaricato, quindi se ad esempio io dovessi fare il furbo sarei rintracciabile inquanto su ogni pagina c’e’ il mio nome.

un saluto
fabio milano

oppure è sempre nel top delle pagine di google, quindi basta una ricerca ;)

ciao!

boolean tea = false;
boolean emulator=false;
boolean firstTime=false;

boolean client=false;
unsigned char c=0×0;

//———————————————————
// definizione degli output per comandi
//———————————————————

const int dma_ack = 44;
const int dma_req = 45;
const int G = 46;
const int DIR = 47;
const int MAX_BUFF_WRT =1024;
byte dato=0;
byte datiDaLeggere=0xfd;
byte datiLetti[0xff];
byte data[0xff];
byte dataRead[0xff];
byte indexItr=0;
boolean comunicazione=false;//false =seriale true =tcp
boolean ciclo=true;
byte bufSerialeWrite[MAX_BUFF_WRT];
byte bufSerialeWriteTot[MAX_BUFF_WRT];
byte bufSerialeRead[MAX_BUFF_WRT];
byte bufSerialeReadTot[MAX_BUFF_WRT];
byte bufRicezione[100];
static long contatore=0;
static boolean controllo=true;
byte i=0;
byte tipoOperazione=0;
byte type=2;
byte inByte=0×0;
byte indice=0×0;
byte maxElementi=8;
byte elemento=0;

void setup()
{
// disabilitazione ingressi analogici
AD1PCFG=0xffff;
// porta dati
TRISE=0xff;
//porta comandi
TRISB=0xff;
pinMode(G,OUTPUT);
pinMode(DIR,OUTPUT);
digitalWrite(G,HIGH);
digitalWrite(DIR,HIGH);
pinMode( dma_ack,OUTPUT);
pinMode(dma_req,INPUT);
memset(bufSerialeWrite,0×0,MAX_BUFF_WRT);
bufSerialeWrite[0]=0xdb;
bufSerialeWrite[51]=0xfb;
memset(bufSerialeRead,0×0,MAX_BUFF_WRT);
bufSerialeRead[0]=0xdb;
bufSerialeRead[51]=0xfb;
memset(bufSerialeWriteTot,0×0,MAX_BUFF_WRT);
memset(bufSerialeReadTot,0×0,MAX_BUFF_WRT);
memset(bufRicezione,0×0,sizeof(unsigned char)*100);
Serial.begin(115000);
Serial.flush();
digitalWrite( dma_ack,HIGH);
memset(dataRead,0×0,0xff);
memset(data,0×0,0xff);
}

void loop()
{

while (ciclo)
{
if(!firstTime)
{
Version(2);
firstTime=true;
digitalWrite(G, HIGH);

memset(bufRicezione,0×0,sizeof(unsigned char)*100);
char myString[] = “**** READY ****”;
memcpy(bufRicezione,myString,strlen(myString));
Serial.flush();
Serial.write(bufRicezione,100);
delay(100);
memset(bufRicezione,0×0,sizeof(unsigned char)*100);
}
dato=0;

int a=Serial.available();

if(a >99)
{
for(byte ricezione=0;ricezione<a;ricezione++)
{
bufRicezione[ricezione]=Serial.read();
}
Serial.flush();

c = bufRicezione[0];

if (c == 0×41 && !emulator)//A
{
digitalWrite(G, HIGH);
delay(200);
pinMode( dma_ack,INPUT);
TRISB=0xf7;
TRISE=0xff;
emulator=true;
digitalWrite(DIR, LOW);
digitalWrite(G, LOW);
tea=false;
char myString[] = "**** EMULATOR ****";
memcpy(bufRicezione,myString,strlen(myString));
Serial.flush();
Serial.write(bufRicezione,100);
delay(100);
}

if(c == 0×71 )//q
{

digitalWrite(G,HIGH);
char myString[] = "**** END TAPE ****";
memcpy(bufRicezione,myString,strlen(myString));
Serial.flush();
Serial.write(bufRicezione,100);
delay(200);
Serial.end();
ciclo=false;
tea=false;
emulator=false;
}

if(!tea)
{

if (c == 0×43 && emulator)//C
{

controllo=true;
contatore=0;
Leggo(dato);
delay(1500);

}

// azzera i buffer globali
if ((c == 0×25) && emulator)
{
memset(bufSerialeWriteTot,0×0,MAX_BUFF_WRT);
memset(bufSerialeReadTot,0×0,MAX_BUFF_WRT);
memset(bufRicezione,0×0,sizeof(unsigned char)*100);
}

// ritorna il cmd inviato x verificare che l'operazione precedente sia conclusa
if ((c == 0×20) && emulator)
{
Serial.flush();
Serial.write(bufRicezione,100);
memset(bufRicezione,0×0,sizeof(unsigned char)*100);
}

}

}

}
Serial.println("**** !!!!!!!!!!!!!! ****");
delay(10);
Serial.end();

}
/////////////////////////////////////////////////////////////
void Version(byte flag)
{
byte i=0×0;
digitalWrite(G, HIGH);
for (i=0×0;i<=flag;i++)
{
//Clock();
digitalWrite(DIR, LOW);
delay(100);
digitalWrite(DIR, HIGH);
delay(400);
}
digitalWrite(DIR, LOW);
memset(bufRicezione,0×0,sizeof(unsigned char)*100);
char myString[] = "**** Ver. 1.0 ****";
memcpy(bufRicezione,myString,strlen(myString));
Serial.write(bufRicezione,100);
delay(500);

}

//////////////////////////////////////////////////////////////////////////
void Leggo(byte flag)
{
byte val=0×0;
byte slk=0×0;
byte ck=0×0;
boolean dt=false;
byte asa=0×0;
boolean flago= true;
byte fISR=0×0;
byte bufSeriale[256];
int indexBuf=0;
int ix=0×0;
byte date[1024];
byte sette=0×0;
boolean datoPreparato=false;
boolean dueCk=false;
int i=0;
memset(date,0×0,1024);
if(controllo)dt=false;
fISR=2;

do
{
do
{
val=PORTB;
slk=(val&0×20);
if(!controllo)contatore++; //controllo in caso di errore

}while((slk==0×20)&&(contatore<200000)); // fronte discesa bit selezione

if(contatore=200000)
{
ck=1;
dt=true;
}

if((!ck )&&(flago))
{
flago=false;
date[ix]=val;
ix=ix+1;
if(val==0×83)//cassette status register
{
TRISE=0×00;//dati in lettura
PORTE=0xff;
}

if(val==0×81)//Isr
{
TRISE=0×00;//dati in lettura

if(fISR==1)
{
PORTE=0×7f;
if(flag==7)dt=true;
}
}

if(val==0×95)//cmd
{
TRISE=0xff; //dati in scrittura
asa=PORTE;
if(asa==0×3e)
{
fISR=1;
}
date[ix]=asa;
ix=ix+1;
}

if(val==0×97)//cmd
{
TRISE=0xff;
bufSerialeWrite[indexBuf]=PORTE;
indexBuf=indexBuf+1;
if(indexBuf>94)dt=true;
}

}

do
{
val=PORTB;
ck=(val&0×40);
}while(ck!=0×40); // fronte salita clock

flago=true;
}
while(!dt);
TRISE=0×00;
PORTE=0×0;
TRISE=0xff;

Serial.write(date,100);

}

/////////////////////////////////////////////////////////////
void IniComandi(void)
{
digitalWrite(G, HIGH);
delay(200);
digitalWrite(DIR, HIGH);
TRISB=0×8;
digitalWrite(G, LOW);
delayMicroseconds(1);
}
/////////////////////////////////////////////////////////////
void IniDati(void)
{
PORTE=0xff;
delayMicroseconds(1);
}
/////////////////////////////////////////////////////////////
void WrtComandi(unsigned int val)
{
//unsigned int app=0×0;
//app=PORTB>>8;
//PORTB=val|(app << 8);
PORTB=val;
delayMicroseconds(1);
}
//////////////////////////////////////////////////////////
void WrtDati(byte val)
{
PORTE=val;
delayMicroseconds(1);
}
//////////////////////////////////////////////////////////
byte RdDati(void)
{
byte valore=0×0;
valore=PORTE;
//valore=LATSESET;
return valore;

}
/////////////////////////////////////////////////////////////

int Setto_dati(int mode)
{
if(mode==0)
{
TRISE=0xffff;
}
else
{
TRISE=0×00;
}
delayMicroseconds(1);
return 0;
}