Functional Safety – Universal Standards - IEC 61508

Regards,

Saravana

Internet of Things IoT - Augmented Reality - Very Interesting but too dangerous - Leads to Virtual Life

Yesterday I have attended a training for IoT - Internet of Things. It was very interesting. World is growing very fast. In near future our world is connected via IoT. It is sure, IoT will replace our mobile phones and people will speak with each other through Augmented Reality. Every human, pet animals, home, office will be addicted to IoT. But....

What will happen in future?

• Every human will have one address just like IP address or MAC address even other organisms.
• Human name will be assigned to IP address just like in DNS server.
• We can easily ping any persons in the world.
• We can identify whether that person is live or dead(shutdown) :-)
• We can identify unknown persons name, address, what diseases he/she is having, in which company he/she is working, married or not, crime record, friends details, mutual friends, etc.
• No need to book tickets to go our native or distant places.
• Without travelling we can enjoy the world's nature.
• We can easily climb Mt Everest.
• We can visit Artic and Antartic continent within a minute.
• Just a like a video game, our life will be changed.
• Even if we dead, we will have more life chances by earning points.
• We will visit all temples virtually, (already started online temple visits in many countries).
• People no need to learn other languages rather just think in native language, some device will translate and other person can understand. 
• There is no real love between each others.
• Virtual Love replaces Real True Love.

• We are going to live Virtual Life - already many people started.
• And finally we will get baby virtually and virtual baby grows within a second - Virtual Population will grow rapidly and Real Population will be drastically reduced by this way.
• Do we need this? 

My first publication - "Hacking Tools" is live on Amazon today - 06-06-2016

My first publication - "Hacking Tools" is live on Amazon today.

https://www.amazon.com/Hacking-Tools-Saravanakumar-H-ebook/dp/B01GN57HCE?ie=UTF8&keywords=hacking%20tools&qid=1465178427&ref_=sr_1_3&s=digital-text&sr=1-3

https://www.amazon.in/Hacking-Tools-Saravanakumar-H-ebook/dp/B01GN57HCE?ie=UTF8&keywords=hacking%20tools&qid=1465188030&ref_=sr_1_11&sr=8-11

I encourage you all to use this tools only for educational purposes and please do not misuse the tools. Without prior permission from clients, please do not use this tools.

The main intention of this book publication is to collect some money and  spend for poor child education. And I promise to dedicate 100% money except tax will be spend for poor child education.

Regards,
Saravana

Serial Peripheral Interface - SPI

Introduction:

SPI allows full-duplex, synchronous, serial communications with peripheral devices. Software can either poll the SPI status flags or SPI operation can be interrupt driven.

Features:

• Communication between SPI and external device is always synchronous.
• SPI is interfaced with external peripheral device for data transfer.
• SPI can transfer data to an external peripheral device.
• SPI can receive data from an external peripheral device.
• SPI can work in master or slave mode.
• In master mode, SPI clock drives the slave peripheral.
• In slave mode, the external clock drives SPI.

SPI Interfacing with a device:

MOSI: 

Master Out Slave In - Output from SPI, connected to Serial Data Input of the peripheral device.

MISO: 

Master In Slave Out - Input to the SPI, connected to Serial Data Output of the peripheral device.

SCLK: 

Clock output from the SPI to the clock input to slave.

SS: 

Chip select output from the SPI - master selects the chip with which it wants to communicate.

Single master, single slave SPI implementation: 

Single master, multiple slave SPI implementation:

Data Transfer mechanisim:

1. The software module begins an SPI transmission by writing a byte to the SPI transmit data register.
2. This byte is transferred to the shift register, when SPI transmit data register becomes empty the byte begins shifting out a bit at a time on the MOSI pin synchronized with the master clock signal.
3. The transfer will continue for 8 clock cycles, transferring all 8-bits.
4. The transmission ends when the whole byte is shifted out of the master SPI shift register and into the slave shift register.
5. If SPI is receiving, the incoming byte will come to the shift register from the MISO pin.
6. When one complete byte is received by the shift register, byte is copied to receive data register.

Thanks for reading !!!

All the Best !!!

Regards,

Saravana

AUTOSAR - Introduction

AUTomotive Open System ARchitecture:

• Is an open and standardized automotive software architecture, together developed by automobile manufacturers, suppliers and tool developers.

• Hardware independent Software layer.

• Transferability of functions.

• Redundancy activation.

AUTOSAR Key Topics:

AUTOSAR provides three main areas of results:

Architecture:

Software architecture including a complete basic (environmental) software stack for an ECU as an integration platform for hardware independent SW applications

Methodology:

Exchange formats (templates) to enable a seamless configuration process of the basic software stack and the integration of application software in ECUs

Application Interfaces:

Specification of application interfaces as a standard for application software modules 

Benefits from AUTOSAR:

OEM:

• OEM overlapping reuse of software modules
• Maintaining ability to compete on innovative functions, enlarged design flexibility
• Simplification of the integration task
• Reduction of total SW development costs

Supplier:

• Reduction of version proliferation
• Development partitioning among suppliers
• Increase of efficiency in functional development
• New business models possible

Tool provider:

• Common interfaces with development processes
• Seamless, manageable, task optimized (time dependent) tool landscape

New market entrant:

• Transparent and defined interfaces enable new business models

AUTOSAR Architecture:

Please refer www.autosar.org for more details.

Few AUTOSAR Specification:

–        AUTOSAR_TechnicalOverview

–    AUTOSAR_LayeredSoftwareArchitecture

–        AUTOSAR_SWS_VirtualFunctionBus           

–        AUTOSAR_SWS_RTE

–        AUTOSAR_SoftwareComponentTemplate

–        AUTOSAR_SystemTemplate

–        AUTOSAR_SWS_DEM     

–        AUTOSAR_SWS_COM

–        AUTOSAR_SWS_ComManager

–        AUTOSAR_ECU_Configuration    

–        AUTOSAR_SWS_ECU_StateManager                     

–        AUTOSAR_SWS_WatchdogManager

–        AUTOSAR_SWS_NVRAM_Manager

–        AUTOSAR_SimulinkStyleguide  

–        AUTOSAR_SWS_PDU_Router   

–        AUTOSAR_SWS_StandardTypes              

–        AUTOSAR_SWS_CompilerAbstraction

At present AUTOSAR 4.x is the latest. If you want more details/training materials about AUTOSAR then feel free to contact me. All the best!!!

Regards

Saravana

interfacing of the LCD module with 8051 P89V51RD2

#include
#include
#include

xdata volatile unsigned char rs _at_ 0xFE01;
xdata volatile unsigned char lcd _at_ 0xFE00;

void main()
{
init_lcd();
printlcd(" Ei Labz ");

while(1);

}
/*********************************************************
Function to initialize lcd
*********************************************************/
void init_lcd()
{
writecommand(0x38); //Two lines 5x7 matrix
writecommand(0x01); //Clear Display screen
writecommand(0x06); //Increment Cursor
writecommand(0x0c); //Display on cursor off
}
/*********************************************************/
/*********************************************************
Function to write COMMAND into lcd
*********************************************************/
void writecommand(unsigned char data1)
{
lcd=data1;
_nop_();
_nop_();

delay();
}
/*********************************************************/
/*********************************************************
Function to print a string data into lcd
*********************************************************/
void printlcd(unsigned char *str)
{
unsigned char len,i;

len=strlen(str);

for(i=0;i<=len-1;i++)
{
writedata(*str);
str++;
}
}

/*********************************************************/
void writedata(unsigned char data2)
{
rs=data2;
_nop_();
_nop_();

delay();
}
/*********************************************************
Function which causes some delay
*********************************************************/
void delay()
{
int k;

for(k=0;k<=9000;k++);
}

ADC interfaced with P89V51RD2 Microcontroller.

#include
#include
#define ch1 0xE8;
#define ch2 0xE9;
#define ch3 0xEA;
#define ch4 0xEB;
#define ch5 0xEC;
#define ch6 0xED;
#define ch7 0xEE;
#define ch8 0xEF;

xdata volatile unsigned char CONTROL _at_ 0xFC00;

sbit b=P3^2;

void Send(unsigned char x)
{
SBUF=x;
while(!TI);
TI=0;
}


void Send_String(char* string, unsigned char no_of_bytes)
{

int i, stringlength = no_of_bytes;

for(i=1; i<=stringlength; i++)
{
Send(*string++);
}

}
void hex2ascii(unsigned char i)
{

unsigned char tmp;
unsigned char ASCII[2];

tmp = i>>4;

if(tmp <= 0x09)
ASCII[0] = tmp+0x30;

else
{
ASCII[0] = tmp-0x9;
ASCII[0] += 0x40;
}

tmp = (i & 0x0f);

if(tmp <= 0x09)
ASCII[1] = tmp+0x30;

else
{
ASCII[1] = tmp-0x9;
ASCII[1] += 0x40;
}

Send_String(ASCII,2);
}


unsigned char Read_ADC(unsigned char x)
{
b=1;
if(x=='1')
{
CONTROL=ch1;
while(!b);
return CONTROL;

}
if(x=='2')
{
CONTROL=ch2;
while(!b);
b = 0;
return CONTROL;
}
if(x=='3')
{
CONTROL=ch3;
while(!b);
return CONTROL;
}
if(x=='4')
{
CONTROL=ch4;
while(!b);
return CONTROL;
}
if(x=='5')
{
CONTROL=ch5;
while(!b);
return CONTROL;
}
if(x=='6')
{
CONTROL=ch6;
while(!b);
return CONTROL;
}
if(x=='7')
{
CONTROL=ch7;
while(!b);
return CONTROL;
}
if(x=='8')
{
CONTROL=ch8;
while(!b);
return CONTROL;
}
}

void delay(void)
{
unsigned int k;
for (k=0;k<0xfffe;k++)
{
_nop_();_nop_();_nop_();_nop_();_nop_();
_nop_();_nop_();_nop_();_nop_();_nop_();
_nop_();_nop_();_nop_();_nop_();_nop_();
}
}

void main(void)
{
SCON = 0x50;
TMOD = 0x21;
TH1 = 0xfd;
TL1 = 0xfd;
TCON = 0x45;
TR1=1;

while(1)
{

hex2ascii(Read_ADC('1'));

delay();
}
}