RyujiAndy

non dimenticare di collegare una resistenza da 10k tra PortA.1 e massa, questo perchè il pic reagisce alla differenza di potenziale non alla corrente, poi una volta definita la funzione della porta puoi richiamare lo stato questo devi farlo di continuo questo perchè la variabile prende il valore della porta ogni volta che viene assegnata poi con un confronto puoi definirgli la funzione dei led, anche durante il ciclo si esecuzione devi continuamente assegnare la variabile fare un confronto.

Sta arrivando natale perchè non fai qualche combinazione di luci lampeggianti per l'occasione, con un pulsante magari per cambiare il tipo di lampeggiamento?

Ho Già lavorato con shede montanti microcontrollori della texas instruments, ed in fondo sono tutti analoghi, ma per lavoro utilizzo molto gli avr e a dire il vero è da poco che ho scoperto la piattaforma arduino, che in fondo non è che un IDE e un bootloader, quest'ultimo non è sempre necessario

l'utilità di usare l'atmel senza cristallo esterno, sono soprattutto il risparmio energetico e quindi la possibilità di aumentare il tempo di alimentazione tramite batteria, di norma e regola anche io uso sempre un clock esterno, soprattutto perchè ho la mania di interfacciare i miei proggetti ad internet tramite i modulo RJ45.

Molti si chiederanno se è necessario comprare un nuovo Arduino ogni volta che si realizza un progetto utilizzando la board. Ovvero... "per costruire qualcos'altro... devo prima procurarmi un altro Arduino?" Sarete felici di sapere che non è sempre indispensabile. Infatti il cuore di arduino uno non è altro che l'atmega328p, un microcontrollore ad 8-bit prodotto dalla avr. La casa costruttrice ci fornisce un programmatore ed una IDE anche per i microcontroller della famiglia Atmega, ma diventa difficile programmare direttamente il 328p o qualsiasi altro chip per chi non è del mestiere, è molto più semplice collegare un chip vergine ad un Arduino utilizzato come programmatore, e utilizzare gli strumenti per Arduino al fine di programmarlo... a programmazione terminata potremo scollegare il nostro "Arduino-programmatore" e usare il chip indipendentemente dalla board. Il chip infatti ha già all'interno un oscillatore che genera tramite un quarzo da 8 MHz il clock che gli serve per processare nel tempo i comandi. Su Arduino invece si ha un quarzo da 16Mhz, che permette di velocizzare l'esecuzione dei comandi. Il microcontrollore è una sorta di piccola CPU in sostanza, e utilizzando una frequenza di 16Mhz anzichè quella di 8 prevista dal produttore sul chip è come se lo stessimo "overcloccando". La frequenza massima di clock prevista dal produttore per l'atmega328p è di 20Mhz. Il Bootloader di arduino è una piccola componente software (comandi) che occupano 0.5 Kb e servono soprattutto per caricare i nostri programmi senza l'ausilio di un programmatore (tramite un seriale TTL). Infatti andando a vedere lo schema elettrico di arduino, tra la porta usb e l'atmega328p troviamo un atmega16u2 che viene utilizzato come "convertirore" da usb a porta seriale rs232. La porta seriale è utilizzata per la programmazione del microcontrollore. Sui vecchi Arduino seriali come il Severino (vedi foto) infatti mancava completamente il chip che provvedeva la conversione della porta, in quanto l'USB è stato aggiunto per comodità sulle board più recenti, in modo da permetterne la programmazione anche con i computer portatili. [imgx] http://images.nonsologaming.com/ArduinoSeverino400.jpg[/imgx] Per adattare il microcontrollore a funzionare senza l'ausilio dell'intera board dobbiamo specificare all'IDE quali sono i suoi nuovi parametri di funzionamento: basterà aprire il file boards.txt che troviamo nella cartella del programma di arduino e aggiungere le seguenti righe: ############################################################## atmega328.name=ATmega328 on a breadboard (8 MHz internal clock) atmega328.upload.protocol=stk500 atmega328.upload.maximum_size=32768 atmega328.upload.speed=57600 atmega328.upload.using=arduino:arduinoisp atmega328.bootloader.low_fuses=0xE2 atmega328.bootloader.high_fuses=0xDA atmega328.bootloader.extended_fuses=0x05 atmega328.bootloader.path=arduino:atmega atmega328.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex atmega328.bootloader.unlock_bits=0x3F atmega328.bootloader.lock_bits=0x0F atmega328.build.mcu=atmega328p atmega328.build.f_cpu=8000000L atmega328.build.core=arduino:arduino ############################################################## Per programmare il chip senza dover comprare un programmatore possiamo utilizzare direttamente un arduino (montato, con su il suo chip atmega). Basterà seguire il seguente schema: http://images.nonsologaming.com/arduinoisp2.png Io ho provato l'operazione su varie versioni dell'IDE, e la 0022 è quella che mi ha dato meno errori. Una volta aperto l'IDE dobbiamo andare a cercare negli esempi lo sketch ArduinoISP: carichiamolo su Arduino, poi colleghiamo un condensatore da 22uF tra il Reset e GND di Arduino, selezioniamo la board atmega328 che abbiamo creato in precedenza... e potremo andare a caricare sul chip il nostro programma. Al termine dell'operazione non servirà nè il clock esterno nè la board per il funzionamento dell'integrato dopo la programmazione, che ormai funzionerà indipendentemente dalla board. Sarà sufficiente alimentarlo.

Il Primo schema dovrebbe funzionare infatti è costruito con un filtro per il segnale audio, un piccolo amplificatore composta dal transistor q1 e un interruttore composto dal transistor q2 e questo fa illuminare i led a ritmo di musica. Il secondo è un pcb.

Danke für den Hinweis. Grazie per la nota.

Scusa non è che nessuno ti voglia rispondere, ma forse c'è un po' di perplessità perchè oggigiorno l'html non va mai da solo, infatti la maggior parte dei siti vengono programmati in php, con varii javascript. Quanto riguarda le dimensioni, sono informazioni che vengono rilasciate dal browser e quindi c'è la possibilità di adattare il template del sito, ma non sempre viene usato, il più delle volte si sceglie una risoluzione e ci si costruisce il sito, dividendolo in blocchi.

Se noti bene la fascia verde è il doppio delle altre quindi... sono 2 sequenze di colori: marrone = 1 verde = 5 verde = x100'000 bianco = 10% tolleranza marrone = 100 V

Scusa il mio estremo ritardo ma l'ho notato solo ora questo post, di norma se si sa leggere il datasheet la risposta viene da se, comunque è un chip utilizzato per espandere le porte I/O dei multicontattori, un esempio pratico lo trovi con arduino, dove tramite il bus I2C si aggiungono altri 16 pin e quindi si possono gestire periferiche più complesse come piccoli schermi lcd.

State attenti ai calcoli teorici che state facendo, guardando il pcb, sembrerebbe che le lampadine vengono alimentate in serie ad un diodo e quindi la differenza di potenziale non è 220/230v. Se prima non fai delle misurazioni con un multimetro, non ti consiglio di mettere le resistenze che ti mostra snuntipook di norma sono da 5W e quindi attento alla corrente che circola.

Quindi prima di comprare ad esempio una ps3, prima la simuli sul pc e poi la compri? Vi sono varii simulatori di circuiti elettronici, ma è risaputo che non è la stessa cosa, a scuola utilizzavamo ORCAD PCB ma è un software a pagamento e anche piuttosto salato, in ditta usiamo Eagle, questultimo ha dei script per la simulazione, ma io non l'ho mai provato, mi limito a disegnare lo schema e se poi funziona in laboratorio su breadboard allora passo alla realizzazione del pcb, sempre con eagle. Il programma ha una versione libera ed una a pagamento, non c'è molta differenza fra i 2, l'unica differenza importante è che nella versione a pagamento si possono creare più fogli su di un proggetto, questo è utile quando si utilizzano i bus e si ha più di un circuito stampato.

I prezzi sono all'incirca tutti uguali, è già una piattaforma molto economica, ma si può risparmiare prendendo dei cloni come seeduino, oppure se avete un po' di pazienza stiamo allestendo un portale per la vendita di arduino con tutto il necessario per le prime sperimentazioni, oppure prossimamente intendo pubblicare come costruirsi arduino da soli con un minimo indispensabile di componenti.

Fritzing è solo un programma per il disegno elettronico e non un simulatore, prova questo http://www.arduino.com.au/Data/SetupF.zip, anche se io non ne ho mai avuta la necessità perchè il bello di arduino è la sperimentazione fisica

Fino ad ora vi ho spiegato come si attivano i pin digitali in uscita quindi come interagire tra Arduino ed un led, ora vediamo come programmare un azione esterna nel nostro caso la pressione di un tasto. Come sempre per controllare la corrente che illumina il LED METTO UNA RESISTENZA DA 1 Kohm, questo perchè l'uscita di arduino fornisce una corrente massima di 40 mA e non voglio rischiare di rompere il microcontrollore AtMega328p di Arduino, tra il pulsante e la massa metto una resistenza da 10 Kohm e lo collego al pin 7 di arduino, l'altra estremità del pulsante va ai 5 V di uscita di Arduino, questo perchè arduino rivela la differenza di potenziale e non la circolazione di corrente, la resistenza è più elevata per ridurre la circolazione di corrente, per chi non lo sapesse è definita dalla legge di ohm che dice V = R*I, quindi avendo una differenza di potenziale nel nostro caso sempre costante (5 V), aumentando la resistenza diminuisco la Corrente. Ora come sempre andiamo a definire nel programma i pin utilizzati: void setup() { pinMode(13, OUTPUT); pinMode(7, INPUT); } Da notare al pin 7 ho impostato "INPUT" questo come logico per dirgli che è una lettura e non una scrittura, quindi arduino ora utilizza il piun 7 per rilevare la differenza di potenziale che si va a creare. Per effettuare una lettura sul pin 7 si deve usare la funzione "digitalRead()" questo ci restituisce 2 valori "HIGH" se c'è tensione e "LOW" se questa non è presente, e quindi il nostro programma uscirà in questa maniera: void loop() { digitalWrite(13, digitalRead(7)); } Se si carica il nostro sketch su arduino si nota subito un piccolo problema, il nostro LED si illumina solo quando il pulsante risulta premuto, non appena lo rilasciamo il LED si spegne, questo lo si può usare solo quando si vuole rilevare lo stato, ma noi vogliamo poter accendere e spegnere il LED ad ogni pressione, quindi dobbiamo rivelare il cambiamento di stato del pulsante e quindi memorizzare lo stato del LED. Una soluzione potrebbe essere: int tastroprecedente = LOW; int tasto = LOW; int statoled = LOW; void setup() { pinMode(13, OUTPUT); pinMode(7, INPUT); } void loop() { stato = digitalRead(7); if (stato != tastoprecedente && stato == HIGH) { statoled = 1 - statoled; } digitalWrite(13, statoled); tastoprecedente = stato; } Il confronto "if" va a rilevare il cambiamento di stato del pulsante su due letture del tasto quella attuale e quella precedente e controla se il pulsante risulta premuto quindi va ad assegnare lo stato del led grazie alla funzione "statoled = 1 - statoled;" questa grazie ad un semplice formula matematica va ad invertire il valore, infatti se lo stato del led è "1" o "HIGH" lo cambia in "0" o "LOW", infatti "1 - 1 = 0", viceversa se lo stato precedente è "0" o "LOW", "1 - 0 = 1". Schema elettrico: R1 = 1K ohm R2 = 10K ohm

Arduino UNO dispone di ben 6 pin PWM, una modulazione digitale che permette di ottenere una tensione media variabile, questo grazie alla variazione del tempo di un impulso, per capire meglio guardate la figura qui in basso, presa da wikipedia http://dl.dropbox.com/u/27772338/688px-PWM%2C_3-level_svg.png V è l'impuso emesso dal pin e B è la tensione media che si ottiene nell tempo sul carico, in questo caso un motore. Ora andiamo a vedere come possiamo utilizzare questa modulazione per poter variale l'illuminazione di un led con arduino. da notare che come l'esperimento precedente ho messo tra il catodo del LED e la massa una resistenza (circa 10kOhm), questo per regolare la corrente. Ora inizializziamo il piedino 9: void setup() { pinMode(9, OUTPUT); } Fin qui non cambia nulla, ora invece basta giocare sul valore di da assegnare al comando di uscita, usando un nuovo comando analogWrite(pin, valore); in questo comando vanno assegnati 2 valori il primo indica il pin dove abbiamo collegato il nostro led e il valore del ciclo pwm compreso tra 0 (sempre spento) e 255 (sempre acceso). quindi il nostro loop diventa: void loop() { for(int valore = 0; valore <= 255; valore++) { analogWrite(9, valore); delay(50); } delay(50); for(int valore = 255; valore >= 0; valore--) { analogWrite(9, valore); delay(50); } delay(50); } ora grazie ai due clicli "for" faccio aumentare il valore della frequenza del segnale pwm, nel primo caso, e nel secondo lo faccio decrescere, creando un effetto di accensione e spegnimento lento del led. Schetch completo: void setup() { pinMode(9, OUTPUT); } void loop() { for(valore = 0; valore <= 255; valore++) { analogWrite(9, valore); delay(50); } delay(50); for(int valore = 255; valore >= 0; valore--) { analogWrite(9, valore); delay(50); } delay(50); } Schema elettrico:

e giá

Finalmente anche Arduino dispone ora di una scheda di prototipazione con processore ARM (precedentemente Advanced RISC Machine, prima ancora Acorn RISC Machine) la stessa architettura di processori con cui vengono costruiti gli smartphone e tablet ed ultimamente i minicomputer come Raspberry pi. Per l'occasione è stata creata una nuova IDE (ambiente di sviluppo integrato) infatti anche se ancora non considerata è stata già rilasciata con tanto di codice sorgente e la si può scaricare tranquillamente da sito ufficiale di arduino, quest'ultima ci permette non solo di programmare questo nuovo gioiellino, ma supporta tutte le versioni precedenti, infatti si possono integrare ancora tutte le librerie già esistenti. Tornando alle caratteristiche principali c'è da notare che i dispositivo dispone di due porte USB (Universal Serial Bus), una per la programmazione grazie al chip ATMEL16U2 che viene utilizzato per la conversione da USB a seriale, a sua volta è connesso tramite UART (Universal Asynchronous Receiver-Transmitter, in italiano ricevitore-trasmettitore asincrono universale) a SAM3X che gestisce la seconda porta USB nativa da 480 Mbs, e ci permette di gestire periferiche come HDD o tartiere. Il cuore di Arduino DUE è un Atmel SAM3X8E ARM Cortex-M3 CPU un processore da 32 bit con 84 MHz Clock e la cosa soprattutto interessante sono i due DAC (Digital to Analog Converter, in ittaliano convertritore digitale analogico) che ci permettono di creare segnali video e audio, cosa impossibile sulle board precedenti, e grazie alla velocità finalmente si può cominciare a parlare di multitasking (multiprocessualità) ma conservando un consumo di corrente ridotto e quindi la possibilità di prototipazioni con alimentazione a batteria. Una cosa importante da tenere in considerazione è che ora le porte IO vengono alimentate a 3.3V infatti se alimentiamo a tensioni di 5V come le versioni precedenti queste rischiano di danneggiare l'ARM, ma in compenso le correnti di uscita dei varii pin digitali è stata portata a 130mA. Anche la Memoria Flash (memoria a stato solido) è stata aumentata infatti ora si dispone di 512 KB per le nostre applicazione e due banchi SRAM (Static Random Access Memory) uno da 64 KB e il secondo con 32 KB. File EAGLE: Arduino DUE Schematica: PDF Datasheet: Atmel SAM3X8E ARM Cortex-M3 CPU

Certamente sembrerebbe a prima vista Aduino Uno Rev.2 con l`Atmel328p

Per tutti coloro che non hanno mai avuto a che fare con la piattaforma Arduino vi presento il primo esperimento, in rete ne troverete a migliaia, ma cercherò di spiegarvi soprattutto il funzionamento del programma, in modo da potervi avvicinare il più possibie. LED Lampeggiante Disegno realizzato con Fritzing Come vedete ho collegato all'uscita D13 all'anodo un semplice LED e per sicurezza ho messo una resistenza da 10K tra il catodo e la massa. Ora avendo preparato il circuito basta passare alla programmazione dell'arduino. Il linguaggio si basa sul linguaggi "C" ma bisogna tenere conto che ci sono due funzioni indispensabili che devono essere sempre presenti su nostro programma. La prima è la funzione "setup" dove andiamo a scrivere che tipo di funzione dobbiamo ad inizializzare, la seconda la "loop" dove il nostro programma gira all'infinito, infatti una piccoa differenza sui normali PC il programma si può terminare in Arduino invece questo si ripete fino allo spegnimento. Ora inizializziamo il piedino D13 dicendogli che è una semplice uscita, quindi viene fornita una differenza di potenziale di 5v e una corrente massima di 40mA. void setup() { pinMode(13, OUTPUT); } Ora vogliamo che ad ogni secondo il nostro LED si accende e spegne quindi basta scrivere nela funzione loop: void loop() { digitalWrite(13, HIGH); delay(1000); digitalWrite(13, LOW); delay(1000); } Il comando "digitalWrite" ci permette di far reagire l'uscita 13 infatti i LED si accende quanto c'è il valore "HIGH" o "1" e si spegne quando c'è "LOW" o "0", la funzione delay è un ciclo vuoto e viene espresso in milliSecondi infatto per arrivare ad un secondo ce ne vogliono 1000. Programma intero: void setup() { pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(1000); digitalWrite(13, LOW); delay(1000); } Come in tutte le programmazioni possiamo utilizzare le variabili e quindi una variante del nostro programma potrebbe diventare: int LEDpin = 13; int LEDstato = LOW; long milliprecedenti = 0; long intervallo = 1000; void setup() { pinMode(LEDpin, OUTPUT); } void loop() { unsigned long millicorrenti = milli(); if (millicorrenti - milliprecedenti > intervalo) { milliprecedenti = millicorrenti; if (LEDstato == LOW) { LEDstato = HIGH; } else { LEDstato = LOW; } digitalWrite(LEDpin, LEDstato); } } Ora il risultato finale fra i due sketch non cambia ma anche se ho allungato e complicato la stesura il mio intento è quello di farvi capire come sul PC la programmazione è reativa al programmatore. Schema elettrico:

Ragazzi eccovi la mia versione di Arduino tra breve sarà disponibile anche al pubblico

ti posto una semplice query CREATE TABLE `database`.`innodb` ( `data` DATE NOT NULL DEFAULT '11042000' ) ; credo che tu sia già in grado di interpretare i comandi in fondo siili ad oracle un altro esempio CREATE TABLE `database`.`innodb` ( `data` DATE NOT NULL DEFAULT CURRENT_TIMESTAMP ) la differenza sta nel fatto che nella prima ho sttato un falore definito 11.04.2000 nel secondo invece immette la data corrente

devi prendere un installer msi e non una noinstal

devi scegliere l'msi della tua architettura e non prendere la versione essenziale, ma quella completa, dovrebbe essere oltre i 100MB

Per semplificargli il lavoro potresti commentargli le varie righe del programma