Posts Tagged ‘RaspberryPi’

Raspberry Pi Episodio 6: RFID

By Vincenzo Cicogna | marzo 30th, 2015 | LEAVE A COMMENT

Arrivati al capolinea!
Finalmente dopo circa un anno, ci siamo riusciti!
Abbiamo portato a termine questa serie di episodi su Raspberry.
Come promesso abbiamo pubblicato 6 episodi.

In questo episodio si parla di una tecnologia molto discussa di recente, in ambito di pagamenti con smartphone e controllo accessi: RFID.
In effetti si è realizzato un sistema in grado di riconoscere opportuni TAG e consentire o meno determinate operazioni.

Qui di seguito lo schema di collegamento del setup riassunto in una tabella:

Collegamenti Raspberry

La libreria SPI potete scaricarla qui:

[cpp] git clone https://github.com/lthiery/SPI-Py
[/cpp]

mentre il framework Python per l’ RFID lo trovate qui:

[cpp]

git clone https://github.com/mxgxw/MFRC522-python

[/cpp]

Qui il codice Read.py modificato:

[cpp] import RPi.GPIO as GPIO
import MFRC522
import signal
import time

#set up GPIO using BCM
GPIO.setmode(GPIO.BOARD)

#setup GPIO PIN
led=11
GPIO.setup (led, GPIO.OUT)

continue_reading = True

# Capture SIGINT for cleanup when the script is aborted
def end_read(signal,frame):
global continue_reading
print "Ctrl+C captured, ending read."
continue_reading = False
GPIO.cleanup()

# Hook the SIGINT
signal.signal(signal.SIGINT, end_read)

# Create an object of the class MFRC522
MIFAREReader = MFRC522.MFRC522()

# Welcome message
print "Welcome to the MFRC522 data read example"
print "Press Ctrl-C to stop."

# This loop keeps checking for chips. If one is near it will get the UID and au$
while continue_reading:
GPIO.output(buz, False)
# Scan for cards
(status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)

# If a card is found
if status == MIFAREReader.MI_OK:
print "Card detected"

# Get the UID of the card
(status,uid) = MIFAREReader.MFRC522_Anticoll()

# If we have the UID, continue
if status == MIFAREReader.MI_OK:

# Print UID
print "Card read UID: "+str(uid[0])+","+str(uid[1])+","+str(uid[2])+","$

# This is the default key for authentication
key = [0xFF,0xFF,0xFF,0xFF,0xFF,0xFF]

# Select the scanned tag
MIFAREReader.MFRC522_SelectTag(uid)

# Authenticate
status = MIFAREReader.MFRC522_Auth(MIFAREReader.PICC_AUTHENT1A, 8, key,$

# Check if authenticated
if status == MIFAREReader.MI_OK:
MIFAREReader.MFRC522_Read(8)
MIFAREReader.MFRC522_StopCrypto1()
GPIO.output(buz, True)
time.sleep(5)
else:
print "Authentication error"
GPIO.output (buz, False)

[/cpp]

Vi ricordo di iscrivervi alla nostra newsletter, questo mese riceverete in anticipo l’annuncio di un grande ritorno. Forse due!

Alla Prossima!

Raspberry Pi Episodio 5: Arduino su I2C

By Vincenzo Cicogna | gennaio 28th, 2015 | SHOW COMMENTS (2)

Benvenuti nel 5° episodio di Raspberry Pi, come ben potete immaginare, a volte è necessario espandere lahttp://www.automazioneos.com/wp-admin/post-new.php rete del sistema che si sta utilizzando per associarlo a nuovi sensori o a nuove attuazioni.

Per fare questo, nei sistemi automatici si fa uso di bus di comunicazione sui quali viaggiano informazioni relative a sensori, microcontrollori e attuatori.

Con l’esperienza di oggi si vuole costruire una comunicazione tra due schede microcontrollore: Raspberry PI ed Arduino.

In seguito è riportato il diagramma per il collegamento:

schema_bb

il codice da caricare su Raspberry Pi:

[cpp] import smbus
import time
# for RPI version 1, use "bus = smbus.SMBus(0)"
bus = smbus.SMBus(1)

# This is the address we setup in the Arduino Program
address = 0x04

def writeNumber(value):
 bus.write_byte(address, value)
 # bus.write_byte_data(address, 0, value)
return -1

def readNumber():
 number = bus.read_byte(address)
 # number = bus.read_byte_data(address, 1)
 return number

while True:
 var = input("Enter 1 – 9: ")
  if not var:
  continue

 writeNumber(var)
 print "RPI: Hi Arduino, I sent you ", var
 # sleep one second
 time.sleep(1)

 number = readNumber()
 print "Arduino: Hey RPI, I received a digit ", number
 print
[/cpp] e quello per Arduino:

[cpp] #include <Wire.h>

#define SLAVE_ADDRESS 0x04
int number = 0;
int state = 0;

void setup() {
pinMode(13, OUTPUT);
Serial.begin(9600); // start serial for output
// initialize i2c as slave
Wire.begin(SLAVE_ADDRESS);

// define callbacks for i2c communication
Wire.onReceive(receiveData);
Wire.onRequest(sendData);
Serial.println("Ready!");
}

void loop() {
delay(100);
}

// callback for received data
void receiveData(int byteCount){

while(Wire.available()) {
number = Wire.read();
Serial.print("data received: ");
Serial.println(number);

if (number == 1){

if (state == 0){
digitalWrite(13, HIGH); // set the LED on
state = 1;
}
else{
digitalWrite(13, LOW); // set the LED off
state = 0;
}
}
}
}

// callback for sending data
void sendData(){
Wire.write(number);
}

[/cpp] L’esperienza riprodotta ha avuto come fonte di ispirazione questo blog

Non perdete la prossima ed ultima puntata di Raspberry Pi!

 

 

 

Raspberry Pi episodio 4: PWM

By Vincenzo Cicogna | settembre 23rd, 2014 | LEAVE A COMMENT

Differentemente da quanto avevamo annunciato nello scorso articolo è stato deciso di apportare delle modifiche agli argomenti intrapresi in questi video episodi sulla Raspberry PI.

Il motivo principale di questa scelta ricade sul target d’uso di questi episodi, i quali si incentreranno principalmente sull’automazione.

In effetti sin dal primo episodio lo stampo caratterizzante del progetto era prospettato su una argomentazione molto vicina all’automazione.

In questo episodio, non a caso parliamo di PWM, quindi della principale tecnica di modulazione utilizzata per l’azionamento.

Oltre al video in questo articolo potete accedere anche allo schema Fritzing e al codice Python utilizzato.

schema PWM


import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BOARD)
GPIO.setup(3, GPIO.OUT)
GPIO.setup(10, GPIO.OUT)
GPIO.setup(12, GPIO.OUT)

p = GPIO.PWM(3,50)
p.start(7.5)
try:
while True:
p.ChangeDutyCycle(7.5)
GPIO.output(10,0)
GPIO.output(12,0)
time.sleep(1)
p.ChangeDutyCycle(12.5)
GPIO.output(10,0)
GPIO.output(12,1)
time.sleep(1)
p.ChangeDutyCycle(2.5)
GPIO.output(10,1)
GPIO.output(12,0)
time.sleep(1)
except KeyboardInterrupt:
p.stop()
GPIO.cleanup()

Onde evitare ulteriori cambi di programma, in questo articolo non anticiperò nulla del prossimo episodio.

Non vi resta che non mancare al prossimo appuntamento.

Buona visione.

Alla prossima.

Episodi precedenti

Raspberry Pi episodio 3: Python e il GPIO

By Vincenzo Cicogna | giugno 23rd, 2014 | LEAVE A COMMENT

Il terzo episodio di Raspberry Pi è incentrato completamente sul Python e sul GPIO.

Schema Breadboard

Schema Raspberry Episodio 3

In questo episodio interfacceremo la Raspberry con il mondo esterno attraverso il canale di GPIO programmando in Pythonin questo episodio interfacceremo la Raspberry con il mondo esterno attraverso il canale di GPIO programmando in Python

Per comprendere al meglio il funzionamento verranno presentati due esercizi molto semplici

  1. Esercizio classico per iniziare: hello world con un led
  2. Al classico lampeggiatore si aggiunge la possibilità di controllo con un pulsante

Gli script sono disponibili di seguito:

Pyton1.py

import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(24,GPIO.OUT)
while 1:
 GPIO.output(24,True)
 time.sleep(5)
 GPIO.output(24,False)
 time.sleep(5)

Python2.py

import RPi.GPIO as GPIO 
import time

#def main():
GPIO.setmode(GPIO.BOARD)
GPIO.setup(23, GPIO.IN)#,pull_up_down=GPIO.PUD_DOWN) 
GPIO.setup(24, GPIO.OUT)

while True:
 input=GPIO.input(23);
 if(input == 0):
  GPIO.output(24, True)
  time.sleep(1)
  GPIO.output(24, False)
  time.sleep(1)
 #print(input)
  print("Button Pressed")
 else:
  GPIO.output(24, False)
  print(input)
# GPIO.cleanup()

Nel prossimo episodio vedremo una modalità di utilizzo molto interessante: un ottimo compromesso ai costosissimi sistemi NAS.

Ma per scoprirlo dovete aspettare la prossima puntata.

A presto

Episodi precedenti

RASPBERRY PI EPISODIO 2

By Vincenzo Cicogna | giugno 3rd, 2014 | SHOW COMMENTS (2)

Il secondo episodio di RaspberryPI si incentra su un piccolo Get-Started per metterci in condizioni di lavorare nelle prossime puntate.

Dopo aver presentato tutto il necessario per collegare la Raspberry PI si descrive il processo di installazione del sistema operativo e del suo primo avvio. Infine è introdotto il GPIO, ed  un primo esempio di interfacciamento con il mondo esterno.

Nelle prossime puntate, come accennato anche nel video, sarà la volta di  Python e alcuni protocolli di rete con i quali verranno mostrate le enormi potenzialità di questo strumento.

Per il momento godevi il secondo episodio, iscrivetevi al nostro canale, e seguiteci sui social, è un piccolo gesto in segno di riconoscimento. 😉

Episodio 1:

http://www.xploreautomation.com/raspberry-pi-ep1/