It defines with device pin of further syntax structure, instead of pin to write pin input-output signal

#define LCD_PIN; //

#define LCD_IO_PIN; //

#define OzOLED_PIN; //

#define CPU_PIN; //

#define CPU_IO_PIN; //

#define RAM_PIN; //

#define RAM_IO_PIN; //

#define SDRAM_PIN; //

#define SDRAM_IO_PIN; //

#define DRAM_PIN; //

#define DRAM_IO_PIN; //

#define SRAM_PIN; //

#define SRAM_IO_PIN; //

#define ROM_PIN; //

#define ROM_IO_PIN; //

#define EPROM_PIN; //

#define EPROM_IO_PIN; //

#define EEPROM_PIN; //

#define EEPROM_IO_PIN; //

#define RG_PIN; //

#define ADC_PIN; //

#define DAC_PIN; //

#define GPS_PIN; //

#define AVR_PIN; //

#define AVR_IO_PIN; //

#define MCU_PIN; //

#define MCU_IO_PIN; //

#define VGA_PIN; //

#define AC_PIN; //

#define DRV_PIN; //

#define MIC_PIN; //

#define SIM_PIN; //

#define BC_PIN; //

#define CF_PIN; //

#define SD_PIN; //

#define SDHC_PIN; //

#define SDHC_IO_PIN; //

#define MMC_PIN; //

#define MMC_IO_PIN; //

#define WIFI_PIN; //

#define BLU_PIN; //

#define MOD_PIN; //

#define MOD_IO_PIN; //

#define MOD_USART_PIN; //

#define MOD_SIM_PIN; //

#define LAN_PIN; //

#define SENS_PIN; //

#define LOG_PIN; //

#define RT_PIN; //

#define HDD_PIN; //

#define BUTTON_PIN; //

#define LED_PIN; //

#define STA_PIN; //

#define RTC_PIN; //

#define CLOCK_PRESCALER_PIN; //

#define USB_CFG_IOPORTNAME PIN; //

#define USB_CFG_DMINUS_BIT PIN; //

#define USB_CFG_DPLUS_BIT PIN; //

List of included devices:

#include<ArduinoRobot.h>

#include<Arduino_LCD.h>

#include<Compass.h>

#include<EasyTransfer2.h>

#include<EEPROM_I2C.h>

#include<Fat16.h>

#include<Fat16Config.h>

#include<Fat16mainpage.h>

#include<Fat16util.h>

#include<FatStructs.h>

#include<Multiplexer.h>

#include<SdCard.h>

#include<SdInfo.h>

#include<Squawk.h>

#include<SquawkSD.h>

#include<Keyboard.h>

#include<RTCZero.h>

#include<SoftwareSerial.h>

#include<Mouse.h>

#include<Audio.h>

#include<DAC.h>

#include<frequencyToNote.h>

#include<MIDIUSB.h>

#include<pitchToNote.h>

#include<Adafruit_GPS.h>

#include<LiquidCrystal.h>

#include<SD.h>

#include<SDHC.h>

#include<SPI.h>

#include<GSM.h>

#include<GSM3CircularBuffer.h>

#include<GSM3IO.h>

#include<GSM3MobileAccessProvider.h>

#include<GSM3MobileCellManagement.h>

#include<GSM3MobileClientProvider.h>

#include<GSM3MobileClientService.h>

#include<GSM3MobileDataNetworkProvider.h>

#include<GSM3MobileMockupProvider.h>

#include<GSM3MobileNetworkProvider.h>

#include<GSM3MobileNetworkRegistry.h>

#include<GSM3MobileServerProvider.h>

#include<GSM3MobileServerService.h>

#include<GSM3MobileSMSProvider.h>

#include<GSM3MobileVoiceProvider.h>

#include<GSM3ShieldV1.h>

#include<GSM3ShieldV1AccessProvider.h>

#include<GSM3ShieldV1BandManagement.h>

#include<GSM3ShieldV1BaseProvider.h>

#include<GSM3ShieldV1CellManagement.h>

#include<GSM3ShieldV1ClientProvider.h>

#include<GSM3ShieldV1DataNetworkProvider.h>

#include<GSM3ShieldV1DirectModemProvider.h>

#include<GSM3ShieldV1ModemCore.h>

#include<GSM3ShieldV1ModemVerification.h>

#include<GSM3ShieldV1MultiClientProvider.h>

#include<GSM3ShieldV1MultiServerProvider.h>

#include<GSM3ShieldV1PinManagement.h>

#include<GSM3ShieldV1ScanNetworks.h>

#include<GSM3ShieldV1ServerProvider.h>

#include<GSM3ShieldV1SMSProvider.h>

#include<GSM3ShieldV1VoiceProvider.h>

#include<GSM3SMSService.h>

#include<GSM3SoftSerial.h>

#include<GSM3VoiceCallService.h>

#include<usart.h>

#include<string.h>

#include<avr/io.h>

#include<io.h>

#include<SIM.h>

#include<MDM.h>

#include<LED.h>

#include<GPIO.h>

#include<Wire.h>

#include<receiver.h>

#include<transmitter.h>

#include<digitalpotentiometer.h>

#include<usb_serial.h>

#include<Dhcp.h>

#include<Dns.h>

#include<Ethernet.h>

#include<EthernetClient.h>

#include<EthernetServer.h>

#include<EthernetUdp.h>

#include<util.h>

#include<SATA.h>

#include<HDD.h>

#include<CDROM.h>

#include<Wprogram.h>

#include<avr/sfr_defs.h>

#include<avr/portpins.h>

#include<avr/common.h>

#include<avr/version.h>

#include<array.h>

#include<avr/cpufunc.h>

#include<eeprom.h>

#include<eepromanything.h>

#include<RTC.h>

#include<count.h>

#include<time.h>

#include<avr/pgmspace.h>

#include<OzOLED.h>

#include<Wiegand.h>

Digital input/output functions

pinMode(PIN, OUTPUT); //

pinMode(PIN, INPUT); //

digitalWrite(PIN, HIGH); //

digitalWrite(PIN, LOW); //

Serial.begin(75); //

Serial.begin(110); //

Serial.begin(134); //

Serial.begin(150); //

Serial.begin(300); //

Serial.begin(600); //

Serial.begin(1200); //

Serial.begin(1800); //

Serial.begin(2400); //

Serial.begin(4800); //

Serial.begin(7200); //

Serial.begin(9600); //

Serial.begin(14400); //

Serial.begin(19200); //

Serial.begin(38400); //

Serial.begin(57600); //

Serial.begin(115200); //

Serial.begin(128000); //

char Keyboard[][] = {}; //

int y, x; // Two counter variables to count inside for loop

if(y==AB&&x == 0){

//it prints the characters or data on the device

}

String y = “”; //

if(y==”DATA”){

digitalWrite(PIN, HIGH); //

}

if(y==”DATA”){

digitalWrite(PIN, LOW); //

}

for(initialization; condition, increment){

//

}

for(int x=0; 100<x; a++){

DEVICE.println()//

}

Functions:

pinMode(); // it configures the specified pin to behave either as an input or an output

digitalWrite(); // it writes a HIGH or a LOW value to a digital pin

digitalRead(); // it reads the value from a specified digital pin, either HIGH or LOW

analogReference(); // it configures the reference voltage used for analog input (also the value used as the top of the input range)

analogRead(); // it reads the value from the specified analog pin …

analogWrite(); // it writes an analog value (Pulse Width Modulation wave) to a pin …

analogReadResolution(); // it sets the size (in bits) of the value returned by the analog reads

analogWriteResolution(); // it sets the resolution of the analog writes

tone(); // it generates a square wave of the specified frequency (and 50% duty cycle) on a pin…

noTone(); // it stops the generation of a square wave triggered by tone

shiftOut(); // it shifts out a byte of data one bit at a time

shiftIn(); // it shifts in a byte of data one bit at a time

pulseIn(); //it reads a pulse from ... pin

millis(); // it returns the number of milliseconds since the … began running the current program

micros(); // it returns the number of microseconds since the ... began running the current program

delay(); // it pauses the program for the amount of time (in milliseconds) specified as parameter

delayMicroseconds(); // it pauses the program for the amount of time (in microseconds) specified as parameter

min(); // it calculates the minimum of two numbers

max(); // it calculates the maximum of two numbers

abs(); // it computes the absolute value of a number

constrain(); // it constrains a number to be within a range

map(); // it remaps a number from one range to another

pow(); // it calculates the value of a number raised to a power

sqrt(); // it calculates the square root of a number

sin(); // it calculates the sine of an angle (in radians)

cos(); // it calculates the cosine of an angle (in radians)

tan(); // it calculates the tangent of an angle (in radians)

isAlphaNumeric(); //the character had been analyzed through ...

isAlpha(); //the character had been analyzed through ...

isAscii(); //the character had been analyzed through ...

isWhitespace(); //the character had been analyzed through ...

isControl(); //the character had been analyzed through ...

isDigit(); //the character had been analyzed through ...

isGraph(); //the character had been analyzed through ...

isLowerCase(); //the character had been analyzed through ...

isPrintable(); //the character had been analyzed through ...

isPunct(); //the character had been analyzed through ...

isSpace(); //the character had been analyzed through ...

isUpperCase(); //the character had been analyzed through ...

isHexadecimalDigit(); //the character had been analyzed through ...

randomSeed(); // it initializes the pseudo-random number generator, ...

random(); // the random function generates pseudo-random numbers of the...

lowByte(); //a value of any type is a ...

highByte(); //a value of any type is a ...

bitRead(); //It initializes functions of the bit read

bitWrite(); //It initializes functions of the bit write

bitSet(); //the numeric variable whose bit to set for the...

bitClear(); //the numeric variable whose bit to clear for the ...

bit(); //the bit whose value to compute for the ...

attachInterrupt(); //the pin ... is attached at external interrupt

detachInterrupt(); //the pin ... is detached at external interrupt