domingo, 29 de julio de 2018

First Arduino practice, my helloworld practice in Arduino it's soo cool!


ARDUINO GENUINO

I'm soo excited working with the ultimate cool hardware ARDUINO GENUINO!!!




C:\Users\admin\Desktop\arduino\2018-07-29 12_33_48-Elegoo Super Starter Kit para UNO V1.0 2017.7.10.pdf (PROTEGIDO) - Adobe Acrobat.png


/*
  Blink

  Turns an LED on for one second, then off for one second, repeatedly.

  Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
  it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
  the correct LED pin independent of which board is used.
  If you want to know what pin the on-board LED is connected to on your Arduino
  model, check the Technical Specs of your board at:
  https://www.arduino.cc/en/Main/Products

  modified 8 May 2014
  by Scott Fitzgerald
  modified 2 Sep 2016
  by Arturo Guadalupi
  modified 8 Sep 2016
  by Colby Newman

  This example code is in the public domain.





Un poco de historia:

What is Arduino?

Arduino is an open-source electronics platform based on easy-to-use hardware and software. Arduino boards are able to read inputs - light on a sensor, a finger on a button, or a Twitter message - and turn it into an output - activating a motor, turning on an LED, publishing something online. You can tell your board what to do by sending a set of instructions to the microcontroller on the board. To do so you use the Arduino programming language (based on Wiring), and the Arduino Software (IDE), based on Processing.
Over the years Arduino has been the brain of thousands of projects, from everyday objects to complex scientific instruments. A worldwide community of makers - students, hobbyists, artists, programmers, and professionals - has gathered around this open-source platform, their contributions have added up to an incredible amount of accessible knowledge that can be of great help to novices and experts alike.
Arduino was born at the Ivrea Interaction Design Institute as an easy tool for fast prototyping, aimed at students without a background in electronics and programming. As soon as it reached a wider community, the Arduino board started changing to adapt to new needs and challenges, differentiating its offer from simple 8-bit boards to products for IoT applications, wearable, 3D printing, and embedded environments. All Arduino boards are completely open-source, empowering users to build them independently and eventually adapt them to their particular needs. The software, too, is open-source, and it is growing through the contributions of users worldwide.

Historial[editar]

Placa Arduino UNO con comunicación RS2325
De forma estricta, el proyecto «Arduino» se inició en el año 2005 como un proyecto enfocado a estudiantes en el Instituto IVREA (IDII), en Ivrea (Italia).2​ En aquellos años, los estudiantes usaban el microcontrolador BASIC Stamp, cuyo costo era de $100USD, un costo considerablemente alto para un estudiante promedio. Antes del año 2005, específicamente durante el año 2003, Hernando Barragán había creado la plataforma de desarrollo Wiring como resultado de su proyecto de tesis en la maestría en el IDII, bajo la supervisión de Massimo Banzi y Casey Reas, quienes eran conocidos por haber trabajado en el lenguaje Processing y daban clases en el IDII2​. El objetivo del proyecto era crear herramientas simples y de bajo costo para la creación de proyectos digitales por parte de personas sin altos conocimientos técnicos o sin un perfil de ingeniería. El proyecto Wiring era una placa de desarrollo de hardware la cual consistía de una placa de circuito impreso (PCB) con un microcontrolador ATmega168, un Ambiente de Desarrollo Integrado (IDE) basado en funciones de procesamiento y una biblioteca de funciones para programar fácilmente el microcontrolador.6​ Regresando al año 2005, Massimo Banzi junto con David Mellis, quien era otro estudiante del IDII, y David Cuartielles, agregaron soporte a Wiring para el microcontrolador ATmega8 el cual era más económico al de un principio (Atmega168). Pero en lugar de continuar el desarrollo en Wiring, se separaron del proyecto y lo renombraron Arduino.6
El nombre Arduino viene de un un bar en Ivrea, Italia; en donde algunos de los fundadores del proyecto Arduino solían reunirse. El bar tiene el nombre de " Bar di Re Arduino", y fue nombrado en honor a Arduino de Ivrea, quien fue el margrave de la Marcha de Ivrea y Rey de Italia desde el año 1002 hasta el año 1014.4
El equipo inicial de Arduino estaba conformado por Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino y David Mellis. Hernando Barragán no fue invitado a participar.6
Posteriormente el proyecto Wiring siguió adelante, placas menos densas y menos costosas se distribuyeron con la comunidad de código abierto.7
Adafruit Industries, un proveedor de componentes electrónicos y fabricante de placas de circuito empreso, entre ellas placas Arduino, ubicado en la ciudad de Nueva York, estimó a mediados del año 2011 que más de 300,000 placas Arduino oficiales habían sido producidos comercialmente.8​ En el año 2013, estimó que 700,000 placas Arduino oficiales se encontraban en manos de usuarios.9
En octubre del año 2016, Federico Musto (actualmente ex CEO de Arduino), adquirió el 50% de la compañía luego de haber adquirido las acciones de uno de los miembros fundadores del equipo. En abril del año 2017, la revista Wired informó que Musto había "fabricado su propio expediente académico", habiéndolo publicado en el sitio web de Arduino, cuenta personal de LinkedIn, e incluso en documentos comerciales oficiales italianos. Musto afirmaba tener un PhD en ciencias de la computación por el Instituto Tecnológico de Massachusetts (MIT), y un MBA de la Universidad de Nueva York. La revista Wired reportó que ninguna de las universidades que él afirmaba haber cursado tenía registro alguno de la asistencia de Musto. Musto más tarde afirmó, en una entrevista a Wired, que realmente nunca había obtenido los grados académicos.10
En el año 2017, Massimo Banzi anunció la creación de la «Fundación Arduino», declarando que sería «un nuevo comienzo para Arduino». Dicha fundación según palabras del mismo Banzi «permitirá defender los valores fundamentales de la Comunidad Arduino dentro del ecosistema de código abierto y hacer que nuestro compromiso ( haciendo referencia a la empresa Arduini) con el código abierto sea más sólido que nunca».11​ Sin embargo ha existido cierta incertidumbre del desarrollo actual de dicha iniciativa.12
La controversia en torno a Federico Musto continuó en julio del año 2017, según los informes, por haber retirado licencias de código abierto, esquemas y códigos del sitio web de Arduino, lo que provocó escrutinio y protesta por parte de la comunidad de maker.13
En octubre del año 2017, Arduino anunció su asociación con la multinacional ARM Holdings (ARM). El anuncio decía, en parte, que "ARM reconoce la independencia como un valor central de Arduino... sin ningún acuerdo de uso exclusivo con la arquitectura ARM". Arduino tiene la intención de seguir trabajando con todos los proveedores y arquitecturas de tecnología.14
Para la producción en serie de la primera versión se tomó en cuenta que el coste no fuera mayor de 30 euros, que fuera ensamblado en una placa de color azul, debía ser Plug and Play y que trabajara con todas las plataformas informáticas tales como MacOSXWindows y GNU/Linux. Las primeras 300 unidades se las dieron a los alumnos del Instituto IVREA, con el fin de que las probaran y empezaran a diseñar sus primeros prototipos.[cita requerida]

Disputa por la marca Arduino[editar]

A principios de 2008, los cinco cofundadores del proyecto Arduino crearon la empresa Arduino LLC, cuyo propósito era englobar las marcas comerciales asociadas a las placas Arduino15​. La fabricación y venta de las placas Arduino debía ser hecha por compañías externas, y Arduino LLC obtendría un royalty(comisión), de ellos. Los estatutos bajo los cuales se creó Arduino LLC especificaban que cada uno de los cinco fundadores originales transferirían la propiedad de la marca Arduino a la empresa recién formada (Arduino LLC).[cita requerida]
A finales de 2008, la empresa de Gianluca Martino (Smart Projects), registró la marca Arduino en Italia y mantuvo esto en secreto de los otros co-fundadores durante un periodo aproximado de dos años. Esto fue revelado cuando la compañía Arduino LLC intentó registrar la marca en otras partes del mundo (originalmente ellos se habían registrado solo en EE. UU.), y descubriendo que esta ya estaba registrada en Italia. Las negociaciones con Gianluca y su firma para poner la marca bajo control de la compañía Arduino LLC fallaron. En el año 2014, Smart Projects comenzó a negarse a pagar regalías. Luego nombraron a un nuevo CEO, Federico Musto, que renombró a la empresa Arduino SRL y creó el sitio web arduino.org, copiando los gráficos y el diseño del arduino.cc original. Esto resultó una fractura en el equipo de desarrollo de Arduino.161718
En enero de 2015, Arduino LLC entabló una demanda contra Arduino SRL.19
En mayo de 2015, Arduino LLC creó la marca mundial Genuino, utilizada como marca fuera de los Estados Unidos. 20
En julio de 2017, la nueva compañía BCMI LABS LLC fundada por Massimo Banzi, David Cuartielles, David Mellis y Tom Igoe, adquirió Arduino AG y todas las marcas registradas de Arduino. Fabio Violante se convirtió en el nuevo CEO que reemplazaría a Federico Musto, quien ya no trabajaría para Arduino AG. 21
Durante la "World Maker Faire" en Nueva York del 1 de octubre de 2016, el cofundador y CEO de Arduino LLC (Massimo Banzi) y el CEO de Arduino SRL (Federico Musto), anunciaron la fusión de ambas compañías. 22

Hardware[editar]

Placa Arduino con Ethernet Shield y sensor de ritmo cardíaco
Arduino es hardware libre. Los diseños de referencia de hardware se distribuyen bajo licencia Creative Commons Attribution Share-Alike 2.5 y están disponibles en el sitio web de Arduino. Los esquemáticos y archivos de montaje de componentes (PCBs) para algunas versiones de placas también están disponibles.
Aunque los diseños de hardware y software están disponibles bajo licencias de copyleft, los desarrolladores han solicitado que el nombre Arduino sea exclusivo del producto oficial y no se use para trabajos derivados sin antes solicitar permiso. El documento de política oficial sobre el uso del nombre Arduino enfatiza que el proyecto está abierto a incorporar el trabajo de otros en el producto oficial. Varios productos compatibles con Arduino lanzados comercialmente han evitado incluir el nombre del proyecto Arduino en sus dispositivos al emplear nombres que terminan en «-duino».
La mayoría de las placas Arduino constan de un microcontrolador AVR Atmel-8 bits (ATmega8, [25] ATmega168, ATmega328, ATmega1280, ATmega2560), cada microncontrolador consta de diversas cantidades de memoria flash, pines y funciones. Las placas utilizan pines/cabezales hembra de una o dos hileras que facilitan las conexiones e incorporación en otros circuitos.
Las placas Arduino pueden conectarse con módulos adicionales denominados shields (escudos, por su traducción al español), dichos shields aumentan las características técnicas de la placa Arduino en uso, debido a que posen circuitos específicos que añaden una o más funcionalidades extras a la placa Arduino nativa en la cual se utilice, también se les conoce como placas de expansión. La mayoría de estos shields se conectan a través de un bus serie I²C, aunque existen también aquellas que emplean conexión mediante el bus UART (Universal Asynchronous Receiver-Transmitter, por su traducción al español Transmisor-Receptor Asíncrono Universal), así como con el bus SPI (Serial Peripheral Interface, por su traducción al español Interfaz Periférica Serial).
La mayoría de las placas incluyen un regulador lineal de 5 V y un oscilador de cristal de 16 MHz, o un resonador de cerámica según sea el caso. Algunos diseños, como el LilyPad, funcionan a 8 MHz y prescinden del regulador de voltaje a bordo debido a restricciones de factor/tamaño de forma específicas.
Los modelos de Arduino se categorizan en placas de desarrollo, placas de expansión (shields), kits, accesorios e impresoras 3D.
  • Placas: Arduino Galileo,23​ Arduino Uno, Arduino Leonardo, Arduino Due, Arduino Yún, Arduino Tre (En Desarrollo), Arduino Zero, Arduino Micro, Arduino Esplora, Arduino Mega ADK, Arduino Ethernet, Arduino Mega 2560, Arduino Robot, Arduino Mini, Arduino Nano, LilyPad Arduino Simple, LilyPad Arduino SimpleSnap, LilyPad Arduino, LilyPad Arduino USB, Arduino Pro Mini, Arduino Fio, Arduino Pro, Arduino MKR1000/Genuino MKR1000, Arduino MICRO/Genuino MICRO, Arduino 101/Genuino 101, Arduino Gemma.
  • Placas de expansión (shields): Arduino GSM Shield, Arduino Ethernet Shield, Arduino WiFi Shield, Arduino Wireless SD Shield, Arduino USB Host Shield, Arduino Motor Shield, Arduino Wireless Proto Shield, Arduino Proto Shield.
  • Kits: The Arduino Starter Kit, Arduino Materia 101.
  • Accesorios: Pantalla LCD TFT, Adaptador USB/Serie y MiniUSB/Serie, Arduino ISP.
  • Impresoras 3d: Arduino Materia 101.

Equipo de desarrollo[editar]

El núcleo del equipo de desarrollo de Arduino está formado por Massimo BanziDavid CuartiellesTom IgoeGianluca MartinoDavid Mellis y Nicholas Zambetti.

Aplicaciones[editar]

La plataforma Arduino ha sido usada como base en diversas aplicaciones electrónicas:
  • Xoscillo: Osciloscopio de código abierto24
  • Equipo científico para investigaciones25
  • Arduinome: Un dispositivo controlador MIDI26
  • OBDuino: un económetro que usa una interfaz de diagnóstico a bordo que se halla en los automóviles modernos
  • SCA-ino: Sistema de cómputo automotriz capaz de monitorear sensores como el TPS, el MAP y el 02S y controlar actuadores automotrices como la bobina de ignición, la válvula IAC y aceleradores electrónicos
  • Humane Reader: dispositivo electrónico de bajo coste con salida de señal de TV que puede manejar una biblioteca de 5000 títulos en una tarjeta microSD27
  • The Humane PC: equipo que usa un módulo Arduino para emular un computador personal, con un monitor de televisión y un teclado para computadora28
  • Ardupilot: software y hardware de aeronaves no tripuladas
  • ArduinoPhone: un teléfono móvil construido sobre un módulo Arduino2930
  • Máquinas de control numérico por computadora (CNC)
  • Open Theremín Uno: Versión digital de hardware libre del instrumento Theremín
  • Impresoras 3D
  • Ambilight, sistema de retroiluminación led imitando el sistema de los televisores Philips [cita requerida]

Otras interfaces de programación[editar]

Es posible comunicar una aplicación que corra sobre Arduino con otros dispositivos que corran otros lenguajes de programación y aplicaciones populares,31​ debido a que Arduino usa la transmisión serial de datos, la cual es soportada por la mayoría de los lenguajes que se mencionan a continuación. Y para los que no soportan el formato serie de forma nativa, es posible utilizar software intermediario que traduzca los mensajes enviados por ambas partes para permitir una comunicación fluida. Algunos ejemplos de lenguajes son:


*++++++++++++++

  http://www.arduino.cc/en/Tutorial/Blink
*/

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

****************

Subrutine for the LCD screen

//www.elegoo.com
//2016.12.9

/*
  LiquidCrystal Library - Hello World

 Demonstrates the use a 16x2 LCD display.  The LiquidCrystal
 library works with all LCD displays that are compatible with the
 Hitachi HD44780 driver. There are many of them out there, and you
 can usually tell them by the 16-pin interface.

 This sketch prints "Hello World!" to the LCD
 and shows the time.

  The circuit:
 * LCD RS pin to digital pin 7
 * LCD Enable pin to digital pin 8
 * LCD D4 pin to digital pin 9
 * LCD D5 pin to digital pin 10
 * LCD D6 pin to digital pin 11
 * LCD D7 pin to digital pin 12
 * LCD R/W pin to ground
 * LCD VSS pin to ground
 * LCD VCC pin to 5V
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)

 Library originally added 18 Apr 2008
 by David A. Mellis
 library modified 5 Jul 2009
 by Limor Fried (http://www.ladyada.net)
 example added 9 Jul 2009
 by Tom Igoe
 modified 22 Nov 2010
 by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */

// include the library code:
#include "LiquidCrystal.h"

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("Roberto Perez eres un chingon!!");
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis() / 1000);
}


***********************
#include "LiquidCrystal.h"

#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "Arduino.h"

// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set: 
//    DL = 1; 8-bit interface data 
//    N = 0; 1-line display 
//    F = 0; 5x8 dot character font 
// 3. Display on/off control: 
//    D = 0; Display off 
//    C = 0; Cursor off 
//    B = 0; Blinking off 
// 4. Entry mode set: 
//    I/D = 1; Increment by 1 
//    S = 0; No shift 
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).

LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
     uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
     uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
  init(0, rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7);
}

LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t enable,
     uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
     uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
  init(0, rs, 255, enable, d0, d1, d2, d3, d4, d5, d6, d7);
}

LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
     uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
{
  init(1, rs, rw, enable, d0, d1, d2, d3, 0, 0, 0, 0);
}

LiquidCrystal::LiquidCrystal(uint8_t rs,  uint8_t enable,
     uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
{
  init(1, rs, 255, enable, d0, d1, d2, d3, 0, 0, 0, 0);
}

void LiquidCrystal::init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
  _rs_pin = rs;
  _rw_pin = rw;
  _enable_pin = enable;
  
  _data_pins[0] = d0;
  _data_pins[1] = d1;
  _data_pins[2] = d2;
  _data_pins[3] = d3; 
  _data_pins[4] = d4;
  _data_pins[5] = d5;
  _data_pins[6] = d6;
  _data_pins[7] = d7; 

  if (fourbitmode)
    _displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
  else 
    _displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS;
  
  begin(16, 1);  
}

void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
  if (lines > 1) {
    _displayfunction |= LCD_2LINE;
  }
  _numlines = lines;

  setRowOffsets(0x00, 0x40, 0x00 + cols, 0x40 + cols);  

  // for some 1 line displays you can select a 10 pixel high font
  if ((dotsize != LCD_5x8DOTS) && (lines == 1)) {
    _displayfunction |= LCD_5x10DOTS;
  }

  pinMode(_rs_pin, OUTPUT);
  // we can save 1 pin by not using RW. Indicate by passing 255 instead of pin#
  if (_rw_pin != 255) { 
    pinMode(_rw_pin, OUTPUT);
  }
  pinMode(_enable_pin, OUTPUT);
  
  // Do these once, instead of every time a character is drawn for speed reasons.
  for (int i=0; i<((_displayfunction & LCD_8BITMODE) ? 8 : 4); ++i)
  {
    pinMode(_data_pins[i], OUTPUT);
   } 

  // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
  // according to datasheet, we need at least 40ms after power rises above 2.7V
  // before sending commands. Arduino can turn on way before 4.5V so we'll wait 50
  delayMicroseconds(50000); 
  // Now we pull both RS and R/W low to begin commands
  digitalWrite(_rs_pin, LOW);
  digitalWrite(_enable_pin, LOW);
  if (_rw_pin != 255) { 
    digitalWrite(_rw_pin, LOW);
  }
  
  //put the LCD into 4 bit or 8 bit mode
  if (! (_displayfunction & LCD_8BITMODE)) {
    // this is according to the hitachi HD44780 datasheet
    // figure 24, pg 46

    // we start in 8bit mode, try to set 4 bit mode
    write4bits(0x03);
    delayMicroseconds(4500); // wait min 4.1ms

    // second try
    write4bits(0x03);
    delayMicroseconds(4500); // wait min 4.1ms
    
    // third go!
    write4bits(0x03); 
    delayMicroseconds(150);

    // finally, set to 4-bit interface
    write4bits(0x02); 
  } else {
    // this is according to the hitachi HD44780 datasheet
    // page 45 figure 23

    // Send function set command sequence
    command(LCD_FUNCTIONSET | _displayfunction);
    delayMicroseconds(4500);  // wait more than 4.1ms

    // second try
    command(LCD_FUNCTIONSET | _displayfunction);
    delayMicroseconds(150);

    // third go
    command(LCD_FUNCTIONSET | _displayfunction);
  }

  // finally, set # lines, font size, etc.
  command(LCD_FUNCTIONSET | _displayfunction);  

  // turn the display on with no cursor or blinking default
  _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;  
  display();

  // clear it off
  clear();

  // Initialize to default text direction (for romance languages)
  _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
  // set the entry mode
  command(LCD_ENTRYMODESET | _displaymode);

}

void LiquidCrystal::setRowOffsets(int row0, int row1, int row2, int row3)
{
  _row_offsets[0] = row0;
  _row_offsets[1] = row1;
  _row_offsets[2] = row2;
  _row_offsets[3] = row3;
}

/********** high level commands, for the user! */
void LiquidCrystal::clear()
{
  command(LCD_CLEARDISPLAY);  // clear display, set cursor position to zero
  delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal::home()
{
  command(LCD_RETURNHOME);  // set cursor position to zero
  delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal::setCursor(uint8_t col, uint8_t row)
{
  const size_t max_lines = sizeof(_row_offsets) / sizeof(*_row_offsets);
  if ( row >= max_lines ) {
    row = max_lines - 1;    // we count rows starting w/0
  }
  if ( row >= _numlines ) {
    row = _numlines - 1;    // we count rows starting w/0
  }
  
  command(LCD_SETDDRAMADDR | (col + _row_offsets[row]));
}

// Turn the display on/off (quickly)
void LiquidCrystal::noDisplay() {
  _displaycontrol &= ~LCD_DISPLAYON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal::display() {
  _displaycontrol |= LCD_DISPLAYON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turns the underline cursor on/off
void LiquidCrystal::noCursor() {
  _displaycontrol &= ~LCD_CURSORON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal::cursor() {
  _displaycontrol |= LCD_CURSORON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turn on and off the blinking cursor
void LiquidCrystal::noBlink() {
  _displaycontrol &= ~LCD_BLINKON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal::blink() {
  _displaycontrol |= LCD_BLINKON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// These commands scroll the display without changing the RAM
void LiquidCrystal::scrollDisplayLeft(void) {
  command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal::scrollDisplayRight(void) {
  command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}

// This is for text that flows Left to Right
void LiquidCrystal::leftToRight(void) {
  _displaymode |= LCD_ENTRYLEFT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This is for text that flows Right to Left
void LiquidCrystal::rightToLeft(void) {
  _displaymode &= ~LCD_ENTRYLEFT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'right justify' text from the cursor
void LiquidCrystal::autoscroll(void) {
  _displaymode |= LCD_ENTRYSHIFTINCREMENT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'left justify' text from the cursor
void LiquidCrystal::noAutoscroll(void) {
  _displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal::createChar(uint8_t location, uint8_t charmap[]) {
  location &= 0x7; // we only have 8 locations 0-7
  command(LCD_SETCGRAMADDR | (location << 3));
  for (int i=0; i<8; i++) {
    write(charmap[i]);
  }
}

/*********** mid level commands, for sending data/cmds */

inline void LiquidCrystal::command(uint8_t value) {
  send(value, LOW);
}

inline size_t LiquidCrystal::write(uint8_t value) {
  send(value, HIGH);
  return 1; // assume sucess
}

/************ low level data pushing commands **********/

// write either command or data, with automatic 4/8-bit selection
void LiquidCrystal::send(uint8_t value, uint8_t mode) {
  digitalWrite(_rs_pin, mode);

  // if there is a RW pin indicated, set it low to Write
  if (_rw_pin != 255) { 
    digitalWrite(_rw_pin, LOW);
  }
  
  if (_displayfunction & LCD_8BITMODE) {
    write8bits(value); 
  } else {
    write4bits(value>>4);
    write4bits(value);
  }
}

void LiquidCrystal::pulseEnable(void) {
  digitalWrite(_enable_pin, LOW);
  delayMicroseconds(1);    
  digitalWrite(_enable_pin, HIGH);
  delayMicroseconds(1);    // enable pulse must be >450ns
  digitalWrite(_enable_pin, LOW);
  delayMicroseconds(100);   // commands need > 37us to settle
}

void LiquidCrystal::write4bits(uint8_t value) {
  for (int i = 0; i < 4; i++) {
    digitalWrite(_data_pins[i], (value >> i) & 0x01);
  }

  pulseEnable();
}

void LiquidCrystal::write8bits(uint8_t value) {
  for (int i = 0; i < 8; i++) {
    digitalWrite(_data_pins[i], (value >> i) & 0x01);
  }
  
  pulseEnable();
}


*******************************

#ifndef LiquidCrystal_h
#define LiquidCrystal_h

#include <inttypes.h>
#include "Print.h"

// commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80

// flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00

// flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00

// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00

// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00

class LiquidCrystal : public Print {
public:
  LiquidCrystal(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
  LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
  LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3);
  LiquidCrystal(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3);

  void init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,
    uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
    uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
    
  void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS);

  void clear();
  void home();

  void noDisplay();
  void display();
  void noBlink();
  void blink();
  void noCursor();
  void cursor();
  void scrollDisplayLeft();
  void scrollDisplayRight();
  void leftToRight();
  void rightToLeft();
  void autoscroll();
  void noAutoscroll();

  void setRowOffsets(int row1, int row2, int row3, int row4);
  void createChar(uint8_t, uint8_t[]);
  void setCursor(uint8_t, uint8_t); 
  virtual size_t write(uint8_t);
  void command(uint8_t);
  
  using Print::write;
private:
  void send(uint8_t, uint8_t);
  void write4bits(uint8_t);
  void write8bits(uint8_t);
  void pulseEnable();

  uint8_t _rs_pin; // LOW: command.  HIGH: character.
  uint8_t _rw_pin; // LOW: write to LCD.  HIGH: read from LCD.
  uint8_t _enable_pin; // activated by a HIGH pulse.
  uint8_t _data_pins[8];

  uint8_t _displayfunction;
  uint8_t _displaycontrol;
  uint8_t _displaymode;

  uint8_t _initialized;

  uint8_t _numlines;
  uint8_t _row_offsets[4];
};

#endif


viernes, 27 de julio de 2018

REDHAT SUCKS!!! besides Installing CentOs from cero

You can look my complete reference of the installation here: https://physicsphd.blogspot.com/2018/07/instalando-centos-desde-cero-porque.html






Instalando CentOs desde cero porque REDHAT apesta, REDHAT SUCKS!

REDHAT SUCKS!
 Incluso tengo los discos originales Redhat 7 a la venta si a alguien le interesa


I was a fan of the Redhat versions for more than 10 years, however when installing the latest versions I see that they have locks everywhere, something called Satellite that blocks the system and leaves it unusable without being able to generate any update if it is not registered in redhat. Which makes the system pretty bad. so install CentOS I installed CentOS because Redhat sucks !!!, I've had very bad experiences lately with Redhat, since I had some apps installed in Openshift (Openshit), and they made a stupid upgrade to Docker that never worked, at least for me, and I ended up installing my apps in HEROKU, which worked quite well, for a NodeJS and Spring Bot app Well what we came for, install CentOS: download the iso of the page of centos and Use the following ISO version: CentOS-7-x86_64-Everything-1804.iso A small introduction:



CentOS (/ˈsɛntɒs/, from Community Enterprise Operating System) is a Linux distribution that provides a free, enterprise-class, community-supported computing platform functionally compatible with its upstream source, Red Hat Enterprise Linux (RHEL).[6][7] In January 2014, CentOS announced the official joining with Red Hat while staying independent from RHEL,[8] under a new CentOS governing board.[9][10]
The first CentOS release in May 2004, numbered as CentOS version 2, was forked from RHEL version 2.1AS.[1] Since the release of version 7.0, CentOS officially supports only the x86-64 architecture, while versions older than 7.0-1406 also support IA-32 with Physical Address Extension (PAE). As of December 2015, AltArch releases of CentOS 7 are available for the IA-32 architecture, Power architecture, and for the ARMv7hl and AArch64 variants of the ARM architecture.[11][12]

Para evitar todas las marranadas de Redhat es que instalé CentOs














My top ten reasons why RedHat sucks

  1. Shoddy workmanship. RPM was discovered to be broken in 2002; it would regularly corrupt its own databases and lock up in such a way that it couldn’t be killed. In spite of that, RedHat went and made two major releases with a broken RPM.
    1. Bad packaging. The RedHat 8 release of libgcj (the libraries for the GNU Java compiler) puts a broken version of jar into /usr/bin, destroying any working version you have installed. They’ve known about the problem since 2002, but left it broken into 2003. What the hell is a jar binary doing in a libraries package anyway?
    2. RPM. If you think RPM is a reasonable piece of software design, I can only assume you’ve never used Portage, APT or BSD ports. I still have to keep a “cheat sheet” of the bizarre invocations necessary to make RPM perform basic tasks. Then there’s the fact that you can’t just install an RPM; no, you need to find the right RPM for your specific version of RedHat, assuming one exists. And if that’s a pain for you, imagine what a pain it is for developers.
    3. Broken SMP. Not a big deal for home users, but RedHat target the enterprise. Yet threading is broken on SMP systems.
    4. Bad advocacy. Standing up and telling people that they should run Windows, not RedHat, is not just a dumb move from a marketing point of view—it also infuriates the very developers they rely on for the products they repackage and sell.
    5. Broken UTF-8. Try echo redhat sucks | grep [A-Z] and see. Works on every other Linux distribution, broken on RedHat. Furthermore, man pages show up as garbage in PuTTY because nroff’s VT102 sequences get hosed. It’s possible to fix it by turning off Unicode support, but is it too much to expect that RedHat get basic stuff like terminal I/O right?
    6. X dependencies. RedHat is for servers, right? Who needs X on a server? Well, you do, if you want to run RedHat’s emacs-nox package. Want to install without X? Tough luck, their “text mode” installation still uses it.
    7. Broken Perl. Perl has its own package management system called CPAN. It’s a hell of a lot more friendly, easy to use and helpful than RPM. I do not want to manage my Perl packages with RPM. However, even if I did, I’d be out of luck, because RedHat don’t provide a complete set of CPAN libraries in RPM format, and the ones they do provide aren’t kept up-to-date. End result: Before installing any Perl library I have to check to see if there’s an RPM version. If there is, I install it and then delete it manually and install it properly using CPAN.
    8. Painful upgrades. Want to upgrade from RedHat 8 to RedHat 9? Good luck, you’ll need it. Even upgrading from 7 to 8 is a “start from scratch” affair. Compare to upgrading debian or Gentoo and it’s clear that RedHat is designed for people who never upgrade. Which wouldn’t be a problem, except that RedHat don’t support old releases any more. If you’ve got an old RedHat system, you have to reinstall anyway, so do yourself a favor and install a different distribution.
    9. Unnecessary software. When I install RedHat, I always do my best to cut down the bloat to a bare minimum. Yet somehow, I always seem to end up with iptables and ipchains. Now, in what universe does it make sense for your installer to install both of those?



Blogger Widgets