Show Posts
Pages: 1 2 [3] 4 5 ... 195
31  International / Software / Re: Progetto Pulsante quick-run on: June 06, 2014, 06:49:08 pm
Qua per me l'esperto è @lesto che con java ci lavora.
Cerca in processing (o java) la classe Process (o simile), dovrebbe permetterti di lanciare applicazioni (processi in unix) e di monitorane lo stato, come pure di terminare l'applicazione.

Altra idea, l'ide di arduino lancia delle applicazioni, quali il compilatore avr-gcc, avr-g++ ecc se ci capisci di java, visto che il sorgente dell'ide è aperto puoi studiarti il codice per capire come fanno.

Ciao.
32  International / Software / Re: AVR-CoreLib on: June 06, 2014, 06:43:27 pm
MauroTec ti riferisci a questa ?
http://www.nongnu.org/avr-libc/avr-corelib/

Il mio sogno sarebbe un porting delle funzioni arduiniche da C++ a C, mantenendo l'alto livello (l'astrazione) del linguaggio tipico di arduino ?
Esatto.

Continua a sognare, perché non si può trasformare in realtà, anzi per me non avrebbe senso. Se scrivessi in C tutto quello che fa il core lib di arduino il codice finirebbe per essere lento e ingombrante uguale, e sarebbe pure più complesso da usare.

Dimmi se ha senso leggere dalla flash la corrispondenza dei pin se desidero efficienza?
Arduino è pensato per essere semplice e non conosco altro modo che quello usato da arduino, cioè nascondere la complessità. Nascondere la complessità significa ridurre la flessibilità.

Quando le risorse sono limitate come quelle di Arduino UNO le librerie preconfezionate sono da evitare. avr-corelib sarà un livello superiore a avr-libc ma non nasconderà la complessità e ridurrà  la flessibilità ed efficienza che sono gli obbiettivi principali.

Comunque qualcosa di Atmel c'è già parzialmente pronta, principalmente perché e multi architettura e multicompilatore, parlo della asf di Atmel, date uno sguardo al modo di gestire i gpio e ditemi cosa ne pensate.
Osservate i registri memory mapped di un Atmega e ditemi se da un indirizzo posso ricavare l'accesso tramite una comodo struttura (struct) tramite cast e anche i campi di bit senza creare nulla in memoria.

Questa è parte di quella che uso alle volte io (simile a asf):
Code:
#include <avr/io.h>

// Definizione del tipo di argomento GPIO
#define GPIO_T port_t *port, uint8_t bit

// port define
#define GPIOA ((port_t *) &_SFR_IO8(0x00))
#define GPIOB ((port_t *) &_SFR_IO8(0x03))
#define GPIOC ((port_t *) &_SFR_IO8(0x06))
#define GPIOD ((port_t *) &_SFR_IO8(0x09))

// define pin name for atmega164, 324 or 644
//      Name        PORTx,      Bit
#define GPIO_A0     GPIOA,      0
#define GPIO_A1     GPIOA,      1
#define GPIO_A2     GPIOA,      2
#define GPIO_A3     GPIOA,      3
#define GPIO_A4     GPIOA,      4
#define GPIO_A5     GPIOA,      5
#define GPIO_A6     GPIOA,      6
#define GPIO_A7     GPIOA,      7

#define GPIO_B0     GPIOB,      0
#define GPIO_B1     GPIOB,      1
#define GPIO_B2     GPIOB,      2
#define GPIO_B3     GPIOB,      3
#define GPIO_B4     GPIOB,      4
#define GPIO_B5     GPIOB,      5
#define GPIO_B6     GPIOB,      6
#define GPIO_B7     GPIOB,      7

#define GPIO_C0     GPIOC,      0
#define GPIO_C1     GPIOC,      1
#define GPIO_C2     GPIOC,      2
#define GPIO_C3     GPIOC,      3
#define GPIO_C4     GPIOC,      4
#define GPIO_C5     GPIOC,      5
#define GPIO_C6     GPIOC,      6
#define GPIO_C7     GPIOC,      7

#define GPIO_D0     GPIOD,      0
#define GPIO_D1     GPIOD,      1
#define GPIO_D2     GPIOD,      2
#define GPIO_D3     GPIOD,      3
#define GPIO_D4     GPIOD,      4
#define GPIO_D5     GPIOD,      5
#define GPIO_D6     GPIOD,      6
#define GPIO_D7     GPIOD,      7

typedef volatile uint8_t reg8b_t;

typedef enum
{
    out_mode,
    inp_mode,
    analog_mode,
    inp_pullup_mode
} pin_mode;


typedef struct
{
    reg8b_t r_pin;
    reg8b_t r_ddr;
    reg8b_t r_pout;

} port_t;

void gpio_modes(GPIO_T, pin_mode mode);

inline void gpio_off(GPIO_T)
{
    port->r_pout &= ~_BV(bit);       // imposta il bit off
}

inline void gpio_on(GPIO_T)
{
    port->r_pout |= _BV(bit);       // imposta il bit off
}

void gpio_set_to(GPIO_T, Bool bit_value);

inline void gpio_set(GPIO_T, Bool bit_value)
{
    (0==bit_value) ? (port->r_pout &= ~_BV(bit)) : (port->r_pout |= _BV(bit));
}

inline void gpio_flip(GPIO_T)
{
    //port->pout ^= _BV(bit);       // inverte il bit di porta out
    // il toggle bit hardware impiega meno codice e fa risparmiare circa 6 byte
    port->r_pin |= _BV(bit);
}

Bool gpio_state(GPIO_T);
Bool gpio_read(GPIO_T);

Quote
Allo stato attuale, poi, riconvertire il core di Arduino a C sarebbe improponibile.
Infatti, inoltre lo sviluppo C standard e cosa molto differente dallo sviluppo su Arduino dove non esiste
proprio il concetto di translation unit, in quando il preprocessore mortifica la flessibilità del C/C++ che in ottica arduino user rappresenta una complicazione. Complicato lo è per davvero, non è facile scrivere applicazioni con più moduli e non si impara dall'oggi al domani.

Ciao.
33  International / Software / Re: [Quesito di Logica] - Rilevare fascia oraria on: June 06, 2014, 02:24:10 pm
Sono anche io per convertire tutto in timestamp unix ma con epoch 2000.
In sviluppo c'è una libreria chiamata avr-corelib che poggia su avr-libc, cercando con google avr-libc time.h si trovano i link a repositor e discussioni in merito.
Un repositor che ho clonato è il seguente: https://github.com/vancegroup-mirrors/avr-libc.
Al momento la libreria non è separata dalla avr-libc ma visionando le linee guida si vede che i nomi sono in camel case e tutto anche la descrizione fa pensare ad una libreria che si separerà da avr-libc.
In quel repo ci sono funzioni per conversione da isotime a unix time e viceversa e varie alternative.
Inoltre ci sono le funzioni per chi ha necessità si sincronizzare con NTP, una serie di funzioni astronomiche che tengono conto della inclinazione dell'asse terrestre e tante altre cose che a causa della mia ignoranza astronomica (in astronomia) non comprendo. Se interessa l'argomento però conviene aprire un altro thread.

Ciao.
34  International / Generale / Re: Gestire una condizione di allarme on: June 05, 2014, 06:12:05 pm
Quote
Quote
per pablotec,
chi è? carino come nick ora lo cambio smiley smiley
Io allora sono Maurolos.  smiley-razz

Ho come l'impressione che al pin dell'allarme c'è collegato il meccanismo che si monta nell'avvolgibile delle tapparelle. Però se fosse così qualunque cambio di stato indifferentemente dallo stato di permanenza equivale ad un allarme, mentre il tuo codice controllo il cambio di stato ma l'allarme è presente solo se lo stato dell'ingresso che rileva l'allarme è LOW.

Puoi fare un prova per me?
Prendi il codice che dici funziona e metti a LOW l'ingresso allarme, togli l'alimentazione al circuito per poi fornirla nuovamente. Ho il dubbio che se l'alimentazione viene fornita mentre l'ingresso allarme è LOW non viene segnalata la condizione di allarme, la cosa potrebbe essere non desiderata o forse si.

Ciao.
35  International / Generale / Re: Gestire una condizione di allarme on: June 05, 2014, 12:53:20 pm
La logica io l'ho realizzata in base a come ho interpretato la tua spiegazione.

Ragionandoci, mi è sembrata funzionale e l'ho implementata.

Il funzionamento dovrebbe essere il seguente:
Se si presenta LOW all'ingresso allarme, (sia che ritorni HIGH o permanga nello stato di LOW) si passa all'else e la prima if non viene eseguita. Ti presenti davanti la centralina e vedi il led acceso e il buzzer suona, taciti il buzzer, e viene letto lo stato di allarme che accende o spegne il led ed inoltre se alarmState == LOW si passa al prossimo ciclo ad eseguire la prima if.

Quote
Lo stato temporaneo di AckPin=LOW deve essere memorizzata per consentire al LED di spegnersi autonomamente.

Mi spiace mi sfugge la logica, il led credevo dovesse rimanere acceso anche se il buzzer viene tacitato e il led
si spegne solo se il pin alarm è LOW.

Poi certo risolta la causa che tiene il led acceso devi azzerare l'allarme che in sostanza equivale a premere una combinazioni di tasti o entrare in un menu e confermare la segnalazione di allarme. Ora mi sono accorto che ci sono commenti errati nel codice, ora vedo e correggo.

Ciao.
36  International / Generale / Re: Costruzione di un calcolatrice on: June 04, 2014, 05:48:35 pm
In merito alla calcolatrice occhio alla logica di funzionamento ancora prima di passare al codice, cioè l'analisi è importante. Se non è stato introdotto alcun numero, la pressione degli altri pulsanti delle operazioni non deve sortire alcun effetto. Se invece è stato digitato un numero la pressione di uno dei tasti delle operazioni salva nella variabile currentOperation 1, 2, 3, 4 per le 4 conosciute operazioni.
Se pigi il tasto canc tutto deve ripartire da currentOperation = 0 cioè operazioni non selezionata;
Tutti questi ragionamenti devono essere fatti a tavolino scritti in un linguaggio a te comprensibile e poi
passo passo codificati nel linguaggio di Arduino.

Ciao.
37  International / Generale / Re: Gestire una condizione di allarme on: June 04, 2014, 05:31:51 pm
Quote
quando il livellostato cambia stato
mmm... dal codice precedente non ti serve tracciare il cambio di stato ma il passaggio di stato da HIGH -> LOW.

Code:
boolean alarmState = LOW;
boolean buzzerState = HIGH

void setup()
{
}

void loop()
{
If (alarmState == LOW) {
     //alarmState = !digitaleRead(AlarmPin);
     buzzerState = alarmState = !digitaleRead(AlarmPin);;
} else  {
    // se è in allarme

    if (digitalRead(AckPin) == LOW) {
            buzzerState = LOW;                                       // spegne il buzzer
            alarmState = !digitaleRead(AlarmPin);         // legge il pin alarmPin
            // nota che se alarmState è LOW al prossimo ciclo non entra nell'else ma nell'if
    }
    digitalWrite(AlarmBuzzerPin, buzzerState);                         // buzzer on  
    digitalWrite(AlarmLedPin, alarmState);                               // alarm led on if alarmState is HIGH or led off se alarmState is LOW

}
Penso che così dovrebbe funzionare, se si non rimane che trasformarlo in funzioni e visto che tutte le variabili
sono globali tutto il codice può essere spostato in una funzione che non prende e non restituisce nulla.
Es:
Code:
void checkAlarmState()  // controlla lo stato allarmi
{

}

ciao.
38  International / Generale / Re: Gestire una condizione di allarme on: June 04, 2014, 01:21:25 pm
Ora la descrizione di cosa deve fare il codice mi risulta più chiara.

Tuttavia c'è necessità di riconferma.

Quote
Quando contatto malfunzionamento diviene Basso, si accende il LED e suona il cicalino.
 ( il contatto si chiude per un attimo, oppure rimane chiuso fino alla fine della causa che lo ha attivato)
Se ingresso ritorna normale, il LED e cicalino sono ALTI

Questa parte deve essere chiarita con precisione.
Io potrei scrivere qualcosa di simile a:

If (alarmState == LOW)
     alarmState = !digitaleRead(AlarmPin);

Il quale legge lo stato del pin alarm solo se l'applicazione *non* è in alarm.
Visto che la condizioni di presenza alarm è LOW, ma lo stato di anomalia di solito equivale a alarm = HIGH, per questo inverto ciò che leggo e lo salvo in alarmState.

alarmState: uguale LOW Non è in allarme, uguale HIGH è in allarme
Nota tra parentesi lo stato invertito grazie a ! prima di digitalRead(AlarmPin)
digitaleRead(AlarmPin): restituisce HIGH (LOW) se non in allarme, LOW (HIGH) se è in allarme.

A questo codice non importa se la condizioni di allarme sul pin è rientrata nelle condizioni normali e una volta che
alarmState == HIGH non esegue più la lettura del pin, quindi ciò che comanda lo stato di alarmState.
Come dire se l'applicazione è in allarme prima di ricontrollare se permane la condizione di allarme devo spegnere
l'allarme con la pressione di una combinazione di tasti.

Potrebbe essere questo il comportamento voluto oppure no, perché magari il controller deve fare altro di utile anche quando è in condizione di allarme.

PS: sembra banale ma non lo è. Devi stabilire la logica e esprimerla in modo non fraintendibile.

Ciao.
39  International / Generale / Re: Gestire una condizione di allarme on: June 04, 2014, 05:39:13 am
Come vedi, dividere il codice in funzioni permette di concentrarsi sui dettaglio isolando il resto del codice.
Code:
boolean checkInputChange (int inPin)      // funzione controlla cambio stato ingresso
{
    inputState = digitalRead(inPin);
    if (inputState != lastInputState) {
        lastInputState = inputState;
        return HIGH;
    }
    return LOW;
}

Non serve salvare lo stato "result" quindi si risparmia una variabile globale, che qui poteva anche essere locale.
lastInputState invece occorre che conservi il valore tra una chiamata e l'altra e questo lo si può fare usando variabili globali o static local.

Code:
boolean checkInputChange (byte inPin)      // funzione controlla cambio stato ingresso
{
    static boolean lastInputState = LOW;      // lastInputState now is static local variable
    boolean inputState = digitalRead(inPin); // now inputState is local variable

    if (inputState != lastInputState) {
        lastInputState = inputState;
        return HIGH;
    }
    return LOW;
}

(int inPin) o (byte inPin) ??
Non esiste un pin negativo (-5) per cui, <byte> è il tipo di dato più adatto a contenere il numero del pin.

In un solo colpo abbiamo rimosso due variabili globali e ridotto la quantità di codice sorgente e questo
migliora anche la leggibilità del codice sorgente. Inoltre lastInputState e inputState sono dichiarate vicino
a dove vengono impiegate e non è necessario andare a cercare tra le globali per vedere di che tipo sono,
per cui osservando la funzione li dentro ci sono tutte le info per capire cosa fa la funzione.

Ciao.

 
40  International / Generale / Re: Gestire una condizione di allarme on: June 03, 2014, 11:39:56 am
Certo tutto quel codice nel loop nella previsione che ti serva inserire altro codice nel porta il loop ad essere poco leggibile dal programmatore e difficile da seguire. Stabiliamo che l'importante per adesso è fallo funzionare come non importa. La successiva fase potrebbe essere quella di spostare quel codice dentro una o più funzioni di modo che nel loop ci sia qualcosa di simile a:
Code:
checkAlarm();
/* //oppure
if (checkAlarm()) {

}
*/
Nel secondo caso checkAlarm ritorna true o false, quindi:
Code:
boolean checkAlarm() {
    AlrmState = digitalRead(AlrmPin);    // legge stato ingresso
    if (AlrmState != lastAlrmState) {   
    // ecc
}

Durante la creazioni di una o più funzioni per snellire il loop() chiediti se alcune variabili possono essere
locali alle varie funzioni e non tutte globali. Es AlrmState potrebbe essere dichiarata dentro checkAlarm e quindi locale, tanto di serve solo per conservare lo stato della lettura digitalRead, se ti serve conservare lo stato della condizioni di allarme puoi usare una variabile globale numerica dove 1 == allarme presente non tacitato, 2 == allarme presente tacitato, 3 == altro.

Fai bene a chiederti come semplificare il codice e il primo passo e quello di distribuire il codice in una o più funzioni che prendono e/o ritornano parametri se necessario. Questo ti aiuta a scrivere un codice più comprensibile, ed è anche possibile che durante questo lavoro tu trovi un modo per ridurre il codice.

PS: Di norma i nomi di classi o enum o in genere i tipi di dato utente sono scritti così: AlrmState il che fa pensare che si tratti di una classe o struct o altro tipo, per evitare fraintendimenti le variabili iniziano con la minuscola: alrmState. Non abbreviare per ridurre la dimensione del codice perché non serve a nulla, alarmState o alrmState ai fini della occupazioni dello spazio sono la stessa cosa in quanto quando il tuo codice si trasforma in firmware,
tutti gli identificativi (nomi di variabili, classi, oggetti ecc) vengono rimossi e trasformati in indirizzi di memoria.

Gli identificativi o simboli dichiarati e non usati (non referenziati) vengono rimossi dal compilatore grazie al parametro gc-section usato da arduino.

Ciao.
41  International / Software / Re: SAM3X8E (Arduino DUE) manipolazione registri PIO on: June 02, 2014, 01:12:29 pm
Emicrania con l'aura, vedo tutto seghettato, quindi ti leggero meglio appena passa.

Quote
cosa intendi? l'ARM Cortex in generale è superato? obsoleto?
No, non è superato per niente, dicevo che considerare superata la Arduino DUE e non la Zero visto che montano entrambe microcontroller ARM e almeno opinabile.

Per di più la DUE ha un clock è una dotazione interna all'ARM superiore al cortex-0 montato sulla Zero e non escludo che studiando il datasheet del SAM e del cortex molte cose sono simili se non identiche.
Per di più rimanendo in casa Atmel non dobbiamo scontrarci con documentazione di altri produttori che se alla lunga può anche essere giudicata migliore e sempre qualcosa di estraneo a noi abituati alla doc Atmel.

Quote
Diciamo che è raro che qualcuno voglia leggere un OUTPUT quando è il programmatore stesso che lo attiva o disattiva, normalmente è importante da parte del programma conoscere lo stato degli INPUT, però su richiesta dovrei riuscire a leggerlo

Per me è un impedimento, in quanto uso il registro per ricavare lo stato di una uscita. Pensa alle uscite temporizzate e/o in pending temporizzato o comunque legate a più di una variabile di stato, queste si accenderanno e spegneranno senza che il programmatore ne possa avere certezza dello stato, per cui o lo salva in una variabile (occupa spazio ram) o con if (pinState(GPIOA, PA7)) legge direttamente lo stato del pin risparmiando ram e leggendo direttamente lo stato e non una copia che potrebbe non essere in sincro.

Ciao.
42  International / Software / Re: SAM3X8E (Arduino DUE) manipolazione registri PIO on: June 02, 2014, 10:10:41 am
Quote
Qui c'è un altra bella sorpresa che ho visto ieri, quando setto un pin in INPUT tutto il PIO che contiene quel pin va a 1, poichè in automatico sono in PULLUP

Allora c'è un bug. Però è strano quello che dici, tutto il PIO intendi tutto Port IO, poi però dici che solo quel pin funziona in input con pull-up e questo è corretto.

Aspetta sto confuso, vediamo se l'impostazione di un pin mode coinvolge tutta la porta allora c'è un bug, ma solo per logica perché sarei costretto ad usare tutta la porta come imput.

Quote
in questo caso il digitalread mi indica 1 e se porto il pin su GND mi indica correttamente 0, ma solo il pin interessato, tutti gli altri restano a 1

E se metti a GND un altro pin di quella porta cosa legge digitalRead().

PS: Arduino 2 o zero sempre ARM è quindi obsoleto e quanto meno opinabile.

Le porte dell'ARM non sono così semplici come quelle di AVR atmega, già con Xmega diventano complicate, anche se l'architettura di xmega semplifica e agevola molto. Occorre leggere il datasheet del sam e impostare i pin manualmente.

Buon divertimento  smiley-twist

Ciao.

43  International / Hardware / Re: lettura imprecisa di un encoder on: June 02, 2014, 09:57:19 am
Non sarebbe male se arduino avesse una libreria per il debug via seriale non bufferizzata, io la uso sempre non bufferizzata e posso fare debug facilmente anche quando ci sono parecchi eventi, in questo caso sarà la print che viene interrotta da gli altri eventi e raramente le ISR prendono molto tempo CPU per cui non noto nemmeno rallentamenti nella seriale. Ancora meglio sarebbe se la serial non bufferizzata non usasse del tutto le classi o comunque fare una routine stretta stretta e solo per fare debug, tipo stampa stringa e stampa long int.

Ciao.
44  International / Software / Re: Che altri metodi oltre gli interrupt? on: June 02, 2014, 09:48:16 am
Quote
Mi devo ripresentare??? smiley
Si, cioè no è necessario ma quanto meno dicci qual'era il tuo vecchio nick.

Quote
Mi chiedevo se ci sono altri metodi oltre gli interrupt.
Gli interrupt agganciati ad un timer hardware per contare il tempo sono l'unica soluzione che conosco, come pure un hardware esterno che invia impulsi ogni 1ms su un pin agganciato ad interrupt.

Se le tempistiche non devono rispettare vincoli ristretti millis() (ma anche micros()) sono da preferire, ma occorre fare attenzione a richiamare il codice che controlla il tempo e agisce di conseguenza il più spesso possibile, altrimenti l'azione potrebbe non essere eseguita, per ovviare si deve anche stare attenti al modo in cui si scrive il controllo del tempo. Un concetto sui timer potrebbe essere quello che la funzione che controlla il tempo ritorna timerHasSpired o timerHasNotSpired, cioè il timer è scaduto o non è scaduto.

Cerca nel forum, di recente si è parlato della questione.

ciao.
45  International / Software / Re: SAM3X8E (Arduino DUE) manipolazione registri PIO on: June 02, 2014, 09:36:43 am
Prova:
pinMode(13, INPUT);

Fai cambiare stato al pin da esterno e vediamo se digitalRead lavora correttamente.

Ciao.
Pages: 1 2 [3] 4 5 ... 195