El minorista OCUK ha abierto las reservas de los procesadores Core i9 7980XE, nuevo tope de gama de Intel que como sabemos está basado en la arquitectura Skylake-X y cuenta con un total de 18 núcleos y 36 hilos.
Ese alto conteo de núcleos ha obligado a Intel a utilizar una velocidad de trabajo de 2,6 GHz,
una cifra bastante baja si comparamos con los Core i7 7700K para
consumo general de cuatro núcleos y ocho hilos ya que funcionan a 4,2
GHz de frecuencia base, aunque gracias al modo turbo los Core i9 7980XE
pueden llegar a los 4,4 GHz reduciendo los núcleos activos.
El precio de los Core i9 7980XE es de 1.999 dólares, una cifra que en su llegada a Europa y tras la conversión a euros y la aplicación de impuestos podría acabar superando sin problema los 2.000 euros.
Tened en cuenta que aunque ya estén disponibles para precompra las primeras unidades no empezarán a llegar hasta el próximo 28 de agosto, así que todavía quedan unos días para que tengan disponibilidad real en el canal minorista.
Los procesadores Core X de intel se dividen en dos grandes grupos, Skylake-X y Kaby Lake-X.
Los primeros se comercializan en configuraciones que van desde los seis
núcleos y doce hilos hasta los 18 núcleos y 36 hilos, mientras que los
segundos sólo llegan a los cuatro núcleos físicos y ocho hilos en su
versión más potente.
Aunque ambos comparten la plataforma X299 y el socket LGA2066 también
presentan diferencias importantes en este sentido, puesto que los
primeros soportan memorias en cuádruple canal y hasta 44 líneas PCI, mientras que los segundos sólo soportan memorias en doble canal y 16 líneas PCIE.
Fuente: http://www.muycomputer.com/2017/08/24/reservas-del-core-i9-7980xe/
El gigante de Mountain View ha confirmado que Android Oreo será anunciado de forma oficial el próximo día 21 de agosto en un evento que celebrarán en la ciudad de Nueva York.
Se trata de un anuncio muy esperado y aunque Google no ha dicho de
forma directa que vaya a utilizar el nombre Android Oreo ha acabado por
confirmarlo de forma indirecta, ya que uno de los vídeos que subió a
Gooogle+ relacionados con este anuncio se titulaba “GoogleOreo_Teaser_0817_noDroids (1).mp4”.
Por otro lado también debemos tener en cuenta el detalle que se ha
marcado el conocido filtrador Evan Blass, quien ha lanzado un guiño a
Android Oreo y a su fecha de presentación (coincide con el día del próximo eclipse de Sol) con la imagen adjunta al tweet que acompañamos en el artículo.
Es importante tener en cuenta que poco después Google decidió cambiar el nombre del vídeo por “Octopus”,
que significa pulpo. Esto sugiere que cometieron un error y refuerza
las teorías que dan por confirmado el nombre de Oreo, pero hasta que la
firma de Mountain View lo comunique de forma oficial no hay nada seguro.
Los primeros terminales en recibir la actualización a Android O serán los de las series Nexus y Pixel.
En el caso de los primeros sólo mantienen el soporte los Nexus 5X y
Nexus 6P, que cerrarán con dicho sistema operativo el ciclo de
actualizaciones de dos años que ofrece Google.
El resto de terminales que podemos dar por seguro que actualizarán a
Android Oreo serán los tope de gama de los principales fabricantes
lanzados este año; como el Galaxy S8, el HTC U11, el Huawei P10 y el LG G6.
También deberían actualizar los tope de gama del año pasado (Galaxy S7, HTC 10, Huawei P9 y LG G5), pero es muy probable que no reciban Android O hasta el primer o segundo trimestre de 2018.
Not long after the announcement by Intel that they would be withdrawing
many of their embedded products, Sony have decided to enter the fray and
will be showcasing an Arduino-compatible development board at the Tokyo Maker Faire. The board specification promises a multi-core ARM processor and built-in GPS/GLONASS capability.
Sony
is normally associated with mass-produced electronic products such as
TVs and more recently, high-quality professional cameras. An
Arduino-sized development board bearing the name of Sony may at first
look a little out of place in the world of open-source products and
hacker-space projects that normally use boards bearing the names of
semiconductors Manufacturers - especially microcontrollers and SoC producers. Sony is, never the less also a semiconductor manufacturer and is particularly strong in camera sensor technology. The fact that Sony is also synonymous with SoCs, is also obvious from
the Spritzer board layout which mixes ARM technology with Ardunio
features.
The Spritzer board has the same dimensions and headers assignments as the classic Arduino Uno. It is equipped with its own ARM-SoC with six Cortex-M4F cores, which can be clocked at up to 156 MHz. There
are also 1.5 MB SRAM, 8 MB Flash, 6 analog inputs, 8-channel audio
processing and in addition to serial interfaces such as SPI, I2C, UART,
four PWM outputs and GPS / GLONASS for global position information. The
physical compatibility with the Arduino Uno makes it possible to use
normal Arduino shields and the Arduino IDE can be used for software
development. The board should be available at the start of 2018; the price has not yet been announced. Sony has a website (in Japanese) for the Spritzer and you can read a translation (courtesy of Google) here.
Para
cargar un nuevo firmware en un microcontrolador y luego depurarlo
usualmente se necesita una herramienta especial: el programador /
depurador en circuito. Los
microcontroladores PIC de Microchip no son una excepción a esto, y
hasta hoy la herramienta preferida para programar y depurar micros PIC
era el MPLAB ICD 3, el dispositivo en forma de disco que soportaba toda
la gama de dispositivos PIC y dsPIC. Ahora, después de muchos años de servicios leales, el MPLAB ICD 3 finalmente está siendo reemplazado por el MPLAB ICD 4. Al
igual que su predecesor, el nuevo depurador MPLAB en circuito (ICD) 4
es redondo y está alojado en un estuche durable negro con una tapa de
aluminio cepillado. El
estado se indica con una tira de LED colorida (la barra azul en la
foto) en lugar de los tres LEDs en el ICD 3. El ICD 4 incluye todas las
características de la CIE 3, pero es aproximadamente dos veces más
rápido. Este aumento de velocidad se debe a un MCU de 32 bits que funciona a 300 MHz ya una memoria intermedia de 2 MB. Otras
características nuevas son un rango de voltaje más amplio de 1,20 a 5,5
V y la posibilidad de conectar una fuente de alimentación externa para
alimentar la placa de destino a través de la CIE 4. Proporciona
resistencias de pull-up / pull-down seleccionables en el conector de
depuración Conectados a través de relés), la velocidad de interfaz es configurable; Ha mejorado la detección de fallos y la inmunidad y también funciona con interfaces JTAG. Una pregunta sigue siendo: ¿el CIE 4 también apoyará dispositivos AVR y ARM en el futuro?
Tutorial Arduino Consola y puerto serie. Interfaz creado con diversos lenguajes como C#, C++ CLR y VB .net
bajo Visual Studio Community que puedes controlar el puerto serie a Arduino encendiendo y apagando un
Led, manejar el LCD y recibes mensajes hacia el ordenador o PC.
En este apartado mostramos el código fuente en C#, en el PDF se encuentra C#, C++ CLR y VB .net.
Código C#:
using System;
using System.IO.Ports;
using System.Text;
namespace Arduino_Consola_cs
{
class Program
{
static void Main(string[] args)
{
// Título de la ventana.
Console.Title = "Arduino Consola C#";
// Establecer los tiempos de espera de lectura / escritura.
Puerto_serie.ReadTimeout = 500; // Milisegundos.
Puerto_serie.WriteTimeout = 500;
// Detecta cualquier dato recibido.
Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
Puerto_serie.Open(); // Abrir puerto.
ConsoleKey tecla;
Console.WriteLine("Pulse tecla 1 para encender y 2 para apagar:");
do
{
tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.
switch (tecla)
{
case ConsoleKey.D1: // Tecla 1 del teclado estandar.
case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
Console.WriteLine("Comando \"Luz_ON\" enviado."); // Muestra en pantalla comandos enviado.
break;
case ConsoleKey.D2:
case ConsoleKey.NumPad2:
byte[] miBuffer2 = Encoding.ASCII.GetBytes("Luz_OFF");
Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length);
Console.WriteLine("Comando \"Luz_OFF\" enviado.");
break;
default:
Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");
break;
}
} while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.
Console.WriteLine("Presione cualquier tecla para terminar...");
Console.WriteLine();
Console.ReadKey(); // Espera pulsar una tecla cualquiera.
Puerto_serie.Close(); // Cierra el puerto serie.
}
// Detecta cualquier dato entrante.
private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
{
SerialPort sp = (SerialPort)sender;
string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
Console.WriteLine("Dato recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
}
}
}
Código fuente en C# avanzado:
using System;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Speech.Recognition; // No olvidar. Micro.
using System.Speech.Synthesis; // No olvidar. Altavoz.
namespace Arduino_Consola_Color_Voz_cs
{
class Program
{
static void Main(string[] args)
{
string COM = "";
// Título de la ventana.
Console.Title = "Arduino Consola color y voz C#";
// Crear un nuevo objeto SerialPort con la configuración predeterminada.
Puerto_serie = new SerialPort();
// Configuración.
Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.
Puerto: ");
COM = Console.ReadLine(); // Escribir el número del puerto.
Console.Clear();
Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.
Puerto_serie.BaudRate = 115200; // Baudios.
Puerto_serie.Parity = Parity.None; // Paridad.
Puerto_serie.DataBits = 8; // Bits de datos.
Puerto_serie.StopBits = StopBits.Two; // Bits de parada.
Puerto_serie.Handshake = Handshake.None; // Control de flujo.
// Establecer la lectura / escritura de los tiempos de espera.
Puerto_serie.ReadTimeout = 500;
Puerto_serie.WriteTimeout = 500;
try
{
Puerto_serie.Open(); // Abrir el puerto serie.
}
catch (IOException)
{
Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
Console.CursorVisible = false;
Console.SetCursorPosition(16, 6);
Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
o no lo encuentra.");
Console.ReadKey(); // Pulse cualquier tecla.
Environment.Exit(1); // Salir de la aplicación.
}
// Detecta cualquier dato recibido.
Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
ConsoleKey tecla;
Console.WriteLine("Pulse tecla 1 para encender, 2 para apagar y \n" +
"Escape para salir. \n" +
"--------------------------------------------------------------\n");
do
{
tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.
// Inicializar una nueva instancia de SpeechSynthesizer.
using (SpeechSynthesizer altavoz = new SpeechSynthesizer())
{
// Configure la salida de audio.
altavoz.SetOutputToDefaultAudioDevice();
// Velocidad de la voz.
altavoz.Rate = -2; // Valores entre -10 a 10.
// Volumen de la voz.
altavoz.Volume = 100; // Valores entre 0 y 100.
switch (tecla)
{
case ConsoleKey.D1: // Tecla 1 del teclado estandar.
case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write("Comando"); // Muestra en pantalla comandos enviado.
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(" \"Luz_ON\" ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("enviado.");
Console.ForegroundColor = ConsoleColor.Gray;
altavoz.Speak("Luz encendida.");
break;
case ConsoleKey.Escape:
Console.WriteLine("Saliendo...");
altavoz.Speak("Saliendo.");
break;
default:
Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");
break;
}
}
} while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine();
Console.WriteLine("╔═════════════════════════════════════════════════════╗");
Console.WriteLine("║ Electrónica PIC metaconta@gmail.com ║");
Console.WriteLine("║ ║");
Console.WriteLine("║ Ángel Acaymo M. G. ║");
Console.WriteLine("╚═════════════════════════════════════════════════════╝");
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Pulse cualquier tecla para salir...");
Console.WriteLine();
Console.ReadKey(); // Espera pulsar una tecla cualquiera.
Puerto_serie.Close(); // Cierra el puerto serie.
}
// Detecta cualquier dato entrante.
private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
{
SerialPort sp = (SerialPort)sender;
string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write("Dato recibido desde Arduino: "); // Muestra en pantalla los datos recibidos.
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(entradaDatos + "\n");
Console.ForegroundColor = ConsoleColor.Gray;
}
// ----- Electrónica PIC -----
//
// Ejercicio 2.
//
// Encendido y apagado del Led 13 mediante puerto serie con pantalla.
// Es lo mismo que el Ejercicoi 1, pero usando el LCD Keypad Shield.
// Pin 10 para saber que es luz de fondo. const byte LuzFondo = 10;
const byte Led = 13; // Declaramos la variable pin del Led. char caracter; String comando;
void setup() { pinMode(Led, OUTPUT); // Inicializa el pin del LED como salida: Serial.begin(115200); // Puerto serie 115200 baudios. lcd.begin(16, 2); // Formato de pantalla. lcd.clear(); // Borra la pantalla y su posición superior izquierda. lcd.print(" Arduino "); delay(1000); }
void loop() { /* Voy leyendo carácter a carácter lo que se recibe por el canal serie (mientras llegue algún dato allí), y los voy concatenando uno tras otro en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while acabará cuando pulsamos Enter. El delay es conveniente para no saturar el canal serie y que la concatenación se haga de forma ordenada. */ while (Serial.available() > 0) { caracter = Serial.read(); comando.concat(caracter); delay(10); }
/* Una vez ya tengo la cadena "acabada", compruebo su valor y hago que la placa Arduino reacciones según sea este. Aquí podríamos hacer lo que quisiéramos: si el comando es "tal", enciende un Led, si es cual, mueve un motor... y así. */
// Si los carácteres es recibido y verdadero. if (comando.equals("Luz_ON") == true) { digitalWrite(Led, HIGH); // Enciende el Led 13. Serial.write("ON - Led encendido."); // Envía este mensaje al PC. lcd.setCursor(0, 1); lcd.print("Luz ON. "); // Mostrar en el LCD. }
if (comando.equals("Luz_OFF") == true) { digitalWrite(Led, LOW); // Apaga el Led 13. Serial.write("OFF - Led apagado. "); // Envía este mensaje al PC. lcd.setCursor(0, 1); lcd.print("Luz OFF. "); // Mostrar en el LCD. }
// Limpiamos la cadena para volver a recibir el siguiente comando. comando = ""; }
Es un hecho que Nintendo asume riesgos,
basta echar un vistazo a todas las generaciones de consolas que ha
lanzado la compañía nipona desde la Nintendo 64 (ésta incluida) hasta la actual Nintendo Switch. La propia NVIDIA
ha destacado esa cualidad de la firma japonesa, pero también ha
indicado que Nintendo es una compañía a la que le gusta trabajar de
forma independiente. Por ello Nintendo asume riesgos y además no se deja influir por otros, no se limita a seguir los estándares del mercado sino que se esfuerza por crear otros nuevos.
Un ejemplo claro lo vimos precisamente en Nintendo 64. La veterana consola introdujo el stick analógico en el mando de control y daba la opción de disfrutar de respuesta háptica
(vibración), un movimiento que luego fue copiado hasta la saciedad por
Sony (primer DualShock para PS1), SEGA (mando de Dreamcast) y Microsoft
(primera Xbox).
Con GameCube, Wii y Wii U volvieron a demostrar que iban “por libre” aunque sólo tuvieron un gran éxito con la segunda, gracias a la idea de los sensores de movimiento y a los juegos sociales que lanzaron centrados en dicho sistema de control.
Durante su última conferencia de resultados Jen-Hsun Huang alabó el
buen hacer de Nintendo con su última consola, la Switch, y dio a
entender claramente que la innovación y los riesgos han vuelto a dar sus frutos, una referencia que podemos entender perfectamente al ver el enorme éxito que ha tenido la nueva consola de la gran N.
Es evidente que el hecho de que Nintendo Switch monte un SoC Tegra X1
ha “motivado” al CEO de NVIDIA a hablar de dicha consola, pero siendo
justos hay que reconocer que la gran N asumió un gran desafío con dicha
consola y que al final todo le ha salido de maravilla.
Android O
(Android 8.0), la versión final de la nueva edición del sistema
operativo que monopoliza el mercado del móvil inteligente, estaría
disponible el 21 de agosto según el prolífico filtrador Evan Blass.
Android O debutará en los dispositivos propios de Google, los Pixel,
Pixel XL, Nexus 5X, Nexus 6P, Nexus Player y Google Pixel C. Su llegada
al resto de móviles Android dependerá de cada uno de los fabricantes. Y
-con honrosas excepciones- no tendrán prisa y con ello aumentará la fragmentación de la plataforma y las acusaciones de obsolescencia tecnológica programada para vender nuevos modelos y seguir la cadena.
A falta de conocer el nombre del dulce, pastel o galleta con el que
Google renombrará este Android O como ha venido sucediendo en versiones
anteriores, la importancia de cada versión del sistema es notable,
teniendo en cuenta que solo en 2017 serán comercializados cerca de 1.500 millones de nuevos terminales con Android.
Novedades Android O
Haremos el correspondiente análisis en su momento pero ve quedándote con algunas de las novedades. Entre otras:
Límite automático de apps en segundo plano.
Continuando el trabajo iniciado en Nougat, Android O pondrá una gran
prioridad en mejorar la vida de la batería y el rendimiento interactivo
del dispositivo. Limitar el impacto de las aplicaciones que funcionan en
segundo plano apunta a ello.
Canales de Notificaciones. Además de mejorar el
sistema de notificaciones, poder posponer las mismas e incluir nuevos
efectos visuales y de sonido, Google implementará los canales de
notificaciones, nuevas categorías definidas por su contenido, que
ofrecerán un mayor control del usuario para recibir, bloquear o
administrar categorías completas de avisos. O distintas notificaciones
dentro de la misma app.
Picture in Picture. Android O ofrecerá una mayor
capacidad de multitarea (un aspecto solo “arañado” en Nougat)
implementando de forma nativa la función Picture in Picture en móviles y
tablets, que nos permitiría -por ejemplo- ver un vídeo de YouTube en
una ventana flotante encima de otra aplicación.
Iconos adaptativos. Los desarrolladores podrá crear iconos de distintas formas para cada interfaz de usuario.
Navegación con teclado. Google mejorará el soporte y
funcionamiento del sistema con este periférico. El motivo es claro,
mejorar el funcionamiento una vez que las apps Android se han integrado
en Chrome OS.
Conectividad. Para lograr la máxima fidelidad de
audio, Android O añadirá compatibilidad con códecs Bluetooth de audio de
alta calidad, como el códec LDAC.
WebView. Android O permite el modo multiproceso de
forma predeterminada con una API para que una aplicación pueda controlar
errores, ganando seguridad y una mayor estabilidad en la ejecución.
Java 8. La nueva versión incluye soporte para las
nuevos APIs Lenguaje Java, incluyendo la nueva API java.time. Google
promete que el tiempo de ejecución será más rápido que nunca, con
mejoras de hasta 2 veces en algunos puntos de referencia.
Pruebas Android O
Si no quieres esperar al lanzamiento de la versión final, Google publicó un SDK actualizado con imágenes del sistema que ha ido actualizando con diferentes versiones de prueba. Las imágenes y las instrucciones de instalación están disponibles en la página para desarrolladores Android.
Sólo se recomiendan para testeo y no para producción. Si estás
desarrollando para la plataforma de wearables de Google, también está
disponible un emulador para pruebas Android Wear 2.0 en Android O.
