Da TI, una piattaforma di sviluppo a €3

Testato:
grazie, questa e' la dimostrazione che e' meglio arduino :slight_smile:

Dite per il codice?
Mi spiace di aver fatto "cattiva pubblicità" alla TI: quelle poche righe sono il risultato di uno che ha preso il micro per la prima volta, si è visto una lista dei registri e ci ha smanettato un po'.
Sicuramente ci sono modi più "eleganti" per farlo (:

ratto93:

Testato:
grazie, questa e' la dimostrazione che e' meglio arduino :slight_smile:

Concordo pare un pochino dico solo un pochino incasinato :stuck_out_tongue_closed_eyes:

Se dite così non avete mai armeggiato con i timer e gli interrupt.... si devono manipolare i registri perché funzioni apposite di Arduino non ce ne sono... non vedo molta differenza dal codice scritto per il micro TI.
Un esempio è questo, col quale attivo il timer 2:

//routine di attivazione del timer con clock interno
void attivaTimer() {
    /*imposto il timer 2 per usare un contatore interno per contare i singoli secondi
    Per ottenere la precisione di 1s, prendiamo un prescaler di 32
    ed inizializziamo il contatore ad 8 bit a 6 così da avere un overflow
    ogni 250 colpi: con clock a 8 MHz sono esattamente 1 millisecondo*/
    
    //disattiva tutti gli interrupt sul timer 2 durante il setup iniziale
    TIMSK2 &= ~(1<<TOIE2); 
    TIMSK2 &= ~((1<<OCIE2A) | (1<<OCIE2B));
    // Usa il clock intero dell'Atmega come fonte di clock per il prescaler
    ASSR &= ~(1<<AS2);
    //Prescaler/32,
    TCCR2B &= ~(1<<CS22); 
    TCCR2B |= ((1<<CS21) | (1<<CS20)); 
    // Modalità normale: incrementa il contatore fino all'overflow
    TCCR2A &= ~((1<<WGM21) | (1<<WGM20)); 
    TCCR2B &= ~(1<<WGM22);
    
    /*valore iniziale del contatore: 6. Questo perché 1/(CLOCK_MICRO_IN_HZ/PRESCALER/(VALORE_CONTATORE))
    restituisce i ms prima che il contatore vada in overflow, quindi 1/(8000000/32/(256-6)=0,001s ossia 
    1 ms esatto. */
    TCNT2=6;
    // Attiva un segnale di interrupt all'overflow del contatore
    TIMSK2 |= (1<<TOIE2); 
    //attiva gli interrupt
    SREG |= 1<<SREG_I;
}

Se tolgo i commenti si ottiene:

//routine di attivazione del timer con clock interno
void attivaTimer() {
    TIMSK2 &= ~(1<<TOIE2); 
    TIMSK2 &= ~((1<<OCIE2A) | (1<<OCIE2B));
    ASSR &= ~(1<<AS2);
    TCCR2B &= ~(1<<CS22); 
    TCCR2B |= ((1<<CS21) | (1<<CS20)); 
    TCCR2A &= ~((1<<WGM21) | (1<<WGM20)); 
    TCCR2B &= ~(1<<WGM22);
    TCNT2=6;
    TIMSK2 |= (1<<TOIE2); 
    SREG |= 1<<SREG_I;
}

Che ci capite? :stuck_out_tongue:

effettivamente ben poco, almeno io, pero non regge il paragone visto che fai il confronto fra un Blink e la gestione di un interrupt

Leo devi tener conto che poi giocandoci già in un paio di chiamaimole esercitazioni o prove il tutto diventa molto più chiaro e di facile comprensione... non vedo l'ora che arrivi per testarlo :slight_smile:
degli interrupt o dei timer non ne ho ancora avuto bisogno per questo non mi son mai posto il problema :slight_smile:

Il mio era un esempio (quello dei timer) per farvi capire che quando si manipolano direttamente i registri del micro, o si conoscono a memoria tutte le variabili interessate oppure il codice diventa arabo, così come appare arabo quella porzione di codice TI perché non sono registri e/o istruzioni a noi non familiari. Spero di essermi spiegato meglio, ora.

questo e' chiaro, ma mi sembra abbastanza chiaro che e' proprio nel rendere piu' user friendly questi passaggi la forza di Wiring... oops Arduino :slight_smile:

guarda tu stesso:

void setup() {                
  pinMode(13, OUTPUT);     
}

void loop() {
  digitalWrite(13, HIGH);  
  delay(1000);          
  digitalWrite(13, LOW);   
  delay(1000);             
}
#include <msp430g2231.h>
void delay(unsigned int millis){
 while(millis--){
 __delay_cycles(1000);
 }
}

int main(){
 WDTCTL = WDTPW | WDTHOLD;
 BCSCTL1 = CALBC1_1MHZ;
 DCOCTL = CALDCO_1MHZ;
 P1DIR = BIT6;
 P1OUT = BIT6;

 while(1){
  P1OUT ^= BIT6;
  delay(1000);
 }
return 0;
}

Concordo in pieno. Tant'è che sia Wiring che Arduino sono nate come piattaforme per dare la possibilità ad artisti la prima ed a studenti la seconda di "spippolare" in modo semplice con dell'HW appositamente preparato.

Molto del successo di Arduino sta proprio in Wiring che ha semplificato operazioni che richiedevano un certo impegno a livello di codice come il semplice lampeggio di un led.

Buongiorno a tutti (:

Ieri sera ho giocherellato un'altra mezz'oretta con il launchpad.
Una volta superato il "problema" di dover leggere e scrivere registri e non pin singoli, ho scritto una funzione per il debounce e copiato/incollato dal mio progetto Arduino quella per il click.
Lo lascio qui in caso interessasse a qualcuno.
Ripeto che è codice di un principiante: sono certo che molte cose potrebbero essere migliorate sia per chiarezza che per efficienza.
Ho provato a cambiare main da int e void, ma gcc produce un avviso in fase di compilazione e mi dava fastidio (:

#include <msp430g2231.h>

char oldState[4] = {0,0,0,0};
char newState;

void delay(unsigned int millis){
 while(millis--){
 __delay_cycles(1000); // MHZ*1000
 }
}

char debounce (unsigned char BIT){
 if ((P1IN & BIT) == !BIT){ // If pushbutton's pressed
  delay(50); 
  if ((P1IN & BIT) == !BIT) return 1;
  else return 0;}
 else return 0;
}
 
char click (unsigned char BIT, char buttonNumber){
 newState = debounce(BIT);
 char clicked;

 if (newState == 1 && newState != oldState[buttonNumber]){
  clicked = 1;} 
 else clicked = 0;
 oldState[buttonNumber] = newState;
 return clicked;
}


int main(){
 WDTCTL = WDTPW | WDTHOLD; //Disables watchdog :)
 BCSCTL1 = CALBC1_1MHZ; //Aux clock 1MHZ
 DCOCTL = CALDCO_1MHZ; //DC0 1MHZ
 P1DIR |= BIT6; //BIT6 as output
 P1OUT = 0; //All pins LOW

 for(;;){ //Loops forever
  if (click(BIT3,0)) P1OUT ^=BIT6; //If click returns 1, flips bit 6 in the P1OUT register
 }

return 0; //I am worthless!
}

Tutto molto bello ma... questo è il forum di Arduino, non della TI... quindi prima che qualcuno dall'"alto" ti richiami... :wink:

leo72:
Tutto molto bello ma... questo è il forum di Arduino, non della TI... quindi prima che qualcuno dall'"alto" ti richiami... :wink:

Hai ragione: continuerò ad esercitarmi in privato (:
Poi, appena arriva l'LCD, riprendo a programmare per Arduino ^-^

Ciao,
bisogna anche dire che le versioni complete dell'ambiente di sviluppo grafico costano parecchio:

Alberto

bigjohnson:
Ciao,
bisogna anche dire che le versioni complete dell'ambiente di sviluppo grafico costano parecchio:
Microcontrollers (MCUs) & processors | TI.com

Alberto

Abbastanza, ma i chip della serie ValueLine hanno 2K, quindi anche la versione Free va benone (:
Se usi Linux, scrivi con l'editor che ti piace di più (niente editor-war, per favore :slight_smile: ), compili con gcc, carichi sul chip con mspdebug e non paghi nulla ^^

Ho passato il pomeriggio a compilare gcc-msp430 e tutte e sue dipendenze sul Netbook.

Ciao NeXTWay, mi puoi dire quale versione di gcc hai compilato?

Se usi Linux, scrivi con l'editor che ti piace di più (niente editor-war, per favore smiley ), compili con gcc, carichi sul chip con mspdebug e non paghi nulla ^^

Quindi hai compilato su GNU/Linux, io uso fedora 12 con gcc 4.4.4, tu su che distrò hai portato a termina la compilazione.

Ciao, grazie.

MauroTec:

Ho passato il pomeriggio a compilare gcc-msp430 e tutte e sue dipendenze sul Netbook.

Ciao NeXTWay, mi puoi dire quale versione di gcc hai compilato?

Se usi Linux, scrivi con l'editor che ti piace di più (niente editor-war, per favore smiley ), compili con gcc, carichi sul chip con mspdebug e non paghi nulla ^^

Quindi hai compilato su GNU/Linux, io uso fedora 12 con gcc 4.4.4, tu su che distrò hai portato a termina la compilazione.

Ciao, grazie.

Ciao, uso Arch con i repository testing (:
La versione di gcc è la 4.6.1
Non ho dovuto compilare gcc, ma gcc-msp430 (versione 4.5.3), mspdebug e le loro dipendenze .

Name : msp430-gcc
Arch : i686
Version : 3.2.3
Release : 3.20090210cvs.fc12
Per curiosità ho scritto: yum search msp43, e mi esce che nel repo c'è questa versione, io non credevo ci fosse. Se andasse bene non avrei bisogno neanche di compilare, al limite controllo se in F14 c'è una versione aggiornata.

Da GCC toolchain for MSP430 - Browse /mspgcc at SourceForge.net vedo che questa è l'ultima versione aggiornata.

questo mi piace: e' il modo che preferisco nello scrivere fw

  • vim/nano/nedit
  • gcc/g++
  • gdb
  • gmake/make
  • downloder specifico per il target
  • eventuali script, python, bash

Io no preferisco QtCreator o in genere un IDE decente, se sono costretto allora pasienza.

ma tornando al dicorso che si faceva, caro maurotec
questa credo che sia una altra arch per cui ADA non e' immediatamente fattibile a meno di bootstrap
(a meno cio' che qualche anima pia lo rilasci, e che quindi lo si possa usare per la compilata)

tutto sommato non mi dispiace: non ha troppo senso ADA su target di questo tipo
e per certi versi si puo' dimostrare che molti dei vantaggi che motivano ADA
si possono ottenere con artificio del c++ exception programming e overload vari
(va da se che la pedanteria di ADA non ha invece eguali)

Io poi ho lasciato perdere ADA, sono troppo impegnato e studiare ADA e sperimentare con le mcu ora non mi và. Mi pare che le exception in avr-gcc non sono presenti, e forse non lo sono neanche in mspgcc. Corregimi se sbaglio.

Sono indeciso se sia o meno il caso di prendere queste schedine. Poi io una P.Iva non c'è l'ho, e non sono uno studente, potrei fare un tentativo ma mi scoccia.

Ciao.

scusate se continuo il topic, capisco il conflitto, se i moderatori ritengono giusto chiudere capisco.

Nel frattempo vi aggiorno.

il pacco e' arrivato in 3 giorni, con fedex. incredibile visti i tempi a cui sono abituato.

il pacco contiene due micro, un quarzo da 32kH2, gli header da saldare se servono. la basetta e' leggermente piu' piccola di arduino ma ha 4 piedini comodissimi ed il cavo usb

Arduino prenda liberamente spunto, sono cose economiche ma che danno il senso di professionalita'.

la cosa che mi ha interessato e' questa http://processors.wiki.ti.com/index.php/Grace_Quick_Start_Guide?DCMP=Grace&HQS=Other+OT+grace#Welcome

che cosa e' ? si puo' creare uno scketch senza mettere mano al codice ?

Arduino non h niente del genere ?

P.S. il tutto pesa 430MB, quasi mezzo Giga, significhera' pur qualcosa :slight_smile:

Sono i cosiddetti "linguaggi visuali", non nel senso che abbiamo imparato a conoscere con il Visual Basic ma nel vero senso di "visuale", ossia di costruire il codice usando blocchi grafici.

Io sono all'antica e preferisco usare la vecchia tastiera

flameman:

NeXTWay:
uso Arch con i repository testing (:

uuuuu questo mi piace, se li ha arch, posso migrare e confezionare l'ebuild anche per gentoo
curiosita', se hai sbirciato la devchain

gcc e binutils hanno patch specifiche o tutto quanto e' gia' intree ?

Scusami ma nonostante la distro, sono poco più che in principiante (:
Quindi non so cosa voglia dire intree e cosa sia una devchain :S
Se è questo quello che vuoi sapere, Arch ha gcc e binutils nel repo core, il toolchain per msp430 si trova invece nel repo AUR (quello gestito dagli utenti).
Il toolchain (almeno su Arch) è composto così:

local/binutils-msp430 2.21.1-3
    A set of programs to assemble and manipulate binary and object files for 
    the MSP430 architecture
local/gcc-msp430 4.5.3-3
    GNU toolchain for the TI MSP430 processor
local/msp430-gdb 7.2-6
    GNU debugger for MSP430
local/msp430-libc 20110612-3
    C runtime library for the MSP430 family of microcontrollers
local/msp430mcu 20110613-4
    C headers and binutils linker scripts for microcontrollers in the MSP430 
    family

Il toolchain per avr invece sta sul repo community (quindi non dev'essere compilato)

Per tornare agli "spunti per Arduino", nella prossima versione sarebbe fantastico avere un jumper per escludere il led posto sul pin13 :smiley:

NeXTWay:
Per tornare agli "spunti per Arduino", nella prossima versione sarebbe fantastico avere un jumper per escludere il led posto sul pin13 :smiley:

ogni oggetto aggiunto = costi aggiuntivi

Tempo fa facevo presente il fatto che sarebbe stato bello avere un jumper per escludere l'auto-reset al posto del contatto da tagliare. Qualcuno mi fece lo stesso ragionamento che adesso io sto facendo a te... :wink:

leo72:
Sono i cosiddetti "linguaggi visuali", non nel senso che abbiamo imparato a conoscere con il Visual Basic ma nel vero senso di "visuale", ossia di costruire il codice usando blocchi grafici.

Se la cosa funziona cade il discorso che facevamo sulla difficolta' di lettura/scrittura del codice, in quanto e' un ulteriore livello che puo' non interessare.