Brightness sensor using SPI bus - Detect brightness through SPI bus


1. Download and open C# project file
  1. Download source code.

    Brightness.Sample1.zip



2. C# source code for Brightness.Sample1
  1. Program.cs

      
    
    using System;
    
    using Microsoft.SPOT;
    using Microsoft.SPOT.Input;
    using Microsoft.SPOT.Presentation;
    using Microsoft.SPOT.Presentation.Controls;
    using Microsoft.SPOT.Hardware;
    
    using SPL.Script.Engine;
    
    namespace SPLMFConsoleWindow1
    {
        public class Program : Microsoft.SPOT.Application
        {
            public static void Main()
            {
                Program myApplication = new Program();
    
                Window mainWindow = myApplication.CreateWindow();
    
                GPIOButtonInputProvider inputProvider = new GPIOButtonInputProvider(null);
    
                myApplication.Run(mainWindow);
            }
    
            private Window mainWindow;
    
            //##########################  Sample Code  #################################
            private ConsoleWindow _consoleWindow;
    
            private I2CDevice _device = null;
            private SPI _spi1 = null;
            //##########################################################################
    
            public Window CreateWindow()
            {
                mainWindow = new Window();
                mainWindow.Height = SystemMetrics.ScreenHeight;
                mainWindow.Width = SystemMetrics.ScreenWidth;
    
                //##########################  Sample Code  #################################
                Font font = Resources.GetFont(Resources.FontResources.small);
                _consoleWindow = new ConsoleWindow(font);
    
                mainWindow.Child = _consoleWindow;
                //##########################################################################
    
                mainWindow.AddHandler(Buttons.ButtonUpEvent, new ButtonEventHandler(OnButtonUp), false);
    
                mainWindow.Visibility = Visibility.Visible;
    
                Buttons.Focus(mainWindow);
    
                //##########################  Sample Code  #################################
                _consoleWindow.WriteLine("Push Select-Button to make a robot turn.");
                //##########################################################################
    
    
                //##########################  Sample Code  #################################
                I2CDevice.Configuration config = new I2CDevice.Configuration(
                                58,
                                100
                                );
    
                _device = new I2CDevice(config);
    
    
                SPI.Configuration spi_config = new SPI.Configuration(
                            Cpu.Pin.GPIO_Pin11,
                            false,
                            1,
                            1,
                            true,
                            false,
                            15000,
                            SPI.SPI_module.SPI1
                            );
    
                _spi1 = new SPI(spi_config);
    
                System.Threading.Thread serialReaderThread = new System.Threading.Thread(spi_Reader);
                serialReaderThread.Start();
    
                //##########################################################################
    
                return mainWindow;
            }
    
            private void OnButtonUp(object sender, ButtonEventArgs e)
            {
                //##########################  Sample Code  #################################
                if (e.Button == Microsoft.SPOT.Hardware.Button.VK_SELECT)
                {
                    byte[] wBuff = new byte[3];
                    wBuff[0] = 4;
                    wBuff[1] = 90;      //-0.1
                    wBuff[2] = 110;     //0.1
    
                    I2CDevice.I2CWriteTransaction wTr = _device.CreateWriteTransaction(wBuff);
                    I2CDevice.I2CTransaction[] wTrArr = new I2CDevice.I2CTransaction[] { wTr };
    
                    //Go Forwards
                    int count = _device.Execute(wTrArr, 1000);
    
                    _consoleWindow.WriteLine("Turn left");
                }
                //##########################################################################
            }
    
    
            //##########################  Sample Code  #################################
            private void spi_Reader()
            {
                ushort[] wBuff = new ushort[1] { 0x0000 };  //dumy data
                ushort[] rBuff = new ushort[1];
    
                while (true)
                {
                    try
                    {
                        _spi1.WriteRead(wBuff, rBuff);
    
                        if (rBuff != null)
                        {
                            ushort brightness = rBuff[0];
    
                            LogInfo("Detected brightness is " + brightness.ToString());
                        }
                    }
                    catch { }
    
                    System.Threading.Thread.Sleep(500);
                }
            }
    
            private void LogInfo(string log)
            {
                this.Dispatcher.BeginInvoke(
                    new DispatcherOperationCallback(
                        delegate(object report)
                        {
                            _consoleWindow.WriteLine(log);
                            return null;
                        }
                        ), null
                    );
            }
            //##########################################################################
        }
    }
    
    
      



3. Execute C# project
  1. Open "Properties" page of C# project.

  2. Choose ".NET Micro Framework" tab.

  3. Select "SPLMFConsoleEmulator" from the emulator list.



  4. Press "F5" key to run sample code.




4. Launch simulation environment
  1. Start "SPL script editor for MSRDS" and add SPL simulation script.

  2. Add script on the editor as follows.



      
    MFEmulator    emul1
    	/Procedure_I2CWrite:proc_i2c_write
    
    StartSimulationEngine  "SimState/basicsim.xml"
    
    AddNewEntity    ent1  	/Position:1.5  0.3  0
    AddBoxShape  	/Dimensions:0.6  0.8  2.0  	/Mass:100
    	/DiffuseColor:0  0  0.2509804  1
    
    AddNewEntity    ent2  	/Position:0  0.4  -1.5
    AddBoxShape  	/Dimensions:2.0  0.8  0.6  	/Mass:100
    	/DiffuseColor:1  1  0  1
    
    AddNewEntity    ent3  	/Position:-1.5  0.4  0
    AddBoxShape  	/Dimensions:0.6  0.8  2.0  	/Mass:100
    	/DiffuseColor:0  1  0  1
    
    AddDifferentialDriveEntity    base1
    
    AddBrightnessSensorEntity    br1
    	/Position:0  0.4  -0.3
    	/ParentEntity:base1
    	/Procedure_SensorNotify:proc_bright
    
    FlushScript  
    
    procedure  proc_bright
    
    	br = value.RawMeasurement	// 0.0 ~ 1.0
    	br = br * 1000	//convert to 0 ~ 1000 unit
    	
    	print "Brightness: " + br
    	
    	//convert type as ushort
    	br = Util.ToUShort(br)	
    	
    	emul1.SetSpiReadBufferUShort("spi1", br)
    				
    end 
    
    procedure  proc_i2c_write
    	
    	if (value.Id == "i2c1")
    	{
    		command_type = value.ReceivedBytes[0]
    		
    		if (command_type == 1)
    		{		
    			distance = value.ReceivedBytes[1]
    			power = value.ReceivedBytes[2]
    	
    			power = power - 100
    
    			distance = Util.ToDouble(distance / 10.0)
    			power = Util.ToDouble(power / 100.0)
    
    			print "Distance -> " + distance.ToString() + " m / Power -> " + power.ToString()
    			
    			base1.GoTo(distance, power)
    		}
    		else if (command_type == 2)
    		{		
    			degrees = value.ReceivedBytes[1]
    			power = value.ReceivedBytes[2]
    	
    			power = power - 100
    
    			degrees = Util.ToDouble(degrees)
    			power = Util.ToDouble(power / 100.0)
    
    			print "Degrees -> " + degrees.ToString() + " / Power -> " + power.ToString()
    			
    			base1.Turn(degrees, power)
    		}
    		else if (command_type == 4)
    		{		
    			left_power = value.ReceivedBytes[1]
    			right_power = value.ReceivedBytes[2]
    	
    			left_power = left_power - 100
    			right_power = right_power - 100
    
    			left_power = Util.ToDouble(left_power / 100.0)
    			right_power = Util.ToDouble(right_power / 100.0)
    
    			print "Left -> " + left_power.ToString() + " / Right -> " + right_power.ToString()
    			
    			base1.Go(left_power, right_power)
    		}
    	}
    
    end  
    
      


  3. Save script.

  4. Press "F5" key or click "Run" icon.



5. Start demo
  1. Click Select-Button to start demo.



  2. You can see that the brightness value is printed on the log as robot turns.