...Recoaro!
il problema vero, in effetti, è fare il codice...

... la eeprom interna quanto è? perchè,se il codice lo compilo x la eeprom esterna, quella interna resta vuota (quindi usabile), giusto?

Devo riordinare un poco il codice, poi tra poco posterò la versione 1.0 della PPTEA_DOMOTICA by ZaK, configurabile.

Fantastico...un altro tassello!
Ciao
Bolle

Adesso serve il sw lato PC/Smartphone/cellulare

Allora, ecco la versione BETA del codice della mia domotica modulare.
Questo è il codice relativo al singolo nodo slave, al momento manca la gestione della comunicazione con il modulo master.
Come annunciato, il nodo ha una tabella di commutazione programmabile senza bisogno di modificare il codice EABASIC; viene
utilizzata la EEPROM esterna per il codice, mentre i 256byte interni al PIC sono usati come memoria del nodo. Al momento,
la programmazione viene eseguita via porta USB, dove il PPTEA si pone in ascolto quando riscontra determinate condizioni.
Il nodo ha 4 linee di ingresso, corrispondenti ai bit 11-12-13-14 del PPTEA, quindi normalmente alte per via delle
resistenze di pull interne; la combinazione 0000 pone il nodo in ascolto per la programmazione, la combinazione 1111 è
quella di riposo (nessun ingresso attuato), tutte le altre (14) sono disponibili all'uso. Nella situazione più semplice,
possiamo immaginare di avere 4 pulsanti collegati, uno per linea. Il nodo dispone inoltre di 7 linee di uscita digitali
(bit 2-8), due ingressi analogici (CAD 0-1), una linea di segnalazione (bit 15).

Vediamo il funzionamento:
per ogni pulsante esistono due timeout, che identificano quindi tre durate della commutazione, breve, media, lunga.
Sulla base del pulsante premuto e del tempo per cui si tene premuto, viene letta una cella diversa nella memoria, cella che
contiene la commutazione da effettuare sulle uscite. Al momento, la pressione breve e media eseguono un "toggle"
(commutazione) dello stato di una o più uscite, mentre la pressione lunga impone un nuovo stato alle uscite indipendente
da quello precedente. Lo stato delle uscite viene memorizzato anch'esso nella memoria del PIC.

Le uscite possono essere configurate per utilizzare relè standard oppure step; nel secondo caso, anzichè avere in uscita un
livello logico alto stabile, viene generato un impulso (mi viene in mente ora mentre scrivo che sarebbe opportuno poterne
modificare la durata... FATTO!) per far eseguire uno step al rele.

Ricapitolando, la pressione di un pulsante mi dà un valore P_ADDR da 1 a 14, la durata della pressione mi dà un valore
T_ADDR da 0 a 2, l'indirizzo della cella da leggere sarà RC=P_ADDR*3+T_ADDR, per un totale di 44 celle di memoria. La
RC-esima cella conterrà un byte che modificherà lo stato delle uscite: per T_ADDR pari a 0 ed 1, verrà fatto lo XOR tra lo
stato attuale delle uscite (OLD_OUT) ed il byte letto (MOD_OUT), per T_ADDR=2 MOD_OUT=NEW_OUT. Poi, sulla base del tipo di
relè, NEW_OUT verrà riportato sulle uscite; in caso di relè monostabili lo stato delle uscite sarà uguale ai bit di
NEW_OUT, altrimenti verranno generati gli impulsi sulle uscite adatte per portare lo stato dei relè step alla
configurazione desiderata.

Spero di essermi capito

Adesso mi dedichero alla definizione di un protocollo di comunicazione master/slave e alla routine di comunicazione; se nel
frattempo trovate migliorie da fare, ditemelo.

Allego un file con il file .eab ed un file .xls per la programmazione. Eseguendo il codice, oppure simulandolo, il PPTEA si
mette in modo programmazione se ha tutti gli ingressi a "0" oppure se trova il byte nella cella 255 diverso da &hAA (170
decimale, 10101010 binario) oppure se trova un'errore nella programmazione del tipo di rele.
Qui uno schemino di principio, senza pretese.

... del tempo per cui si tene premuto...
[/QUOTE]
Cavolo...questa me l'ero persa...notevole, veramente notevole.
Ora ho poco tempo poi guardo tutto con estrema calma.
Ciao
Bolle

... beh, direi che è una delle cose fondamentali, associare più comandi allo stesso pulsante... risparmi sul cablaggio, sulle parti, fa figo e non impegna
Ovviamente le pressioni multiple non sono gestite, a meno di non divertirsi con le combinazioni...

Ho letto attentamente quello che hai fatto/scritto...probabilmente ti seguiranno in pochi...con alcuni esempi il lavorone si capirà meglio! Hai implementato anche il sistema di configurazione del modulino...se ti interessa possiamo farlo mediante un eseguibile....sempre se non l'hai già fatto/pensato.
Ciao
Bolle

Beh, il progetto è a disposizione, poi se a nessuno interessa, pace, io lo faccio per mio uso e lo metto a disposizione per conoscenza/spunto.
La configurazione per ora è molto "didattica" (nel senso che, essendo tutti byte o meno, tu m'insegni che non serve inviare quella marea di caratteri, ma così è più comprensibile); la versione finale, realizzata e quindi operativa, dovrà accettare la configurazione (anche?) via seriale su CAN da PPTEA master. Per un sw ad alto livello (su Rasp, PC, Duinomite o quant'altro troveremo) per configurazioni e funzioni evolute (sgancio carichi quando eccede l'assorbimento etc...etc...etc... salute! e magari la possibilità di interagire via bluetooth con telefonini, mi affiderò alle competenze di altri... io riesco (male) a fare qualche cavolata con il VBA di XL, e non ho ancora provato a parlare col PPTEA, sempre per la tirannia di Cronos cui sei soggetto pure tu, mi pare

Nuova versione per il codice domotica PPTEA. Implementato l'ascolto e la risposta ad interrogazioni da parte del master via seriale, programmazione della tabella di commutazione ancora solo via USB... allegato anche file XL per programmazione e comunicazione.
Per ora rimane tutto poco documentato, causa dittatura temporale... appena riesco completo tutto con spiegazione dettagliata ed esempi. Nanotte.

Bolle, ho un problema con la comunicazione USB tra compiler e PPTEA che esegue il codice della domotica... il comportamento è diverso rispetto a quello che avviene nel debugger, il PPTEA attende i dati, ma sembra che legga le stringhe inviate solo in parte... adesso sto rifacendo la routine, ti faccio sapere evoluzioni, ma se nel frattempo provi, magari trovi qualche cosa da sistemare... Grazie, ciao!

nuova versione del codice domotico... con questa dovremmo esserci , funziona tutto , è possibile programmare la tabella delle commutazioni inviando due stringhe di 50 byte direttamente dal compiler , e via usb si ha anche una idea di cosa sta succedendo ...
Adesso inizio con gli esempi, se non ci sono controindicazioni. Ciao !

Allora, iniziamo con qualche esempio di programmazione del sistema domotico.

Parto dalla mia applicazione "sul campo", ovvero b&b:
abbiamo una camera matrimoniale, con bagno; lampada della stanza, due lampade ai lati del letto, lampada del bagno, lampada dello specchio, quattro prese e cinque punti di comando. Quali funzioni voglio implementare? In un impianto tradizionale da Pb1 agirei su L1, da Pb2 su L2 (se volessi agire da piu punti su L1 dovrei cablare ogni comando aggiuntivo) e così via. Io, dovendolo realizzare ex novo, ho fatto una cosa diversa, sfruttando il PPTEA; ho creato una tabella del genere:


Comando-Pressione-------Pressione-------Pressione
--------Breve-----------Media-----------Lunga

Pb1-----Accende/Spegne--Accende/Spegne--SpegneTutto
--------L1--------------L2+L3-----------accende L1

Pb2-----Accende/Spegne--Accende/Spegne--SpegneTutto
--------L2--------------L3--------------accende L2

Pb3-----Accende/Spegne--Accende/Spegne--SpegneTutto
--------L3--------------L2--------------accende L3

Pb4-----Accende/Spegne--Accende/Spegne--SpegneTutto
--------L4--------------L5--------------accende L4


In questa maniera, da qualsiasi comando posso spegnere tutte le luci, mantenendo accesa solo quella dove mi trovo; se sono a letto posso da entrambi i lati agire sulla luce della stanza e su entrambe le luci di lettura, andando in bagno di notte posso accendere la luce di lettura per muovermi e una volta arrivato spegnerla e lasciare accesa quella del bagno, andandomene dalla stanza posso spegnere tutto quanto con un solo comando. Inoltre, riduco drasticamente il numero di cavi e componenti necessari per implementare anche solo parzialmente quanto sopra, pensiamo al comando luci stanza/luci lettura; lavorando senza relè dovrei usare due deviatori ed un doppio deviatore per il comando di L1 da tre punti, con 4 fili che arrivano al doppio e tre fili a ciascuno dei
deviatori singoli, piu due deviatori ad ogni lato del letto per il comando separato di L2 ed L3. Utilizzando rele, dovrei mettere ad ogni lato del letto tre pulsanti, piu un pulsante alla porta, ed in entrambe le soluzioni perderei la possibilità di spegnere tutto da qualsiasi punto.

Vediamo come implementerò quanto sopra sfruttando il mio codice domotico:

Il PPTEA/DOMO possiede 4 linee di ingresso e 7 linee di uscita, in questo semplice caso assegno ad ogni punto di comando una linea di input e ad ogni lampada una linea di output:

Pb1 - IN1 - bit 11
Pb2 - IN2 - bit 12
Pb3 - IN3 - bit 13
Pb4 - IN4 - bit 14

questi bit del PPTEA hanno delle resistenze di pull-up interne, quindi utilizzerò dei pulsanti NA in chiusura verso massa, in questo modo lo stato di riposo corrisponderà allƇ e lo stato di

pulsante premuto allo 0.

L1 - OUT1 - bit 2
L2 - OUT2 - bit 3
L3 - OUT3 - bit 4
L4 - OUT4 - bit 5
L5 - OUT5 - bit 6

Inoltre, per ogni ingresso, vengono discriminati tre tempi di pressione del pulsante (configurabili), pressione di breve durata (minore di un secondo), pressione di media durata (tra uno e due secondi), pressione di lunga durata (più di due secondi).
A ciascuno, corrisponde una azione sulle uscite, per la pressione di breve e media durata, il PPTEA inverte lo stato di una o più uscite (ad esempio, se la OUT1 era a 0, passa a 1, e viceversa), per la pressione di lunga durata, viene invece impostato uno stato delle uscite indipendente da quello precedente. Queste azioni sono configurabili senza dover modificare e ricaricare il codice EAB della domotica, dato che sono dei bytes immagazzinati nella memoria del PPTEA, e sono modificabili mettendo il nodo in modalità programmazione. Vediamo quindi cosa accade se premo il pulsante Pb1 per un tempo inferiore ad un secondo: il PPTEA calcola l'indirizzo della cella di memoria e carica il byte in essa contenuto (MOD_OUT nel codice); di questo byte, i primi 7 bit corrispondono alle uscite del nodo. Il PPTEA, a questo punto, esegue la commutazione delle uscite il cui bit in MOD_OUT si trova ad 1; in pratica, esegue lo XOR (OR esclusivo, disuguaglianza logica) tra lo stato precedente delle uscite (OLD_OUT) e la maschera di commutazione; nella applicazione descritta sopra, la pressione breve di Pb1, collegato ad IN1 agisce sullo stato di L1, collegata alla OUT1 accendendola:


__________________OUT
__________________7654321
OLD_OUT (binario) 0000000 XOR
MOD_OUT (binario) 0000001 =
------------------------------------
NEW_OUT (binario) 0000001



Se lo stato dell'uscita 1 fosse stato 1, la stessa operazione avrebbe avuto come esito lo spegnimento di L1:


__________________OUT
__________________7654321
OLD_OUT (binario) 0000001 XOR
MOD_OUT (binario) 0000001 =
------------------------------------
NEW_OUT (binario) 0000000


difatti, la tabella di verità dello XOR è:

A B| U=A XOR B
0 0| 0
0 1| 1
1 0| 1
1 1| 0

da cui il nome "disuguaglianza logica", il suo valore è 1 se i gli operandi cui si applica hanno valori diversi.

Per la pressione media, il funzionamento è lo stesso; per la pressione lunga, invece, MOD_OUT contiene il nuovo stato delle uscite, indipendente dal contenuto di OLD_OUT:


__________________OUT
__________________7654321
OLD_OUT (binario) xxxxxxx
MOD_OUT (binario) 1010101 =
------------------------------------
NEW_OUT (binario) 1010101


Pertanto, la programmazione del nodo sarà la seguente:


(puls)-IN--------PRESSIONE---OUT
-------1234------------------7654321
(Pb1)--0001------breve-------0000001
-----------------media-------0000110
-----------------lunga-------0000001
(Pb2)--0010------breve-------0000010
-----------------media-------0000100
-----------------lunga-------0000010
(Pb3)--0100------breve-------0000100
-----------------media-------0000010
-----------------lunga-------0000100
(Pb4)--1000------breve-------0001000
-----------------media-------0010000
-----------------lunga-------0001000

In realtà, nelle celle di memoria dobbiamo scrivere un byte, quindi 8 bit e non 7; pertanto bisogna aggiungere un bit a quelli della colonna OUT.
L'indirizzo della cella di memoria corrispondente alla combinazione di ingresso e tempo di pressione viene calcolato con la formula CELL=(P_ADDR*3)+T_ADDR dove P_ADDR è il numero (binario a 4 bit) del pulsante premuto, e T_ADDR un valore intero da 0 a 2 che corrisponde alla pressione breve, media o lunga. Quindi, per l'ingresso 1, gli indirizzi corrispondenti alle tre soglie saranno 3-4-5, per l'ingresso 2 saranno 6-7-8 e cosi via. Nell'esempio, il pulsante Pb3, essendo collegato a IN3, avrà come numero 2^3 ovvero 8, quindi le celle di memoria da usare saranno 24-25-26. Ma quale memoria utilizzano questi dati? Visto che il codice EAB è troppo grande per la memoria interna e viene pertanto usata la EEPROM esterna, rimangono i 256byte interni al PPTEA, piu che sufficenti ad alloggiare tutti i dati. Ma come posso inserirli? nel codice PPTEA/DOMO è prevista la modalità configurazione: il codice si pone in attesa di ricevere sulla porta USB i valori da memorizzare, composti da coppie di bytes, il primo è l'indirizzo della cella, il secondo il valore contenuto. Il codice entra in questa modalità in due casi: se gli ingressi sono tutti e 4 a livello 0, oppure se il contenuto della cella 255 è diverso dal valore 170, ovvero &hAA. Il PPTEA invia sulla porta USB il messaggio "WAITING..." ed attende di ricevere i dati: ricevuti 50 bytes vengono inseriti in memoria, ed il programma si rimette in attesa di ricevere altri dati; per uscire da questo stato occorre inviare la sequenza "STOP".
Oltre ai dati di commutazione, nella memoria vengono inseriti anche altri valori di conficurazione: la cella 255 come detto contiene un valore relativo allo stato della programmazione; nella 254 l'ID del nodo nelle comunicazioni nodo-master di cui parlerò piu avanti; nella 253 il tipo di relè che viene utilizzato, monostabile o bistabile (passo-passo), nella 252 la durata dell'impulso di comando per i relè passo; nelle 251 e 250 vi sono i timeout che discriminano i tempi di pressione; nella 249 la durata del waitms inserito nel ciclo di misura del tempo di pressione; nella 248 la velocità della porta seriale per le comunicazioni nodo-master.
Nel file Excel allegato al codice, vi è una tabella da compilare che permette di generare le stringhe di configurazione, contenute nelle celle B3-B4-B5; queste vanno copiate ed incollate nel compilatore, nell'area "Inp USB (PIC <-PC)" del debugger oppure, per programmare un PPTEA/DOMO hardware, nell'area "USB TX str". A causa di una particolarità della funzione CODICE.CARATT di MSExcel, che non restituisce un carattere valido per il byte 0, ed anche per non avere problemi con i caratteri "non stampabili" in fase di copia e incolla, ho dovuto sommare 64 sia all'indirizzo della cella che al valore in essa contenuto per le celle relative alla tabella di commutazione. Questa particolarità forse scomparirà quando riuscirò a scrivere un pò di codice VBA per comunicare
direttamente col PPTEA via Excel. Ultima novità in questa versione del codice, la possibilità di assegnare un valore "NO_OP" (no operazione) alle celle della tabella di commutazione, in pratica, se il bit MSB della cella è a 1 (valore della cella > 127) non viene eseguita nessuna modifica allo stato delle uscite.

Nella prossima puntata la descrizione del protocollo di comunicazione.
Buonanotte!