DevSide http://dev.sarasini.it Linux, PICs, Qt and more Sun, 01 May 2011 17:57:22 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 ListView con SimpleAdapter e ListActivity http://dev.sarasini.it/?p=371 http://dev.sarasini.it/?p=371#comments Sun, 01 May 2011 17:56:17 +0000 admin http://dev.sarasini.it/?p=371 Vediamo come realizzare un programma composto da una lista di elementi con tre TextView e una ImageView, collegata ai dati mediante un SimpleAdapter.

MainActivity.java

package it.sarasini.android.Lez_5_ListView_SimpleAdapter;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import android.app.ListActivity;
import android.os.Bundle;
import android.widget.SimpleAdapter;
 
public class MainActivity extends ListActivity {
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
 
        super.onCreate(savedInstanceState);
 
        ArrayList<Map<String, Object>> listaDati = new ArrayList<Map<String, Object>>();
        listaDati = riempilistaDati(listaDati);
 
        String[] from = { "foto", "nome", "cognome", "indirizzo" };
        int[] views = { R.id.image, R.id.text1, R.id.text2, R.id.text3 };
 
        SimpleAdapter mioAdapter = new SimpleAdapter (
 
	this, 			// The context where the View associated with this SimpleAdapter is running
	listaDati,		// A List of Maps. Each entry in the List corresponds to one row in the list.
	R.layout.item,		// Resource identifier of a view layout
	from,	 		// A list of column names that will be added to the Map associated with each item.
	views 			// The views that should display data
        );
 
        this.setListAdapter(mioAdapter);
    }
 
    private ArrayList<Map<String, Object>> riempilistaDati(ArrayList<Map<String, Object>> listaDati) {
 
    	listaDati.add(creaMappa(R.drawable.img, "Mario", "Rossi", "Via Roma 12 Bologna"));
    	listaDati.add(creaMappa(R.drawable.img, "Paolo", "Bianchi", "Via Fermi 22 Milano"));
    	listaDati.add(creaMappa(R.drawable.img, "Luca", "Molli", "Via Trento 15 Brescia"));
    	listaDati.add(creaMappa(R.drawable.img, "Giorgio", "Berlusconi", "Via Appia 12 Lecce"));
    	listaDati.add(creaMappa(R.drawable.img, "Luigi", "Rutelli", "Via Principale 132 Como"));
    	listaDati.add(creaMappa(R.drawable.img, "Franco", "Casini", "Via Settima 14 Firenze"));
    	listaDati.add(creaMappa(R.drawable.img, "Matteo", "Lorenzi", "Vicolo Stazione 7 Venezia"));
    	listaDati.add(creaMappa(R.drawable.img, "Giovanni", "Matteoli", "Via Genova 77 Torino"));
    	listaDati.add(creaMappa(R.drawable.img, "Leonardo", "Polli", "Via Campiana 34 Ancona"));
    	listaDati.add(creaMappa(R.drawable.img, "Diego", "Meruso", "Via Serena 23 Palermo"));
    	listaDati.add(creaMappa(R.drawable.img, "Enrico", "Giorini", "Via Mattei 127 Rimini"));
 
        return listaDati;
    }
 
    private Map<String, Object> creaMappa(int foto, String nome, String cognome, String indirizzo) {
 
    	Map<String, Object> map = new HashMap<String, Object>();
 
    	map.put("foto", foto);
    	map.put("nome", nome);
    	map.put("cognome", cognome);
    	map.put("indirizzo", indirizzo);
 
    	return map;
    }   
}

item.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout   xmlns:android="http://schemas.android.com/apk/res/android"   android:layout_width="match_parent"   android:layout_height="match_parent"    android:orientation="horizontal"   android:padding="5dp">
 
  <ImageView android:layout_width="wrap_content" android:layout_height="fill_parent" android:id="@+id/image" android:src="@drawable/icon"></ImageView>
 
  <LinearLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/linearLayout1" android:orientation="vertical">
 
    <TextView android:text="TextView" android:id="@+id/text1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:paddingLeft="5dp"></TextView>
    <TextView android:text="TextView" android:id="@+id/text2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:paddingLeft="5dp"></TextView>
    <TextView android:text="TextView" android:id="@+id/text3" android:layout_width="wrap_content" android:layout_height="wrap_content" android:paddingLeft="5dp"></TextView>
 
  </LinearLayout>
</LinearLayout>

ListView SimpleAdapter

]]> http://dev.sarasini.it/?feed=rss2&p=371 2 ListView con ArrayAdapter e ListActivity http://dev.sarasini.it/?p=353 http://dev.sarasini.it/?p=353#comments Sun, 01 May 2011 17:42:04 +0000 admin http://dev.sarasini.it/?p=353 Vediamo come realizzare un programma composto da una lista di elementi di tipo TextView collegata ai dati mediante un ArrayAdapter. Il codice è veramente semplice…

MainActivity.java

package it.sarasini.android.ListView_ArrayAdapter;
 
import java.util.ArrayList;
import android.app.ListActivity;
import android.os.Bundle;
import android.widget.ArrayAdapter;
 
public class MainActivity extends ListActivity {
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
 
        super.onCreate(savedInstanceState);
 
        ArrayList listaNomi = new ArrayList();
        listaNomi = riempiListaNomi(listaNomi);
 
        ArrayAdapter mioAdapter = new ArrayAdapter (		
        this, 					// The context where the View associated with this SimpleAdapter is running
        android.R.layout.simple_list_item_1, 	// Resource identifier of a view layout
        listaNomi				// Data to display
        );
 
        this.setListAdapter(mioAdapter);
    }
 
    private ArrayList riempiListaNomi(ArrayList listaNomi) {
 
    	listaNomi.add("Marco");
        listaNomi.add("Paolo");
        listaNomi.add("Luca");
        listaNomi.add("Giorgio");
        listaNomi.add("Luigi");
        listaNomi.add("Franco");
        listaNomi.add("Matteo");
        listaNomi.add("Giovanni");
        listaNomi.add("Leonardo");
        listaNomi.add("Diego");
        listaNomi.add("Enrico");
 
        return listaNomi;
    }   
}

ListActivity ArrayAdapter

]]> http://dev.sarasini.it/?feed=rss2&p=353 0 Corso Android http://dev.sarasini.it/?p=334 http://dev.sarasini.it/?p=334#comments Thu, 17 Mar 2011 13:35:22 +0000 admin http://dev.sarasini.it/?p=334 Si è concluso il corso di programmazione di base di dispositivi Android svolto da me e da Maurizio Cozzetto all’ITIS Castelli di Brescia. Pubblico qui un po’ di materiale.

Slide delle lezioni e del progetto finale, comparativa dispositivi android in commercio
Slide Corso Android (224)

ActionSMS (progetto finale)
Sorgente ActionSMS (199)

ActionSMS è un progetto realizzato per l’ultima lezione del corso con le seguenti funzionalità:
- Lettura tramite sintesi vocale degli sms in arrivo
- Controllo remoto del cellulare tramite sms
- Invio di sms
action_sms_1 action_sms_2

]]> http://dev.sarasini.it/?feed=rss2&p=334 0 Android: Inviare SMS all’emulatore http://dev.sarasini.it/?p=325 http://dev.sarasini.it/?p=325#comments Thu, 03 Mar 2011 11:54:10 +0000 admin http://dev.sarasini.it/?p=325 Può capitare di dover inviare un sms all’emulatore di Android ad esempio per testare un SMS reciver. Vediamo come fare.
Avviamo l’emulatore. Poi digitiamo da terminale:

./adb devices

otterremo qualcosa di simile:

List of devices attached
emulator-5554	device

5554 è la porta dell’emulatore che ci servirà per connetterci via telnet.
Digitiamo:

telnet localhost 5554

Ora siamo pronti ad inviare un sms digitando

sms send numero messaggio

Ad esempio

sms send 123456789 Ciao come va?

Dopo pochi secondi vedremo arrivare sull’emulatore il nostro messaggio.

SMS Emulatore

]]> http://dev.sarasini.it/?feed=rss2&p=325 0 Grafici con AndroidPlot http://dev.sarasini.it/?p=313 http://dev.sarasini.it/?p=313#comments Tue, 01 Mar 2011 09:05:58 +0000 admin http://dev.sarasini.it/?p=313 AndroidPlot è una libreria java per Android che consente la creazione di grafici statici e dinamici in modo semplice ed efficace. Dispone anche di un piccolo wiki con alcuni esempi pronti.

Grafico

Grafico

Vediamo un semplice programma che visualizza su un grafico a barre i valori letti dall’accelerometro.

MainActivity.java

package it.sarasini.android.graficoaccelerometri;
 
import it.sarasini.android.graficoaccelerometri.R;
import java.util.Arrays;
 
import com.androidplot.xy.BarFormatter;
import com.androidplot.xy.BarRenderer;
import com.androidplot.xy.BoundaryMode;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.xy.XYPlot;
 
import android.app.Activity;
import android.graphics.Color;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
 
public class MainActivity extends Activity implements SensorEventListener {
 
	private SensorManager mSensorManager = null;
 
	private XYPlot grafico = null;
	private SimpleXYSeries serie = null;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
 
    	super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        grafico = (XYPlot) findViewById(R.id.grafico);
        makeChart(grafico);
 
        mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
    	mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_UI);
    }
 
    public void makeChart(XYPlot grafico) {
 
    	serie = new SimpleXYSeries("valori");
 
    	grafico.addSeries(serie, BarRenderer.class, new BarFormatter(Color.BLUE, Color.DKGRAY));
        grafico.setDomainStepValue(3);
        grafico.setTicksPerRangeLabel(3);
 
        grafico.setDomainValueFormat(new MyFormat());
 
        grafico.setRangeBoundaries(-11, 11, BoundaryMode.FIXED);
 
        // update our domain and range axis labels:
        grafico.setDomainLabel("Axis");
        grafico.getDomainLabelWidget().pack();
        grafico.setRangeLabel("Angle (Degs)");
        grafico.getRangeLabelWidget().pack();
 
        BarRenderer barRenderer = (BarRenderer) grafico.getRenderer(BarRenderer.class);
        if(barRenderer != null)
            barRenderer.setBarWidth(30, BarRenderer.BarWidthStyle.FIXED_WIDTH);
 
        grafico.setGridPadding(30, 0, 30, 0);
        grafico.disableAllMarkup();
 
    }
 
    @Override
	public void onAccuracyChanged(Sensor sensor, int accuracy) {
		// TODO Auto-generated method stub
	}
 
	@Override
	public void onSensorChanged(SensorEvent event) {
 
		if(event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
 
			// Dalla documentazione:
			// All values are in SI units (m/s^2) and  measure the
			// acceleration applied to the phone minus the force of gravity. 
 
			Number[] series1Numbers = {event.values[0], event.values[1], event.values[2]};
	        serie.setModel(Arrays.asList(series1Numbers), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
 
			grafico.redraw();
 
		}
	}
}

MyFormat.java

package it.sarasini.android.graficoaccelerometri;
 
import java.text.FieldPosition;
import java.text.Format;
import java.text.ParsePosition;
 
@SuppressWarnings("serial")
public class MyFormat extends Format {
 
        @Override
        public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
 
        	Number num = (Number) obj;
            // using num.intValue() will floor the value, so we add 0.5 to round instead:
            int roundNum = (int) (num.floatValue() + 0.5f);
            switch(roundNum) {
                case 0:
                    toAppendTo.append("X");
                    break;
                case 1:
                    toAppendTo.append("Y");
                    break;
                case 2:
                    toAppendTo.append("Z");
                    break;
                default:
                    toAppendTo.append("Unknown");
            }
            return toAppendTo;
        }
 
        @Override
        public Object parseObject(String source, ParsePosition pos) {
            return null;  // We don't use this so just return null for now.
        }
}

Grafici accelerometro

]]> http://dev.sarasini.it/?feed=rss2&p=313 1 0xdroid su Devkit8000 http://dev.sarasini.it/?p=265 http://dev.sarasini.it/?p=265#comments Wed, 03 Nov 2010 13:04:31 +0000 admin http://dev.sarasini.it/?p=265
Grazie alla community di 0xdroid è possibile installare facilmente Android su Beagleboard e su Devkit8000. Vediamo come fare.

Prendiamo la solita SD assicurandoci che la prima partizione sia di tipo Fat32 e di almeno 100Mb.
Scarichiamo l’immagine già pronta di Android Eclair: download
Scarichiamo il nuovo bootloader necessario per avviare Android: download

Estraiamo il file devkit8k-eclair-0x5_sgx.zip nella prima partizione della SD e copiamo anche il file flash-uboot.bin.
Modifichiamo il file install.conf decommentando la riga relativa al U_BOOT_IMAGE. Controllate inoltre che sia selezionato il display corretto.

Ora inseriamo la SD nella nostra Devkit8000. La colleghiamo al nostro pc tramite seriale (su Linux è molto comodo GtkTerm) e accendiamo. Interrompiamo l’autoboot e digitiamo i seguenti comandi (Attenzione questi comandi possono danneggiare la vostra scheda, non mi assumo nessuna responsabilità, provateli a vostro rischio e pericolo :-D ):

mmcinit
fatload mmc 0:1 80000000 flash-uboot.bin
nand unlock
nand ecc sw
nand erase 80000 160000
nand write.i 80000000 80000 160000

Adesso riavviamo. Interrompiamo ancora l’autoboot e digitiamo:

mmc init
fatload mmc 0 80300000 uimage.bin
bootm 80300000

Si avvierà l’installer di Android. Lasciamolo lavorare. A processo completato troveremo queste scritte:

Press [Enter] to activate shell
Welcome to 0xdroid Image Installer
 
Mounting SD card...
Copying files..
	* 0xkernel.bin
	* android.ubi
	* flash-uboot.bin
Writing android.ubi into NAND flash...
File System :: Done!
Check point
Erase NAND flash (Kernel)
Writing 0xkernel.bin into NAND flash...
starting from 0
 
Kernel :: Done!
Check point
Erase NAND flash (U-Boot)
Writing into NAND flash...
starting from 0
U-Boot :: Done!
Setup U-Boot Env...
U-Boot Env :: Done!
All done. You may reboot now.

Rimuoviamo la SD e riavviamo. Se tutto è andato a buon fine si avvierà Android

Alcuni links utili:
http://code.google.com/p/0xdroid/
http://code.google.com/p/0xdroid/wiki/UsingPreBuiltImages
http://code.google.com/p/0xdroid/wiki/EnhanceButton
http://www.armkits.com/Product/devkit8000.asp

1 2 3 4 5 6 ]]> http://dev.sarasini.it/?feed=rss2&p=265 0 Telecomando IR con Pic http://dev.sarasini.it/?p=224 http://dev.sarasini.it/?p=224#comments Sun, 10 Oct 2010 14:37:03 +0000 admin http://dev.sarasini.it/?p=224 Vediamo come realizzare un semplice telecomando usando i Pic.

Ci servono un ricevitore infrarossi a 3 pin (come quelli usati nei televisori), un led ad infrarossi, alcune resistenze, condensatori, led e transistor, e naturalmente un paio di Pic.

Il ricevitore che ho utilizzato è l’SFH 5110 a 36kHz (datasheet)

Il led IR invece è un comune led con lunghezza d’onda pari a 940nm.

Ecco il circuito ricevente

E il telecomando

Ho utilizzato un protocollo di comunicazione simile al protocollo Sony. un segnale alto di 2400us e una pausa di 300us all’inizio di ogni trama, 1 generato con un segnale alto di 1200us e una pausa di 600us, 0 generato con un segnale alto di 600us e una pausa di 600us.
Il ricevitore riconosce segnali con frequenza pari a 36kHz, quindi il segnale dovrà essere generato con tale frequenza (infatti nell’immagine si vede il segnale alto rappresentato come una serie di “alti-bassi”).

Il telecomando è molto semplice, si limita ad inviare continuamente il segnale alla frequenza di 36Khz. Per realizzare un telecomando completo è sufficiente collegare dei pulsanti e associare ad ognuno di essi l’invio di una trama diversa.
Il ricevitore è più complesso. Viene utilizzato il timer0 per misurare la lunghezza dei dati ricevuti in modo da poterli riconoscere. Tutto questo viene fatto senza utilizzare interrupt, perché il pic scelto è molto economico e non li supporta. L’algoritmo inizia cercando il segnale alto di start e verificando la sua lunghezza. Quando lo trova si prepara a ricevere 6 numeri (possono essere anche molti di più volendo) controllando ogni volta la loro lunghezza. Se la lunghezza non corrisponde ne ad un 1 ne ad uno 0 si ricomincia da capo. Chiaramente non cerca il valore esatto ma vengono ammessi più valori compresi in un intervallo.
Ogni volta che riceve un valore corretto lo inserisce nella coda e controlla la sequenza.

Codice ricevitore main.c

#include "main.h"
 
#define  PIN_LED        PIN_B4
#define  PIN_SIGNAL     PIN_B2
 
#define  SEGNALE_ALTO   !input(PIN_B5)
#define  SEGNALE_BASSO  input(PIN_B5)
 
#define  MAX_DATA_RX    6
 
int data_rx[MAX_DATA_RX]        = {2,2,2,2,2,2};
int data_colpito[MAX_DATA_RX]   = {1,1,1,0,1,0};
 
void cancella()
{
   data_rx[0] = 2;
   data_rx[1] = 2;
   data_rx[2] = 2;
   data_rx[3] = 2;
   data_rx[4] = 2;
   data_rx[5] = 2;
}
 
void shift_sx(byte data)
{
   data_rx[0] = data_rx[1];
   data_rx[1] = data_rx[2];
   data_rx[2] = data_rx[3];
   data_rx[3] = data_rx[4];
   data_rx[4] = data_rx[5];
   data_rx[5] = data;
}
 
short controlla()
{
   if(data_rx[0] == data_colpito[0])
      if(data_rx[1] == data_colpito[1])
         if(data_rx[2] == data_colpito[2])
            if(data_rx[3] == data_colpito[3])
               if(data_rx[4] == data_colpito[4])
                  if(data_rx[5] == data_colpito[5])
                     return TRUE;
 
   return FALSE;
}
 
void main()
{
   long time;
   int i;
   int dato;
 
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_16); 
 
   delay_ms(200); 
 
   while(1)
   {
      while(SEGNALE_BASSO);         // aspetto segnale alto
      set_timer0(0);                // inizio a contare
      while(SEGNALE_ALTO);          // aspetto che finisca
      if(get_timer0() < 105)         // se non è lo start ricomincio
         continue;
 
      // trovato lo start prendo la sequenza
      while(SEGNALE_BASSO);                  // aspetto segnale alto
 
      set_timer0(0);                         // inizio a contare il dato
      for(i=0; i<6; i++)
      {             
         while(SEGNALE_ALTO);                // aspetto che finisca il dato
         time = get_timer0();                // salvo il tempo del dato
         set_timer0(0);                      // inizio a contare la pausa
 
         if((time > 59)&&(time < 100))
            dato = 1;                        // sto ricevendo un 1
         else if((time > 24)&&(time < 50))
            dato = 0;                        // sto ricevendo uno 0
         else
         {
            cancella();                      // cancello tutto
            break;                           // ricomincio
         }
 
         while(SEGNALE_BASSO);               // aspetto che finisca la pausa
         time = get_timer0();                // salvo il tempo della pausa
         set_timer0(0);                      // inizio a contare il prossimo dato
 
         if((time > 30))
            shift_sx(dato);                  // il dato è corretto e lo salvo
         else
         {
            cancella();
            break;
         }
      }
 
      if(controlla())
      {
         output_high(PIN_LED);
         delay_ms(200);
         output_low(PIN_LED);
 
         cancella();
      }
   }
 
}

Codice ricevitore main.h

#include "12F508.h";
 
#FUSES NOWDT
#FUSES INTRC                    //Internal RC Osc
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOMCLR                   //Master Clear pin used for I/O
 
#use delay(clock=4000000)

Codice telecomando main.c

#include "main.h"
#include "ir.h"
 
void main()
{
   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_CLOCK_INTERNAL);
 
   setup_wdt(WDT_OFF);
   setup_timer_0(RTCC_INTERNAL);
   setup_timer_1(T1_DISABLED);
 
   while(1)
   {
      invia_start();
      invia_uno();
      invia_uno();
      invia_uno();
      invia_zero();
      invia_uno();
      invia_zero();
 
      delay_ms(10);
   }
 
}

Codice ir.h

#define  CYC_DELAY         CYC_DELAY
#define  US_FINAL_DELAY    600
 
void invia_start()
{
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
 
   output_low(PIN_B2);
   delay_us(300);
}
 
void invia_uno()
{
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
 
   output_low(PIN_B2);
   delay_us(US_FINAL_DELAY);
}
 
void invia_zero()
{
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_high(PIN_B2);
   delay_cycles(CYC_DELAY);
   output_low(PIN_B2);
   delay_cycles(CYC_DELAY);
 
   output_low(PIN_B2);
   delay_us(US_FINAL_DELAY);
}

Codice telecomando main.h

#include "18F1330.h";
#device adc=8
 
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
#FUSES HS                       //High speed Osc (&gt; 4mhz)
#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES BROWNOUT                 //Reset when brownout detected
#FUSES BORV27                   //Brownout reset at 2.7V
#FUSES PUT                      //Power Up Timer
#FUSES NOCPD                    //No EE protection
#FUSES STVREN                   //Stack full/underflow will cause reset
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOWRT                    //Program memory not write protected
#FUSES NOWRTD                   //Data EEPROM not write protected
#FUSES NOWRTC                   //configuration not registers write protected
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES NOEBTR                   //Memory not protected from table reads
#FUSES NOEBTRB                  //Boot block not protected from table reads
#FUSES NOMCLR                     //Master Clear pin disabled
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOCPB                    //No Boot Block code protection
#FUSES NOWRTB                   //Boot block not write protected
#FUSES BBSIZ1K                  //1K words Boot Block size
#FUSES T1OSCA6                  //T1 oscillator pin on A6
#FUSES NOPWMPIN                 //PWM outputs drive active state upon Reset
#FUSES HPOL_HIGH                //High-Side Transistors Polarity is Active-High (PWM 1,3,5 and 7)
#FUSES LPOL_HIGH                //Low-Side Transistors Polarity is Active-High (PWM 0,2,4 and 6)
 
#use delay(clock=20000000)

Circuito con 4 ricevitori per una ricezione a 360°

]]> http://dev.sarasini.it/?feed=rss2&p=224 0 Bluetooth scanner con Bluez http://dev.sarasini.it/?p=211 http://dev.sarasini.it/?p=211#comments Thu, 27 May 2010 11:05:31 +0000 admin http://dev.sarasini.it/?p=211 Ecco un semplice programma in grado di rilevare la presenza di dispositivi bluetooth scritto in C++ (con Qt) utilizzando le librerie BlueZ su Linux.

Link utili:
http://www.bluez.org
http://people.csail.mit.edu/albert/bluez-intro
http://it.wikipedia.org/wiki/Bluetooth

File main.cpp

#include <QtCore/QCoreApplication>
#include <QDebug>
 
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    inquiry_info *ii = NULL;
    int max_rsp, num_rsp;
    int dev_id, sock, len, flags;
    int i;
    char addr[19] = { 0 };
    char name[248] = { 0 };
 
    // bdaddr_t è la struttura di base per specificare un indirizzo bluetooth
    // tutto bluez utilizza questa struttura.
    // str2ba: permette di convertire un indirizzo bluetooth XX:XX:XX:XX:XX:XX in bdaddr_t
    // ba2str: fa esattamente il contrario di str2ba
 
    // hci_get_route ricevendo un bdaddr_t restituisce il device id corrispondente.
    // di solito c'è solo un adattatore bluetooth nel sistema, quindi non specifico nessun bdaddr_t (NULL)
    // e hci_get_route mi restituirà l'id del primo adattatore disponibile.
 
    qDebug() << "Rilevazione di un adattatore bluetooth...";
    dev_id = hci_get_route(NULL);
 
    if(dev_id < 0)
    {
        qDebug() << "Nessun adattore bluetooth disponibile";
        exit(1);
    }
 
    qDebug() << "Trovato un adattatore con device id" << dev_id;
 
    // hci_open_dev ricevendo un device id, apre un socket verso l'adattatore bluetooth corrispondente.
    // anche se c'è solo un adattatore bluetooth nel sistema, passare 0 come device id sarebbe sbagliato
    // perchè non sempre il primo adattatore è indicato con il numero 0
 
    qDebug() << "Apertura di un socket verso l'adattatore...";
    sock = hci_open_dev(dev_id);
 
    if(sock < 0)
    {
        qDebug() << "Impossibile aprire un socket verso l'adattore bluetooth" << dev_id;
        exit(1);
    }
 
    qDebug() << "Socket aperto";
 
    // parametri per il device discovery
    len = 8;                        // l'attesa durerà al massimo 1.28 * len secondi
    max_rsp = 255;                  // numero massimo di dispositivi rilevabili
    flags = IREQ_CACHE_FLUSH;       // svuoto la cache ad ogni nuovo scan. se non lo facessi potrei rilevare periferiche che non sono più attive
 
    ii = (inquiry_info*) malloc(max_rsp * sizeof(inquiry_info));
 
    // hci_inquiry effettua un device discovery e ritorna il numero di dispositivi trovati
 
    qDebug() << "Device discovery in corso...";
    num_rsp = hci_inquiry(dev_id, len, max_rsp, NULL, &ii, flags);
 
    qDebug() << "Device discovery completato";
 
    // se non ho trovato dispositivi lo segnalo
    if(num_rsp < 0)
        qDebug() << "Nessun dispositivo rilevato";
 
    qDebug() << "Dispositivi rilevati:" << num_rsp;
 
    for(i=0; i<num_rsp; i++)
    {
        ba2str(&(ii+i)->bdaddr, addr);
        memset(name, 0, sizeof(name));
 
        if (hci_read_remote_name(sock, &(ii+i)->bdaddr, sizeof(name), name, 0) < 0)
            strcpy(name, "[unknown]");
 
        qDebug() << (i+1) << ") " << addr << " Nome:" << name;
    }
 
    free(ii);
    close(sock);
 
    return a.exec();
}

File progetto

QT  -= gui
 
TARGET = bluetoothScan
CONFIG   += console
CONFIG   -= app_bundle
TEMPLATE = app
SOURCES += main.cpp
 
LIBS += -lbluetooth

]]> http://dev.sarasini.it/?feed=rss2&p=211 0