CORTEXRis in the Big Data Analytics Industry

CORTEXR

Radio-frequency identification and near-field communication are two similar technologies used in many industries. Their fields of application include inventory tracking, location tracking, access control, contactless payments, logistics, manufacturing, marketing, retail, and more. In this article, we are going to talk about these systems from an electronics design perspective. We will also take a look at RFID and NFC device development cases. How do RFID and NFC Technologies Work? is a wireless communication technology that uses radio waves to uniquely identify tagged items. A radio-frequency identification system generally consists of three elements: a reader, a tag, and RFID software. The RFID tag carries unique ID information and other data associated with the item it is placed on. When activated, the reader sends radio waves. The waves power any tags within the interrogation zone. They send back the data to the reader. The software processes the raw data for the end user. Radio-frequency identification (RFID) Radio-frequency identification allows you to track and identify unique items and people. For this reason, RFID technology is used in many spheres: asset and location tracking, inventory management, access control, theft prevention, etc. is a short-range wireless communication technology that uses high-frequency radio waves to uniquely identify tagged items and exchange data with other NFC-enabled devices. While RFID uses a broad range of radio frequencies, NFC devices work at 13.56 MHz only. This technology evolved from RFID and can be regarded as its fine-tuned subset. Near field communication (NFC) NFC technology is commonly used in contactless payment terminals in retail stores. NFC systems consist of the same elements as RFID: a reader (called initiator), a tag (called target), and NFC software. They work the same way as RFID systems. However, they have a much shorter operating range (up to several centimeters). That is why near field communication is primarily used in contactless payment. Nevertheless, other applications similar to that of RFID systems are also possible. Unlike RFID, NFC devices are capable of two-way communication. So, they are also used where data exchange is required. These technologies are very similar, but suit different business tasks. NFC systems can work in . active or passive modes of communication , one active device (Initiator) generates a radio-frequency field. The passive device (Target) draws power from the alternating magnetic field and acts as a transponder. It uses load modulation for data transferring. In passive mode , both the Initiator and the Target are active and generate magnetic fields in turns. The field deactivates while the device is waiting for data and activates when the device is ready to respond. In active mode An active NFC device can work in any of these operating modes: The device acts as a contactless smart card. The radio-frequency field is generated by the reader. Typical application: smartphone as an instrument of payment. The device acts as a reader for NFC and RFID tags. When the tag is close enough, the device detects it with a collision avoidance mechanism. Then it can read the data from the tag or write new information to it. Typical application: smart posters. Both devices act as a reader and a tag to alternately transmit and receive data. It allows them to exchange information such as pictures, business cards, etc. Android Beam technology uses this mode. Card emulation mode. Reader/writer mode. Peer-to-peer mode. Here are the key differences between RFID and NFC systems. You can learn more about these and other differences and the applications of RFID and NFC systems in our previous article. RFID and NFC Tags RFID Tags RFID and NFC tags consist of three elements: a substrate, an antenna, and a microchip. Tags come in various shapes and sizes: plastic cards, key fobs, paper or plastic stickers, badges, etc. The microchip is responsible for the signal modulation and demodulation. It also stores and processes information. There are three types of RFID tags: tags do not have a power source. In order to function, they use the energy from the reader’s radio signal. tags have their own power source (usually a small battery). It allows them to transmit signals periodically. The battery boosts the signal. Active tags can be read from longer distances. (battery-assisted passive) tags also use batteries but do not transmit periodic signals. When the tag receives the signal from the reader, the battery only turns on the tag. So, all the energy from the reader’s signal is reflected back. They also have a longer range than passive tags. Passive Active Semi-passive RFID systems can operate at different frequencies. They commonly use the following radio frequency bands. Note that the bands are defined by national standards and regulations. , particularly 120-140 kHz. In ideal conditions, these radio waves can travel up to 50 cm. But in practice, their range does not exceed 10-20 cm. LF RFID tags do not have security standards. So, they are not recommended for applications requiring encrypted communication. They can also penetrate through metals and liquids. , particularly 13.56 MHz. The read range of these systems usually varies from 10 to 20 cm but can reach about 1 m. HF RFID tags cannot penetrate through liquids and dense metals but work fine with most other materials including thin metals. tags operate at frequencies of 865–868 MHz (Europe) and 902–928 MHz (North America). Their reading range usually does not exceed 12 m. Note that some UHF RFID systems use 433 MHz and can reach up to 100 m. Low frequency band High frequency band Ultra-high frequency Some RFID tags operate at 2.45-5.8 GHz, 3.1-10 GHz, and 24.125 GHz. However, frequency bands higher than 928 MHz are not common for commercial RFID tags. Most civil-grade systems use LF, HF, and UHF tags. NFC Tags Near field communication utilizes the same frequency as HF RFID tags – 13.56 MHz. NFC-Forum defines the following types of NFC tags. Note that custom RFID and NFC systems usually do not require custom tags. However, one may require to design a non-standard device with a reader, which includes custom PCB design and embedded software development. RFID and NFC Readers NFC devices can work as readers and tags. RFID readers can only scan tags. Readers consist of an oscillator, transceiver, receiver, control unit (processor), and an external antenna. They come in three form factors: - Mobile (handheld) readers that often have the shape of a pistol; - Fixed readers that can be attached to walls or near doors; - Vehicle-mounted readers that are often integrated into material handling devices. The reading range of RFID and NFC readers depends on their transmitting power. This, in turn, is defined by the type of antenna, the operating frequencies, and the power source. Environmental conditions and local regulations can cap the reader’s maximum range as well. Many RFID-enabled devices have an integrated NFC module, which enables them to read both RFID and NFC tags. They can also have a few additional modules: a 1D/2D scanner, a camera, GPS, or a cellular connection (in case Wi-Fi is unavailable). RFID readers can be either active or passive. Depending the type of readers and tags, RFID systems can be classified as follows: - (Passive Reader Active Tag) systems. The reader has no power source and can only receive data from active tags. PRAT - (Active Reader Passive Tag) systems. The reader sends interrogation signals to passive tags and powers them. ARPT - (Active Reader Active Tag) systems. Both elements have power sources. Semi-passive tags can also be used here. ARAT Unlike NFC devices, RFID readers can scan multiple tags simultaneously with one of these anti-collision algorithms: either probabilistic or deterministic detection. To transmit the data from the reader to a host computer, several network connection types can be used. Fixed readers usually utilize USB, serial interface, Ethernet, Wi-Fi, and POE. Mobile models usually use Wi-Fi, Bluetooth, and USB. These network connections can also be used to charge the device. Custom RFID and NFC Device Development Usually, one has a number of options here. If it is possible to create the system with off-the-shelf (OTS) readers and tags, then all you need is to develop software. In some cases, one can even purchase OTS software packages for RFID and NFC systems. However, there are relatively few of them. Due to complicated or specific tasks, businesses may also require custom-design readers and, thus, custom NFC or RFID hardware development. Non-standard applications and requirements will probably need a research and development stage. As for tags, engineers usually use OTS models even for custom solutions. Manufacturers offer so many models that there is no need to reinvent the wheel. Designing a printed circuit board for an RFID or NFC-enabled device starts with choosing a suitable reader. The choice is defined by various factors: the required read range, frequency band, environmental conditions, etc. The PCB will also require a microcontroller or a microprocessor, as well as various passive components. Another obligatory component is the antenna, but it is placed outside the board. Depending on what additional functions the device must perform, the team may need to mount additional modules and components. Custom NFC and RFID device development also involves software design. Such systems typically require three types of software. 1. that manages the work of the hardware. Tags come with firmware developed by the manufacturer and don’t require any changes. But designing a custom reader also includes RFID or NFC firmware development. Simpler solutions can be written in C, while more complex devices will most likely be written in C++. Firmware 2. , i.e. the highest-level software that manages the processed data, collected with the reader, to address particular business needs. Application 3. , i.e. the software between the firmware and the high-level application. As a rule, NFC systems do not require middleware, unless an NFC-enabled device serves as an intermediate link between the tag and an enterprise information system, which is uncommon. Middleware is more common for RFID systems. connects the readers and the data they collect with the application or enterprise information system. It processes the raw data coming from the readers before passing it on as aggregated data. It also provides an application-level interface for managing readers and querying data. Middleware Middleware The middleware and the application level software can be written in C++, C#, Python, Java, and other languages. The choice is defined by the system’s size, the complexity of its tasks, and hardware requirements. When there’s a need for cross-platform solutions, Qt development is a better option. The most important requirements for the language for middleware is the ability to reach the hardware on the one hand and to interact with the high-level software on the other hand. The following cases demonstrate two projects from our portfolio that involved custom RFID and NFC device development. Case #1: Custom RFID Device Development Our customer wanted to develop an RFID system for livestock enterprises to identify animals, track their movements, and collect other data for timely disease diagnostics. Our job was to design a handheld RFID data terminal for this system. Our RFID device development resulted in a data terminal operating at 860-960 MHz with multiple modules. The terminal can read multiple tags simultaneously from a distance of several meters. For this project, our team developed a custom single-board computer  based on the STM32MP151AAD3 microprocessor with one Arm® Cortex®-A7 core for high-level operations and one Cortex®-M4 core for low-level operations. This microprocessor features a low price and allows us to curb the number of components to make the device smaller but more energy efficient. Pared with the microprocessor, the device also uses energy-saving 1GB MT41K512M16HA-125A SDRAM-DDR3L memory and 4GB EMMC04G-MK27-A01C FLASH-NAND (MLC) memory with eMMC interface. The RFID reading function is implemented with the ST25RU3980 single chip reader. It’s a highly-integrated solution compatible with ISO 18000-6C/EPC Class1 Gen2 transponders. The reader is battery-powered and features very low power consumption. Pared with a custom patch antenna, it provides a very high sensitivity and resistance to reflection and self-clutter effects. The ESP32-C3-MINI-1-N4 module with an integrated PCB antenna is responsible for the WiFi 802.11b/g/n and Bluetooth v5.0 interfaces. They allow the device to connect to local data networks. The Telit ME310G1W103T040100 module is responsible for cellular connection and data transmission in the field. The device is also equipped with a Newland EM2096 module for scanning 1D and 2D barcodes. The team used a USB Type C Amphenol 124019322112A connector for data transmission over USB 2.0 and battery charging. It has IPX4 level of protection, which makes it suitable for outdoor applications. The terminal is also equipped with an MC6470 inertial measurement unit. It allows businesses to track the location of the device, which can be important for keeping record of its work. The device is powered with a 3.7V 12Ah single-cell Li-ion battery, which should be enough for a 12-hour shift. The scope of work also included firmware and software development. For the microprocessor, the team used the Android distribution package provided by the manufacturer. We developed the firmware in C for the ESP32-C3-MINI-1-N4 module with programming libraries. It is controlled by the microprocessor with the help of AT commands. We also wrote a custom driver in C for the RFID reader, as it uses an SPI interface. Other modules use standard drivers. Case #2: Custom NFC Device Development This case demonstrates how NFC technology can be adapted for non-standard use. The project involved both custom NFC hardware and software development. Our job was to design an NFC-enabled device for orienteering events and location-based games. With the device we created, event participants can scan NFC tags placed on control points. The reader then transmits the data to a host computer used by the administration to let them know which team reached the point. The device can also perform a number of other tasks. The device is based on an NXP PN7362BNHN microcontroller. It has an integrated radio interface with NFC support and low energy consumption for autonomous work. The microcontroller has all the necessary NFC components inside. The team only had to add impedance-matching circuits. It also has enough memory capacity (160 KB) for complex algorithms. As the microcontroller has an integrated radio interface, it is also responsible for reading NFC tags. The microcontroller is paired with a passive, small-size flexible antenna – Pulse/Larsen W7001. The system supports all protocols and modes defined by NFC-Forum. It features high sensitivity and stability. Its read range equals 40 mm. Data transmission in field conditions is implemented with a Quectel MC60ECB-04-BLE module. It has an integrated navigation receiver (GPS/GLONASS/Galileo/BeiDou/QZSS) and supports 2G cellular communication. The module supports navigation, based on GSM signals, and multiple data transmission protocols (TCP/UDP/FTP/PPP/HTTP/NITZ/NTP/PING/HTTPS/TCP/SSL/MQTT). It allows the device to send data to the administration as well as receive various messages: confirmations, warnings, hints, statistics, etc. The information is displayed on a monochrome graphic display (Orient Display JAZZ-BC-W). The device is equipped with an emergency button. When it is pressed, the device sends an emergency signal to the host computer along with location data. The device’s location is tracked with an MC6470 inertial measurement unit. The device is powered by a built-in single-cell 3.7V 1.2Ah Li-ion battery. It can work over 8 hours on a single charge. Using the energy-saving mode of the microcontroller can extend this period. The device is fitted with a USB Type C Amphenol 124019322112A connector, so it is well protected against moisture and dust. The software development team wrote firmware for the microcontroller in C using an AT command library to control the 2G module. Conclusion In most cases, one can use off-the-shelf RFID and NFC systems. Different types of readers and tags suit different purposes. Technical characteristics of the devices, such as operating frequency, power source, or memory capacity, define the system’s read range, penetration capability, etc. With off-the-shelf elements, it is only a matter of software design. But sometimes, complicated or non-standard tasks can require a custom solution. RFID and NFC device development involves designing a custom PCB, as well as embedded firmware and software development. Depending on what tasks the system must perform, the team can also install additional components, so that the device could work in field conditions, or scan 1D/2D codes, and so on. This story was first published here.

Custom RFID and NFC Device Development: Theory and Practice

The aim of this is to read air quality sensor data and show it on an LCD display that is connected to STM32 board. A web browser will read the sensor data and pass it to STM32 board using BleuIO. Bluetooth LE project Introduction The project is based on which controls using BleuIO. STM32 Nucleo-144, LCD display We will need for this project, one connected to the Nucleo board and the other to a computer running the web script and a . When the BleuIO Dongle is connected to the Nucleo board’s USB port, the STM32 will recognize it and directly start advertising. This allows the Dongle on the computer port to connect with the web script. two BleuIO USB dongles HibouAir – Air quality monitoring device With the web script on the computer, we can scan and get air quality sensor data from HibouAir. Then we send these data to an LCD screen connected to STM32 using Bluetooth. We have used a STM32 Nucleo-144 development board with STM32H743ZI MCU (STM32H743ZI micro mbed-Enabled Development Nucleo-144 series ARM® Cortex®-M7 MCU 32-Bit Embedded Evaluation Board) for this example. This development board has a USB host where we connect the BleuIO dongle. If you want to use another setup, you will have to make sure it supports a USB Host and beware that the GPIO setup might be different and may need to be reconfigured in the .ioc file. About the Code The project source code is available at . Github Either clone the project or download it as a zip file and unzip it into your STM32CubeIDE workspace. If you download the project as a zip file, you will need to rename the project folder from ‘stm32_bleuio_lcd-master’ to ‘stm32_bleuio_lcd’. Connect the SDA to PF0 on the Nucleo board and SCL to PF1. Then setup I2C2 in the STM32Cube ioc file as follows. (Make sure to change the I2C speed frequency to 50 kHz as per LCD display requirements.) In the USBH_CDC_ReceiveCallback function in USB_HOST\usb_host.c, we copy the CDC_RX_Buffer into an external variable called dongle_response that is accessible from the main.c file. void USBH_CDC_ReceiveCallback(USBH_HandleTypeDef *phost)
{
  	if(phost == &hUsbHostFS)
  	{
  		// Handles the data recived from the USB CDC host, here just printing it out to UART
  		rx_size = USBH_CDC_GetLastReceivedDataSize(phost);
		HAL_UART_Transmit(&huart3, CDC_RX_Buffer, rx_size, HAL_MAX_DELAY);

		// Copy buffer to external dongle_response buffer
		strcpy((char *)dongle_response, (char *)CDC_RX_Buffer);

		// Reset buffer and restart the callback function to receive more data
		memset(CDC_RX_Buffer,0,RX_BUFF_SIZE);
		USBH_CDC_Receive(phost, CDC_RX_Buffer, RX_BUFF_SIZE);
  	}

  	return;
} In main.c we create a simple interpreter so we can react to the data we are receiving from the dongle. void dongle_interpreter(uint8_t * input)
{

	if(strlen((char *)input) != 0)
	{
		if(strstr((char *)input, "\r\nADVERTISING...") != NULL)
		{
			isAdvertising = true;
		}
		if(strstr((char *)input, "\r\nADVERTISING STOPPED") != NULL)
		{
			isAdvertising = false;
		}
		if(strstr((char *)input, "\r\nCONNECTED") != NULL)
		{
			isConnected = true;
			HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_SET);
		}
		if(strstr((char *)input, "\r\nDISCONNECTED") != NULL)
		{
			isConnected = false;
			HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_RESET);
		}


		if(strstr((char *)input, "L=0") != NULL)
		{

			isLightBulbOn = false;
			//HAL_GPIO_WritePin(Lightbulb_GPIO_Port, Lightbulb_Pin, GPIO_PIN_RESET);
			lcd_clear();

			writeToDongle((uint8_t*)DONGLE_SEND_LIGHT_OFF);

			uart_buf_len = sprintf(uart_tx_buf, "\r\nClear screen\r\n");
			HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
		}

		if(strstr((char *)input, "L=1") != NULL)
		{
				isLightBulbOn = true;
				writeToDongle((uint8_t*)DONGLE_SEND_LIGHT_ON);


				lcd_clear();

				lcd_write(input);

		}

	}
	memset(&dongle_response, 0, RSP_SIZE);
} We put the interpreter function inside the main loop. /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
    MX_USB_HOST_Process();

    /* USER CODE BEGIN 3 */
    // Simple handler for uart input
    handleUartInput(uartStatus);

    // Inteprets the dongle data
    dongle_interpreter(dongle_response);

	// Starts advertising as soon as the Dongle is ready.
	if(!isAdvertising && !isConnected && isBleuIOReady)
	{
		HAL_Delay(200);
		writeToDongle((uint8_t*)DONGLE_CMD_AT_ADVSTART);
		isAdvertising = true;
	}
  }
  /* USER CODE END 3 */ Using the example project What we will need Two BleuIO dongles A board with a STM32 Microcontroller with a USB port. (A Nucleo-144 development board: NUCLEO-H743ZI2, was used to develop this example. To connect the dongle to the Nucleo board, a “USB A to Micro USB B”-cable with a USB A female-to-female adapter can be used.) STM32CubeIDE Liquid Crystal Display Module – NHD-0420D3Z-NSW-BBW-V3 – Air quality monitoring device HibouAir Importing as an Existing Project From STM32CubeIDE choose File>Import… Then choose General>Existing Projects into Workspace, then click ‘Next >’ Make sure you’ve chosen your workspace in ‘Select root directory:’ You should see the project “stm32_bleuio_SHT85_example”, check it, and click ‘Finish’. Running the example Upload the code to STM32 and run the example. The USB dongle connected to STM32 will start advertising automatically. Send Sensor Data to LCD screen from a web browser Connect the BleuIO dongle to the computer. Run the web script to connect to the other BleuIO dongle on the STM32. Now you can send sensor data to the LCD screen. For this script to work, we need connected to the computer. BleuIO USB dongle BleuIO javascript library Chrome 78 or later, and you need to enable the flag in #enable-experimental-web-platform-features chrome://flags A web bundler Create a simple Html file called index.html which will serve as the frontend of the script. This Html file contains some buttons that help connect, read advertised data from the HibouAir to get air quality sensor data and send this data to the LCD screen, which is connected to stm32. <!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
      integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3"
      crossorigin="anonymous"
    />
    <title>Bluetooth LE Air quality sensor data to LCD screen</title>
  </head>
  <body class="mt-5">
    <div class="container mt-5">
      <img
        src="https://www.bleuio.com/blog/wp-content/themes/bleuio/images/logo.png"
      />
      <h1 class="mb-5">Bluetooth LE Air quality sensor data to LCD screen</h1>

      <div class="row">
        <div class="col-md-4 pt-5">
          <button class="btn btn-success mb-2" id="connect">Connect</button>
          <form method="post" id="sendDataForm" name="sendMsgForm" hidden>
            <div class="mb-3">
              <label for="sensorID" class="form-label">Sensor ID</label>
              <input
                type="text"
                class="form-control"
                name="sensorID"
                id="sensorID"
                required
                maxlength="60"
                value="0578E0"
              />
            </div>

            <button type="submit" class="btn btn-primary">Get Data</button>
          </form>
          <br />
          <button class="btn btn-danger" id="clearScreen" disabled>
            Clear screen
          </button>
        </div>
        <div class="col-md-8">
          <img src="air_quality_lcd.jpg" class="img-fluid" />
        </div>
      </div>
    </div>

    <script src="script.js"></script>
  </body>
</html> Create a js file called script.js and include it at the bottom of the Html file. This js file uses the BleuIO js library to write AT commands and communicate with the other dongle. import * as my_dongle from 'bleuio'
import 'regenerator-runtime/runtime'

const dongleToConnect='[0]40:48:FD:E5:2F:17'
//const sensorID = '0578E0'
document.getElementById('connect').addEventListener('click', function(){
  my_dongle.at_connect()
  document.getElementById("clearScreen").disabled=false;
  document.getElementById("connect").disabled=true;
  document.getElementById("sendDataForm").hidden=false;
})

document.getElementById("sendDataForm").addEventListener("submit", function(event){
    event.preventDefault()
    const sensorID = document.getElementById('sensorID').value
    getSensorData(sensorID)
    setInterval(function () {getSensorData(sensorID)}, 10000);

   
  });

  const getSensorData =((sensorID)=>{
    my_dongle.ati().then((data)=>{
        //make central if not
        if(JSON.stringify(data).includes("Peripheral")){
            console.log('peripheral')
            my_dongle.at_dual().then((x)=>{
                console.log('central now')
            })
        }        
    })
    .then(()=>{
        // connect to dongle
        my_dongle.at_getconn().then((y)=>{
            if(JSON.stringify(y).includes(dongleToConnect)){
                console.log('already connected')
            }else{
                my_dongle.at_gapconnect(dongleToConnect).then(()=>{
                    console.log('connected successfully')
                })
            }
        })
        .then(async()=>{
           return my_dongle.at_findscandata(sensorID,6).then((sd)=>{
                console.log('scandata',sd)
                let advData = sd[sd.length - 1].split(" ").pop()
                let positionOfID= advData.indexOf(sensorID);
                let tempHex = advData.substring(positionOfID+14, positionOfID+18)
                let temp = parseInt('0x'+tempHex.match(/../g).reverse().join(''))/10;

                let co2Hex = advData.substring(positionOfID+38, positionOfID+42)
                let co2 = parseInt('0x'+co2Hex);
                //console.log(temp,co2)
                return {
                    'CO2' :co2,
                    'Temp' :temp,                       
                  }
            })
        })
        .then((x)=>{
            console.log(x.CO2)
            console.log(x.Temp)
            var theVal = "L=1 SENSOR ID "+sensorID+"    TEMPERATURE " + x.Temp + ' °c    CO2 '+ x.CO2+' ppm';
            console.log('Message Send 1 ')
            // send command to show data
            my_dongle.at_spssend(theVal).then(()=>{
                console.log('Message Send '+theVal)
            })
        })
        
    })
})

document.getElementById('clearScreen').addEventListener('click', function(){
    my_dongle.ati().then((data)=>{
        //make central if not
        if(JSON.stringify(data).includes("Peripheral")){
            console.log('peripheral')
            my_dongle.at_central().then((x)=>{
                console.log('central now')
            })
        }
    })
    .then(()=>{
        // connect to dongle
        my_dongle.at_getconn().then((y)=>{
            if(JSON.stringify(y).includes(dongleToConnect)){
                console.log('already connected')
            }else{
                my_dongle.at_gapconnect(dongleToConnect).then(()=>{
                    console.log('connected successfully')
                })
            }
        })
        .then(()=>{
            // send command to clear the screen
            my_dongle.at_spssend('L=0').then(()=>{
                console.log('Screen Cleared')
            })
        })
        
    })
}) The script has a button to connect to the COM port on the computer. There is a text field where you can write the sensor ID of the air quality monitor device. Once connected, the script will try to get advertised data from the sensor and convert it to meaningful data. After that, it will send this data to the STM32 board, which is then displayed on the LCD screen. To connect to the BleuIO dongle on the STM32, make sure the STM32 is powered up, and a BleuIO dongle is connected to it. Get the MAC address Follow the steps to get the MAC address of the dongle that is connected to STM32. - Open this site https://bleuio.com/web_terminal.html and click connect to dongle.
- Select the appropriate port to connect.
- Once it says connected, type ATI. This will show dongle information and current status.
- If the dongle is on peripheral role, set it to central by typing AT+CENTRAL
- Now do a gap scan by typing AT+GAPSCAN
- Once you see your dongle on the list ,stop the scan by pressing control+c
- Copy the ID and paste it into the script (script.js) line #4 Run the web script You will need a web bundler. You can use parcel.js Once parcel js is installed, go to the root directory of the web script and type . This will start your development environment. “parcel index.html” Open the script on a browser. For this example, we opened http://localhost:1234. You can easily connect to the dongle and see air quality data on the LCD screen. The response will show on the browser console screen. The web script looks like this: Output The message will show on the LCD screen. Also published here.

Show Bluetooth LE Sensor Readings on LCD Screen Connected to STM32 

Home automation involves automating household environment equipment. To achieve that, we have created a smart bulb that is easy to install, and the attached equipment can be controlled over a web browser or smartphone app. The aim of this project is to control different home appliances using a web browser or smartphone. 1. Introduction The project is showcasing a simple way of using the the BleuIO Dongle to turn on and off a light bulb that is connected to the STM32 Nucleo-144 via a 5V Relay. You will need two dongles, one connected to the Nucleo board and one connected to a computer, running the web script. When the BleuIO Dongle is connected to the Nucleo boards USB port the STM32 will recognize it and directly start advertising. This allows the other Dongle to connect to it. It will also accept 3 different inputs from the UART: 0	Send ATI (Request device information) command to BlueIO Dongle.
1	Manually turn the light bulb on
2	Manually turn the light bulb off input	result We have used a STM32 Nucleo-144 development board with STM32H743ZI MCU (STM32H743ZI micro mbed-Enabled Development Nucleo-144 series ARM® Cortex®-M7 MCU 32-Bit Embedded Evaluation Board) for this example. If you want to use another setup you will have to make sure it support USB Host and beware that the GPIO setup might be different and may need to be reconfigured in the .ioc file. WARNING – THIS PROJECT INVOLVES HIGH VOLTAGES THAT CAN CAUSE SERIOUS INJURY OR DEATH. PLEASE TAKE ALL NECESSARY PRECAUTIONS, AND TURN OFF ALL POWER TO A CIRCUIT BEFORE WORKING ON IT. What you will need Two BleuIO dongles ( ) https://www.bleuio.com/ The script for the dongle (available on the source code inside web script folder) A board with a STM32 Microcontroller with a USB port. (A Nucleo-144 development board: NUCLEO-H743ZI2, was used developing this example. ( ) https://www.st.com/en/evaluation-tools/nucleo-h743zi.html To connect the dongle to the Nucleo board a “USB A to Micro USB B”-cable with a USB A female-to-female adapter can be used.) STM32CubeIDE ( ) https://www.st.com/en/development-tools/stm32cubeide.html A 5V Relay A light bulb Connecting the relay NOTICE OF RISK; DISCLAIMER OF LIABILITY Always be very careful when experimenting with AC, electrical shock can result in serious injuries! For the DC part of the Relay circuit connect S (signal) to pin PE4 on the STM32 NUCLEO board, also connect the Power supply (+) and ground (-) to +5V and GND respectively. Pinout and Connection to STM32 About the Code You can get the project HERE https://github.com/smart-sensor-devices-ab/stm32_bleuio_lightbulb_example This project-based on our previous STM32 project ( ) with these changes in the .ioc file: https://github.com/smart-sensor-devices-ab/stm32_bleuio_example In the pinout view we set the GPIO PE4 to OUTPUT and labeled it to ‘lightbulb’. In the USBH_CDC_ReceiveCallback function in USB_HOST\usb_host.c we copy the CDC_RX_Buffer into a external variable called dongle_response that is accessible from the main.c file. void USBH_CDC_ReceiveCallback(USBH_HandleTypeDef *phost)
{
    if(phost == &hUsbHostFS)
    {
        // Handles the data recived from the USB CDC host, here just printing it out to UART
        rx_size = USBH_CDC_GetLastReceivedDataSize(phost);
        HAL_UART_Transmit(&huart3, CDC_RX_Buffer, rx_size, HAL_MAX_DELAY);

        // Copy buffer to external dongle_response buffer
        strcpy((char *)dongle_response, (char *)CDC_RX_Buffer);

        memset(CDC_RX_Buffer,0,RX_BUFF_SIZE);
        USBH_CDC_Receive(phost, CDC_RX_Buffer, RX_BUFF_SIZE);
    }

    return;
} In main.c we create a simple interpreter so we can react to the data we are receiving from the dongle. /**
  * @brief Simple dongle interpreter
  * @retval None
  */
void dongle_interpreter(uint8_t * input)
{

    if(strlen((char *)input) != 0)
    {
        if(strstr((char *)input, "\r\nADVERTISING...") != NULL)
        {
            isAdvertising = true;
        }
        if(strstr((char *)input, "\r\nADVERTISING STOPPED.") != NULL)
        {
            isAdvertising = false;
        }
        if(strstr((char *)input, "\r\nCONNECTED") != NULL)
        {
            isConnected = true;
            HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_SET);
        }
        if(strstr((char *)input, "\r\nDISCONNECTED") != NULL)
        {
            isConnected = false;
            HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_RESET);
        }
        if(strstr((char *)input, "L=0") != NULL)
        {
            isLightBulbOn = false;
            HAL_GPIO_WritePin(Lightbulb_GPIO_Port, Lightbulb_Pin, GPIO_PIN_RESET);

            writeToDongle((uint8_t*)DONGLE_SEND_LIGHT_OFF);

            uart_buf_len = sprintf(uart_tx_buf, "\r\nLight bulb is %s\r\n", isLightBulbOn ? "on":"off");
            HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
        }
        if(strstr((char *)input, "L=1") != NULL)
        {
            isLightBulbOn = true;
            HAL_GPIO_WritePin(Lightbulb_GPIO_Port, Lightbulb_Pin, GPIO_PIN_SET);

            writeToDongle((uint8_t*)DONGLE_SEND_LIGHT_ON);

            uart_buf_len = sprintf(uart_tx_buf, "\r\nLight bulb is %s\r\n", isLightBulbOn ? "on":"off");
            HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
        }
    }
    memset(&dongle_response, 0, RSP_SIZE);
} In main.c we create a simple interpreter so we can react to the data we are receiving from the dongle. /**
  * @brief Simple dongle interpreter
  * @retval None
  */
void dongle_interpreter(uint8_t * input)
{

    if(strlen((char *)input) != 0)
    {
        if(strstr((char *)input, "\r\nADVERTISING...") != NULL)
        {
            isAdvertising = true;
        }
        if(strstr((char *)input, "\r\nADVERTISING STOPPED.") != NULL)
        {
            isAdvertising = false;
        }
        if(strstr((char *)input, "\r\nCONNECTED") != NULL)
        {
            isConnected = true;
            HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_SET);
        }
        if(strstr((char *)input, "\r\nDISCONNECTED") != NULL)
        {
            isConnected = false;
            HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_RESET);
        }
        if(strstr((char *)input, "L=0") != NULL)
        {
            isLightBulbOn = false;
            HAL_GPIO_WritePin(Lightbulb_GPIO_Port, Lightbulb_Pin, GPIO_PIN_RESET);

            writeToDongle((uint8_t*)DONGLE_SEND_LIGHT_OFF);

            uart_buf_len = sprintf(uart_tx_buf, "\r\nLight bulb is %s\r\n", isLightBulbOn ? "on":"off");
            HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
        }
        if(strstr((char *)input, "L=1") != NULL)
        {
            isLightBulbOn = true;
            HAL_GPIO_WritePin(Lightbulb_GPIO_Port, Lightbulb_Pin, GPIO_PIN_SET);

            writeToDongle((uint8_t*)DONGLE_SEND_LIGHT_ON);

            uart_buf_len = sprintf(uart_tx_buf, "\r\nLight bulb is %s\r\n", isLightBulbOn ? "on":"off");
            HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
        }
    }
    memset(&dongle_response, 0, RSP_SIZE);
} We also update the handleUartInput function so we can have manual control over the light bulb via the UART. /**
  * @brief Simple uart input handler
  * @retval None
  */
void handleUartInput(UARTCommandTypeDef cmd)
{
    switch(cmd)
    {
        case UART_RX_0:
        {
            // 0
            uart_buf_len = sprintf(uart_tx_buf, "\r\n(0 pressed)\r\n");
            HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
            if(isBleuIOReady)
            {
                writeToDongle((uint8_t*)DONGLE_CMD_ATI);
            } else
            {
                uart_buf_len = sprintf(uart_tx_buf, BLEUIO_NOT_READY_MSG);
                HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
            }
            uartStatus = UART_RX_NONE;
            break;
        }
        case UART_RX_1:
        {
            // 1
            uart_buf_len = sprintf(uart_tx_buf, "\r\n(1 pressed light bulb on!)\r\n");
            HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
            HAL_GPIO_WritePin(Lightbulb_GPIO_Port, Lightbulb_Pin, GPIO_PIN_SET);
            uartStatus = UART_RX_NONE;
            break;
        }
        case UART_RX_2:
        {
            // 2
            uart_buf_len = sprintf(uart_tx_buf, "\r\n(2 pressed light bulb off!)\r\n");
            HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
            HAL_GPIO_WritePin(Lightbulb_GPIO_Port, Lightbulb_Pin, GPIO_PIN_RESET);

            uartStatus = UART_RX_NONE;
            break;
        }
        case UART_RX_NONE:
        {
            break;
        }
        default:
        {
            uartStatus = UART_RX_NONE;
            break;
        }
    }
} We put the interpreter function inside the main loop. /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
    MX_USB_HOST_Process();

    /* USER CODE BEGIN 3 */
    // Simple handler for uart input
    handleUartInput(uartStatus);
    // Inteprets the dongle data
    dongle_interpreter(dongle_response);

    // Starts advertising as soon as the Dongle is ready.
    if(!isAdvertising && !isConnected && isBleuIOReady)
    {
        HAL_Delay(200);
        writeToDongle((uint8_t*)DONGLE_CMD_AT_ADVSTART);
        isAdvertising = true;
    }
  }
  /* USER CODE END 3 */ How to setup project Downloading the project from GitHub Either clone the project, or download it as a zip file and unzip it, into your STM32CubeIDE workspace. Get project HERE https://github.com/smart-sensor-devices-ab/stm32_bleuio_lightbulb_example Importing as an Existing Project From STM32CubeIDE choose File>Import… Then choose General>Existing Projects into Workspace then click ‘Next >’ Make sure you’ve chosen your workspace in ‘Select root directory:’ You should see the project “stm32_bleuio_example”, check it and click ‘Finish’. Running the example In STMCubeIDE click the hammer icon to build the project. Open up the ‘STMicroelectronics STLink Virtual COM Port’ with a serial terminal emulation program like TeraTerm, Putty or CoolTerm. Serial port Setup: Baudrate: 115200 Data Bits: 8 Parity: None Stop Bits: 1 Flow Control: None Connect the BleuIO Dongle before running the example. In STMCubeIDE click the green play button to flash and run it on your board. The first time you click it the ‘Run Configuration’ window will appear. You can just leave it as is and click run. You should be greeted by this welcome message: Wait until the message: “[BleuIO Dongle Ready]” is shown. You can now connect with the other dongle using the script. You can also use the uart commands (0, 1 or 2): Press 0 to get device information. 1 to turn on lightbulb. 2 to turn off lightbulb. Dongle response will be printed to UART. Controlling the light from a web browser We wrote a simple script that connects to the dongle and sends signals to toggle the light from the web browser. For this script to work, we need connected to the computer. BleuIO USB dongle BleuIO javascript library Chrome 78 or later, and you need to enable the flag in #enable-experimental-web-platform-features chrome://flags A web bundler – ( ) parcel js Steps Create a simple Html file called index.html which will serve as the frontend of the script. This Html file contains some buttons that help connect and signal to the remote dongle, which is connected to stm32. `<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3" crossorigin="anonymous" /> <title>Control Light using Bleutooth Low Energy</title> </head> <body class="mt-5"> <div class="container mt-5"> <h1 class="mb-5">Control Light using Bleutooth Low Energy</h1> <button class="btn btn-success" id="connect">Connect</button> <button class="btn btn-warning" id="lightOn" disabled>Turn On</button> <button class="btn btn-danger" id="lightOf" disabled>Turn Off</button> </div> <div class="container mt-5"> <img id="light" src="light_off.png" alt="" /> </div> <script src="script.js"></script> </body> </html>` Create a js file called script.js and include it at the bottom of the Html file. This js file uses the BleuIO js library to write AT commands and communicate with the other dongle. import * as my_dongle from "bleuio";
const dongleToConnect = "[0]40:48:FD:E5:35:A5";
import lightOnImg from "./light_on.png";
import lightOfImg from "./light_off.png";
document.getElementById("connect").addEventListener("click", function () {
  my_dongle.at_connect();
  document.getElementById("lightOn").disabled = false;
  document.getElementById("lightOf").disabled = false;
  document.getElementById("connect").disabled = true;
});

document.getElementById("lightOn").addEventListener("click", function () {
  my_dongle
    .ati()
    .then((data) => {
      //make central if not
      if (JSON.stringify(data).includes("Peripheral")) {
        console.log("peripheral");
        my_dongle.at_central().then((x) => {
          console.log("central now");
        });
      }
    })
    .then(() => {
      // connect to dongle
      my_dongle
        .at_getconn()
        .then((y) => {
          if (JSON.stringify(y).includes(dongleToConnect)) {
            console.log("already connected");
          } else {
            my_dongle.at_gapconnect(dongleToConnect).then(() => {
              console.log("connected successfully");
            });
          }
        })
        .then(() => {
          // send command to control light
          my_dongle.at_spssend("L=1").then(() => {
            console.log("Turned on");
            document.getElementById("light").src = lightOnImg;
          });
        });
    });
});

document.getElementById("lightOf").addEventListener("click", function () {
  my_dongle
    .ati()
    .then((data) => {
      //make central if not
      if (JSON.stringify(data).includes("Peripheral")) {
        console.log("peripheral");
        my_dongle.at_central().then((x) => {
          console.log("central now");
        });
      }
    })
    .then(() => {
      // connect to dongle
      my_dongle
        .at_getconn()
        .then((y) => {
          if (JSON.stringify(y).includes(dongleToConnect)) {
            console.log("already connected");
          } else {
            my_dongle.at_gapconnect(dongleToConnect).then(() => {
              console.log("connected successfully");
            });
          }
        })
        .then(() => {
          // send command to control light
          my_dongle.at_spssend("L=0").then(() => {
            console.log("Turned off");
            document.getElementById("light").src = lightOfImg;
          });
        });
    });
}); The script js file has three button actions; connect and control light. Now we need to know the ID of the other dongle connected to STM32 so that we can connect to it. You can use this web terminal to get the dongle ID. Open this site and click connect to dongle. https://bleuio.com/web_terminal.html Select the appropriate port to connect. Once it says connected, type . This will show dongle information and current status. "ATI" If the dongle is on peripheral role, set it to central by typing "AT+CENTRAL" Now do a gap scan by typing "AT+GAPSCAN" Once you see your dongle on the list ,stop the scan by pressing control+c Copy the ID and paste it into the script (script.js) line #2 You will need a web bundler. You can use parcel.js Once parcel js installed, go to the root directory and type . This will start your development environment. “parcel index.html” Open the script on a browser using parcel js. You can easily connect to the dongle and turn on-off light from there.

A Guide to Making a BLE-Enabled Smart Bulb with STM32

Signal filtering is the bread and butter of digital signal processing, and ARM Cortex-M cores provide a very efficient way to implement IIR filters, especially for cores that come with an FPU. ARM maintains the library as a collection of useful DSP functionality, including IIR filters implemented using a Direct Form II transposed structure. Big words, right? CMSIS-DSP In fact, the maths needed to go from filter specification to running code are not necessarily straightforward to do on paper. The process is complex and error prone, plus there is not a lot of value in doing it yourself for every minimal parameter variation. That's why at we created a collection of scripts to harness the power of to design IIR filters and automatically get "ready-to-run" C code for our applications. Elimo Engineering GNU Octave Being very creative people, we called it and, in the spirit of open source, we made it available with examples on GitHub. iir-designer-cmsis-dsp The repo includes a file with example inputs like the following for a DC blocking filter: / % Example % nd order DC blocker, Hz, sampling frequency = kHz
% Plots the filter response sample signals / pkg load signal
order= f1= fs= plot_results= %// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // 1 2 20 44.1 and %// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // 2 20 44100 true design ; _iir_highpass_cmsis_butter( , , , ) order f1 fs plot_results which will give you the following output: coeffs = 0.99799 -1.99597 0.99799 1.99597 - . 0 99598 That array of coefficients can be directly used in ARM code like the following: #define IIR_ORDER #define IIR_NUMSTAGES (IIR_ORDER/ )

static 32_t m_biquad_state[IIR_ORDER];
static 32_t m_biquad_coeffs[ *IIR_NUMSTAGES] =
{ , , , , };

arm_biquad_cascade_df2T_instance_f32 iir_inst = 
{
  IIR_ORDER/ ,
  m_biquad_state,
  m_biquad_coeffs
};

extern 32_t* pSrc;
extern 32_t* pDst;
extern 16_t blockSize;

arm_biquad_cascade_df2T_f32(&amp;iir_inst, pSrc, pDst, blockSize); 2 2 float float 5 0.99799 -1.99597 0.99799 1.99597 -0.99598 const 2 float float uint Note that this code is mostly boilerplate, and you just need to provide an input array of floats (pSrc in our example), a buffer for the filtered signal (pDst) and their length (blockSize) Let us know if you find it useful, we would love to know what people are using it for!

Fast IIR filtering on ARM Cortex-M with CMSIS-DSP and GNU Octave

In 2017, the cryptocurrency rage reached to the highest point when Bitcoin surged to USD19,783, many speculators and miners started to invest an enormous amount of money into mining hardware and chips hoping to get on the craze. Cryptocurrency mining was originally designed to be doable with general-purpose computers. Yet with the increase in competition to the limited resources, miners have been seeking an effective way to improve their chances. A , known as ASIC, has taken over the mining market since. ASIC are chips that are designed with a singular purpose. For cryptocurrency mining, these chips are built into specifically designed motherboards and power supplies to efficiently . Each cryptocurrency has its own cryptographic hash algorithm and ASIC hardware are designed to excel at calculating that algorithm, in the case of Bitcoin, ASIC hardware is designed to calculate the SHA-256 hash algorithm. pplication-specific integrated circuit chips solve a specific algorithm However, in 2018, the bearish performance in the cryptocurrency market has put them in a difficult situation. Though with better performance comparing the general-purpose computer using GPU or CPU cards, there is a limited room of adjustment for the ASIC hardware. ASIC miners were seeking ways to deal with their machines and spaces they rent for running the mining machines. In contrast, GPU miners can easily adapt to new PoW algorithms and tokens due to better compatibility with different hash algorithms (in the cost of performance). Furthermore, the emerging of Cuckoo Cycle algorithm sheds light on the GPU mining to compete against the ASIC miners. What is Cuckoo Cycle PoW algorithm? is one of the most promising PoW algorithm created by Dutch computer scientist, John Tromp. Cuckoo cycle was originally applied as a measure to prevent email spams. Cuckoo cycle ASIC-resistant The email sender has to perform a certain amount of work that consumes computational power to prove that he does have the need to send out the email to the recipient. Yet, with its unique design, it sees fit for GPU mining. It focuses more on memory use, meaning the solution time is bound to memory bandwidth rather than the raw processor or GPU speed. Unlike other PoW algorithms that requires maxing out the capacity of your hardware that drains a lot of power which produces heat (which is why most mining factories are located in colder locations/or locations with cheap electricity that can turn A/C on 24/7), a memory-bound algorithm like Cuckoo cycle require far less energy than most other GPU, CPU or ASIC-bound PoW algorithms. The most up-to-date implementations and findings can be found on his . GitHub Difference between the Cuckoo Cycle PoW algorithm and the SHA256 used by Bitcoin? The SHA256 used by Bitcoin is a simple and pure hash function. The computational process of the solution is easily migratable from the CPU to GPU, FPGA, and ASIC. The above picture is an 8-node, 4-sided Cuckoo Cycle bipartite graph Cuckoo Cycle is a graph theory-based algorithm. It tries to find a fixed length L ring in the Cuckoo Cycle bipartite graph randomly generated by Siphash. As the scale of the graph increases, the L value increases and becomes more difficult to find a ring that fits the length of L. Solving the solution (i.e., the process of finding a loop) itself requires a relatively large amount of memory to store the sorting of data. The Cuckoo Cycle algorithm is to ASIC chips. The difficulty and cost to make Cuckoo Cycle compatible on ASIC are much higher than the SHA256 of Bitcoin. It is possible to reduce the anti-ASIC capability by deformation and become an ASIC-friendly algorithm, but it is also possible to further improve its ASIC resistance through deformation as well. resisted For example, simplifies and discards the binary end of nodes in the bipartite graph which greatly reduce the difficulty of the solution. However, if all the nodes in the bipartite graph are grouped where all the nodes in the group have mutually dependent relationships, it is necessary to calculate the hash of all the nodes in the group. The difficulty of the solution and the requirements for data cache are then greatly increased. This transformation of Cuckoo Cycle is called . CuckAToo algorithm CuckARoo algorithm Projects using the Cuckoo Cycle algorithm On the official Cuckoo Cycle page, a list of projects using this algorithm was announced including AE, Grin, and Cortex. GitHub The list of projects using Cuckoo Cycle on GitHub , also known as , is a new blockchain technology, designed to deliver unmatched efficiency, transparent governance, and global scalability. (2.0.0) was released a couple weeks ago. AE has a total of 254,396,431 AE and aims to boost 1,000 TPS. AE æternity Minerva Mainnet upgrade is currently live with its Grin uses the Mimblewimble protocol to improve scalability and privacy. It empowers anyone to transact or save modern money without the fear of external control or oppression. Grin is designed for the decades to come, not just tomorrow. Grin wants to be usable by everyone, regardless of borders, culture, skills or access. Grin does not have circulating limit, which means that there is no limit on the total amount, and 60 Grins are mined per minute. Grin mainnet . is building something unique and original. Cortex aims to create a decentralized AI autonomous system that continues to expand the performance boundaries of smart contracts, allowing smart contracts to be actually smart with AI algorithms. In Cortex’s AI on Blockchain ecosystem, AI model developers, AI DApp developers, miners, and users can be linked together through public blockchain to create more AI DApps with real-world use cases. It also help stimulating more high-quality AI models to open source through the tokenomic model and incentive mechanism, which helps to democratize AI research which often led to concentrations of power and money. This is a new AI on Blockchain ecosystem that is independently governed by AI smart contracts. Cortex follows the four-year halving mechanism of Bitcoin. The total amount of CTXC mined through PoW is 150 million, and the first four years yields 75 million, which is halved every four years. Currently, the is live and the are live. Cortex TestNet first AI DApp Grin and Cortex's take on ASIC Grin uses CuckARoo (anti-ASIC) and CuckAToo (ASIC-friendly) algorithms in parallel where 90% of Grin is mined by ASIC-resistant CuckARoo and 10% of Grin is mined by ASIC-friendly CuckAToo. This ratio will be adjusted every six months to the point that will fully adopt ASIC-friendly CuckAToo. Grin Cortex In contrast, goal is to try to establish an environment where any AI equipment or conventional hardware already owned by everyone to be able to mine. Based on this goal, anti-ASIC is a firm belief in Cortex. The reason for this is that Cortex hopes to allow the mining machine investors in the Cortex ecosystem to have better general-purpose computing capabilities and lay the foundation for the future large-scale AI computing demand market. Cortex’s Cortex has released a full version of the which is already using a version of Cuckoo Cycle for consensus mechanism. The AI smart contract feature has also been deployed. The first fully available has been created on the TestNet. The development progress of the MainNet is working in progress according to the roadmap, which will be launched in Q2 of 2019. The launched of Cortex MainNet will bring a new wave of not just to AI developers and DApp developers but also to GPU miners. TestNet AI DApp The first AI DApp on the Cortex TestNet Conclusion Cuckoo Cycle is the newly emerging Proof-of-Work algorithm adopt by many projects to establish a friendly mining environment. It generates random bipartite graphs from a provided message and tries to find whether a subgraph with required property exists or not. Different projects have their objectives using Cuckoo Cycle. The algorithm itself has a relatively high anti-ASIC capability and can be modified into other algorithms to adjust the anti-ASIC capability. For Grin, Cuckoo Cycle was used to the Bitcoin-style “hardware arms-race” by making it ASIC resistant. For Cortex, it is to the mining requirements to lay the foundation for future scalability in AI computing demand market. Cukoo Cycle and GPU mining will lead us to a better mining environment where anyone can be a part of. mitigate against lower

WTF is Cuckoo Cycle PoW algorithm that attract projects like Cortex and Grin?

Your brain is a magical thing. It is the computer that you, that defines your world, and creates the interface for which you interpret “reality.” Technology and culture are starting to make us aware of just machine-like we are. In the movie “ ,” Nathan, shows Caleb the artificial wetware brain he crafted out of an exotic gel, essentially distilling our consciousness down to just a very expensive piece of tech. ( ) Treating your mind like a machine is an approach that is logical and highly beneficial. is how Ex Machina Apparently you can build one if you are so inclined. My Mom’s Desktop on her is a mess. I just counted and there are over 8,000 files sitting there just on the Desktop. But, she gets a lot done. She runs a youth theatre, is CFO and COO for my Dad’s business, and despite my bias, is genuinely one of the most productive people I know. But, back to the subject, her Desktop on that MacBook gives me instant anxiety. It’s a clusterfuck. So, every 2 or 3 years she gets a new laptop and I end up cloning her old computer onto her new one, except I always put her Desktop folder into a sub folder. At some point, I delete the old ones. She never notices. MacBook Many times, when working on a collaborative project, I hear someone say “I just didn’t have time to get to it,” or “I was distracted.” 9 times out of 10, their life is just too busy, their office too messy, and they watch The News every night before bed. Our minds (most of them) can’t deal with a Desktop like my mom’s. Our minds need clean input to obtain clean output. Our brains take in everything, and we are very much at the peril of the world. But, we have mechanisms to clean our mind’s Desktop. Reduce Distraction There are lots of things I do to reduce distraction: I don’t have sounds on my phone. If you call me, my phone doesn’t ring. If you message me, my phone doesn’t even vibrate. In fact, there is only 1 person that my phone makes sound for. This reduces distraction. But the most important piece of the input puzzle is not the amount of input, but the quality of the input. Even just a little positive input in a crowded life can completely change everything. We have deliberate input sources, like TV, books, and other media. I stopped watching TV for years. I don’t read Facebook, and my Twitter usage is limited. I read books with purpose and intent, and try to only interact with positive people. But there is so much input you receive without consent. Reprogram To combat the input you receive without your consent, you need to employ some reprogramming techniques. Can you remember the last time you had such an amazing day, that you went to bed, slept like a baby, and woke up the next morning feeling deep love in your heart? It would be amazing if we could operate this way, almost irregardless, every single day. We can’t always feel good, but we can rewire our brain to function more positively. The 2 biggest ideas for reprogramming your mind are: Mind follows body. If you start moving your body, your mind will follow suit. Subconscious programming through self hypnosis is real, it works, and you can change your life with it. The aim is to reprogram our brain more positively. Think of someone that makes you extremely happy and picture the essence and joy they conjure in your mind. They aren’t around right now, but you can still feel that happiness. All of that wonderfulness was fed straight to your brain, and you can recall it. People subtly feed you information about who they are and their intentions. How people sit in our minds has a lot to do with the subconscious information we’ve gathered on them, and how our brain processes it. People are hypnotizing. They work their way into our minds through very hypnotic, subconscious methods. We can also program our own vision of ourselves, the outlook we have on the day, and the perspective we take on life in a similar fashion through self hypnosis. The Hypnosis Experience I was laying in a chair, feeling my body floating perhaps 4 feet in the air. Colors of yellow were washing over my eyes and words being echoed through the air were entering and exiting my mind simultaneously. I saw a version of myself that I had not seen in a long time. Waves of energy pulsed through my body. And, then a finger snapped… I was awake and I felt “good.” What I experienced was similar to meditation experiences I had in the past, so I didn’t think it was absolutely crazy, but I was bewildered. I didn’t think I would see a dramatic change in my life by listening to this hypnosis session every day, but I continued to every day since that day. In 3 years, there is not a single thing I can contribute to my health, happiness, and success more than self hypnosis. I was told many years ago by my father that self hypnosis is something you are doing whether you think you are or not. You can be in control of the content your brain receives, or let the world decide for you. Hypnosis is real and it works. What does it mean? Mental health is something we don’t talk about enough. It’s not just about beating depression, but about finding ways to optimally live in the moment. There are wonderful things out there, like hypnosis, meditation and exercise. Take control of your brain’s input and output, and do everything and anything you need to attain the optimal life you desire. Originally published at https://noeljackson.com/io-cerebral-cortex/ Noël Jackson is an engineer, designer, and hacker working on the web since 1998, with a focus on optimization through thoughtfulness and logic. He currently works at studio.zeldman as director of development.

I/O for Your Cerebral Cortex

Stack: Older developers and engineers might remember the LAMP stack💡  and although it’s reengineered, if we strip down everything to the basics what we find and need is: an operating system


a web server


a database


a programming language What I’m going to talk to you today is how I reimagined the LAMP stack in an alternative format: Linux
Apache
MySql
Php
to:
Ubuntu
Apache
Sqlite3
Python What Does It Take? Nowadays, all that I hear all too often is: “I want to become a developer how do I get started?”, “I want to become a developer what laptop do I need?” or “Do I need to buy the latest MacBook to become a developer?” and to be honest, it’s starting to get to me. No kids, you don’t need the latest fancy tech or a rocket🚀 to become a developer, what you need is an operating system that is capable of installing programming packages and can compile them; you can even use your grandma’s old laptop. And now you ask: “How can this be?!” Let’s take a short trip down memory lane; almost 3 and a half years ago, I started tinkering with an SBC - single board computer that starts at under 50E to buy, and on it right now, I have a web server, a database, am performing hundreds of web-scrapes per hour, and on top of it, I’m working on developing an API endpoint. This SBC is not even the latest in its range and has: 8GB of LPDDR4  internal memory


1.5GHz quad-core ARM Cortex-A72 CPU (launched in 2015) - that you can easily and safely overclock at 2GHz (+fan extension & heatsink) Here’s what GPT has to say about these specs:
The specifications you provided are decent for certain types of computing tasks, but they may not be sufficient for others. Here's an evaluation: 8GB LPDDR4 internal memory:
LPDDR4 is a relatively fast and power-efficient type of RAM commonly used in mobile devices and some laptops.
8GB is a moderate amount of memory that should be sufficient for everyday tasks like web browsing, office work, and light multitasking. It can also handle moderate gaming and content creation applications.
However, for more demanding tasks like video editing, graphic design, or running virtual machines, 8GB may be limiting, and you might experience performance bottlenecks.
1.5GHz Quad-Core ARM Cortex-A72 CPU:


The ARM Cortex-A72 is a capable processor design commonly found in smartphones, tablets, and other mobile devices.


A quad-core configuration means it has four cores, allowing it to handle multiple tasks simultaneously more efficiently.


The 1.5GHz clock speed is decent for general-purpose computing tasks, including web browsing, media consumption, and productivity applications.


However, for more demanding tasks such as gaming, video editing, or running complex software, a higher clock speed and possibly more cores would provide better performance.
In summary, these specifications are suitable for light to moderate computing tasks, such as everyday productivity, web browsing, and multimedia consumption. However, for more demanding tasks or future-proofing, you may want to consider upgrading to a system with more RAM and a faster CPU. Trust me, in the beginning, light to moderate is more than sufficient, so with a Pi board, you can easily have a working desktop environment in which you can learn how to code, and not only frontend but even backend programming languages such as Python, c++ (which is even more energy efficient), or javascript. What do I use? On my Raspberry Pi, I am developing code with: Ubuntu Desktop - courtesy of desktopify:

Which I had to secure and in doing so I learned about:


web server vulnerabilities


firewalls


antivirus


intrusion prevention software IPS


networking


DNS


strong password management


ssh keys


SSL certificates






VSCode remotely connecting to the server


Python3 scripts which scrape the web and build HTML webpages embodied by CSS


requests


selenium


pandas


parallel processing - concurrent.futures




Javascript coupled with PHP here and there.


Python3 scripts that automatically write in my Sqlite3 database in JSON format.


Flask app, a small and lightweight Python web framework that provides useful tools and features that make creating web applications in Python.


And lastly, a Javascript piece of code that calls the Flask endpoint - a RESTful API endpoint
For close to 4 years at a definitely amortized cost of 120E and < 4E per month in electricity🔌. To summarize everything, here’s the BerryNews system architecture: The key factors here are Efficient Resource Utilization + Resource Utilization Constraints. Why splurge when you can write efficient code? Conclusion: If we were to sum up everything, we’d end up with a table such as this on a 100-dollar computer: Category

Keywords



Programming languages

Python3, Javascript, PHP, CSS, HTML, SQL



Data formats

JSON



Frameworks

flask, selenium, concurrent.futures



Databases

sqlite3



Networking

router config, DNS



Cybersecurity

UFW (firewall), ClamAV (antivirus), Fail2ban (IPS), password management, SSH Keys, Let’s Encrypt (SSL certificate)



Linux

Raspberry Pi, Ubuntu Desktop, VSCode So, tell me, do you still think you need the latest laptop specs to become a developer? Stack: Stack: Older developers and engineers might remember the LAMP stack💡  and although it’s reengineered, if we strip down everything to the basics what we find and need is: strip down everything to basics an operating system a web server a database a programming language an operating system an operating system a web server a web server a database a database a programming language a programming language What I’m going to talk to you today is how I reimagined the LAMP stack in an alternative format : the LAMP stack in an alternative format Linux Apache MySql Php
to: Ubuntu Apache Sqlite3 Python Linux Apache MySql Php to: to: Ubuntu Apache Sqlite3 Python What Does It Take? What Does It Take? Nowadays, all that I hear all too often is: “I want to become a developer how do I get started?”, “I want to become a developer what laptop do I need?” or “Do I need to buy the latest MacBook to become a developer?” and to be honest, it’s starting to get to me. No kids , you don’t need the latest fancy tech or a rocket🚀 to become a developer, what you need is an operating system that is capable of installing programming packages and can compile them; you can even use your grandma’s old laptop. And now you ask: “How can this be?!” No kids Let’s take a short trip down memory lane; almost 3 and a half years ago, I started tinkering with an SBC - single board compute r that starts at under 50E to buy, and on it right now, I have a web server, a database, am performing hundreds of web-scrapes per hour, and on top of it, I’m working on developing an API endpoint. SBC single board compute This SBC is not even the latest in its range and has: SBC 8GB of LPDDR4  internal memory 1.5GHz quad-core ARM Cortex-A72 CPU (launched in 2015) - that you can easily and safely overclock at 2GHz (+fan extension & heatsink) 8GB of LPDDR4  internal memory 8GB of LPDDR4  internal memory 1.5GHz quad-core ARM Cortex-A72 CPU (launched in 2015) - that you can easily and safely overclock at 2GHz (+fan extension & heatsink) 1.5GHz quad-core ARM Cortex-A72 CPU (launched in 2015) - that you can easily and safely overclock at 2GHz (+fan extension & heatsink) Here’s what GPT has to say about these specs:
The specifications you provided are decent for certain types of computing tasks, but they may not be sufficient for others. Here's an evaluation: 8GB LPDDR4 internal memory: LPDDR4 is a relatively fast and power-efficient type of RAM commonly used in mobile devices and some laptops. 8GB is a moderate amount of memory that should be sufficient for everyday tasks like web browsing, office work, and light multitasking. It can also handle moderate gaming and content creation applications. However, for more demanding tasks like video editing, graphic design, or running virtual machines, 8GB may be limiting, and you might experience performance bottlenecks. 1.5GHz Quad-Core ARM Cortex-A72 CPU:


The ARM Cortex-A72 is a capable processor design commonly found in smartphones, tablets, and other mobile devices.


A quad-core configuration means it has four cores, allowing it to handle multiple tasks simultaneously more efficiently.


The 1.5GHz clock speed is decent for general-purpose computing tasks, including web browsing, media consumption, and productivity applications.


However, for more demanding tasks such as gaming, video editing, or running complex software, a higher clock speed and possibly more cores would provide better performance.
In summary, these specifications are suitable for light to moderate computing tasks, such as everyday productivity, web browsing, and multimedia consumption. However, for more demanding tasks or future-proofing, you may want to consider upgrading to a system with more RAM and a faster CPU. 8GB LPDDR4 internal memory: LPDDR4 is a relatively fast and power-efficient type of RAM commonly used in mobile devices and some laptops. 8GB is a moderate amount of memory that should be sufficient for everyday tasks like web browsing, office work, and light multitasking. It can also handle moderate gaming and content creation applications. However, for more demanding tasks like video editing, graphic design, or running virtual machines, 8GB may be limiting, and you might experience performance bottlenecks. 1.5GHz Quad-Core ARM Cortex-A72 CPU: The ARM Cortex-A72 is a capable processor design commonly found in smartphones, tablets, and other mobile devices.


A quad-core configuration means it has four cores, allowing it to handle multiple tasks simultaneously more efficiently.


The 1.5GHz clock speed is decent for general-purpose computing tasks, including web browsing, media consumption, and productivity applications.


However, for more demanding tasks such as gaming, video editing, or running complex software, a higher clock speed and possibly more cores would provide better performance.
In summary, these specifications are suitable for light to moderate computing tasks, such as everyday productivity, web browsing, and multimedia consumption. However, for more demanding tasks or future-proofing, you may want to consider upgrading to a system with more RAM and a faster CPU. The ARM Cortex-A72 is a capable processor design commonly found in smartphones, tablets, and other mobile devices. A quad-core configuration means it has four cores, allowing it to handle multiple tasks simultaneously more efficiently. The 1.5GHz clock speed is decent for general-purpose computing tasks, including web browsing, media consumption, and productivity applications. However, for more demanding tasks such as gaming, video editing, or running complex software, a higher clock speed and possibly more cores would provide better performance.
In summary, these specifications are suitable for light to moderate computing tasks, such as everyday productivity, web browsing, and multimedia consumption. However, for more demanding tasks or future-proofing, you may want to consider upgrading to a system with more RAM and a faster CPU. The ARM Cortex-A72 is a capable processor design commonly found in smartphones, tablets, and other mobile devices. The ARM Cortex-A72 is a capable processor design commonly found in smartphones, tablets, and other mobile devices. A quad-core configuration means it has four cores, allowing it to handle multiple tasks simultaneously more efficiently. A quad-core configuration means it has four cores, allowing it to handle multiple tasks simultaneously more efficiently. The 1.5GHz clock speed is decent for general-purpose computing tasks, including web browsing, media consumption, and productivity applications. The 1.5GHz clock speed is decent for general-purpose computing tasks, including web browsing, media consumption, and productivity applications. However, for more demanding tasks such as gaming, video editing, or running complex software, a higher clock speed and possibly more cores would provide better performance.
In summary, these specifications are suitable for light to moderate computing tasks, such as everyday productivity, web browsing, and multimedia consumption. However, for more demanding tasks or future-proofing, you may want to consider upgrading to a system with more RAM and a faster CPU. However, for more demanding tasks such as gaming, video editing, or running complex software, a higher clock speed and possibly more cores would provide better performance.
In summary, these specifications are suitable for light to moderate computing tasks, such as everyday productivity, web browsing, and multimedia consumption. However, for more demanding tasks or future-proofing, you may want to consider upgrading to a system with more RAM and a faster CPU. Trust me, in the beginning, light to moderate is more than sufficient, so with a Pi board, you can easily have a working desktop environment in which you can learn how to code, and not only frontend but even backend programming languages such as Python, c++ (which is even more energy efficient), or javascript. desktop What do I use? What do I use? On my Raspberry Pi, I am developing code with: Ubuntu Desktop - courtesy of desktopify:

Which I had to secure and in doing so I learned about:


web server vulnerabilities


firewalls


antivirus


intrusion prevention software IPS


networking


DNS


strong password management


ssh keys


SSL certificates VSCode remotely connecting to the server Python3 scripts which scrape the web and build HTML webpages embodied by CSS


requests


selenium


pandas


parallel processing - concurrent.futures Javascript coupled with PHP here and there. Python3 scripts that automatically write in my Sqlite3 database in JSON format. Flask app, a small and lightweight Python web framework that provides useful tools and features that make creating web applications in Python. And lastly, a Javascript piece of code that calls the Flask endpoint - a RESTful API endpoint
For close to 4 years at a definitely amortized cost of 120E and < 4E per month in electricity🔌. Ubuntu Desktop - courtesy of desktopify: Which I had to secure and in doing so I learned about:


web server vulnerabilities


firewalls


antivirus


intrusion prevention software IPS


networking


DNS


strong password management


ssh keys


SSL certificates Ubuntu Desktop - courtesy of desktopify : Ubuntu desktopify Which I had to secure and in doing so I learned about:


web server vulnerabilities


firewalls


antivirus


intrusion prevention software IPS


networking


DNS


strong password management


ssh keys


SSL certificates Which I had to secure and in doing so I learned about: web server vulnerabilities


firewalls


antivirus


intrusion prevention software IPS


networking


DNS


strong password management


ssh keys


SSL certificates secure web server vulnerabilities firewalls antivirus intrusion prevention software IPS networking DNS strong password management ssh keys SSL certificates web server vulnerabilities web server vulnerabilities web server vulnerabilities firewalls firewalls antivirus antivirus intrusion prevention software IPS intrusion prevention software IPS networking networking DNS DNS DNS strong password management strong password management ssh keys ssh keys ssh keys SSL certificates SSL certificates SSL certificates VSCode remotely connecting to the server VSCode remotely connecting to the server Python3 scripts which scrape the web and build HTML webpages embodied by CSS requests


selenium


pandas


parallel processing - concurrent.futures Python3 scripts which scrape the web and build HTML webpages embodied by CSS Python3 HTML CSS requests selenium pandas parallel processing - concurrent.futures requests requests selenium selenium pandas pandas parallel processing - concurrent.futures parallel processing - concurrent.futures Javascript coupled with PHP here and there. Javascript coupled with PHP here and there. Javascript PHP Python3 scripts that automatically write in my Sqlite3 database in JSON format. Python3 scripts that automatically write in my Sqlite3 database in JSON format. Sqlite3 JSON Flask app, a small and lightweight Python web framework that provides useful tools and features that make creating web applications in Python. Flask app, a small and lightweight Python web framework that provides useful tools and features that make creating web applications in Python. Flask web framework And lastly, a Javascript piece of code that calls the Flask endpoint - a RESTful API endpoint For close to 4 years at a definitely amortized cost of 120E and < 4E per month in electricity🔌. And lastly, a Javascript piece of code that calls the Flask endpoint - a RESTful API endpoint endpoint RESTful For close to 4 years at a definitely amortized cost of 120E and < 4E per month in electricity🔌. To summarize everything, here’s the BerryNews system architecture: The key factors here are Efficient Resource Utilization + Resource Utilization Constraints . Efficient Resource Utilization Resource Utilization Constraints Why splurge when you can write efficient code? Conclusion: If we were to sum up everything, we’d end up with a table such as this on a 100-dollar computer: Category

Keywords



Programming languages

Python3, Javascript, PHP, CSS, HTML, SQL



Data formats

JSON



Frameworks

flask, selenium, concurrent.futures



Databases

sqlite3



Networking

router config, DNS



Cybersecurity

UFW (firewall), ClamAV (antivirus), Fail2ban (IPS), password management, SSH Keys, Let’s Encrypt (SSL certificate)



Linux

Raspberry Pi, Ubuntu Desktop, VSCode Category

Keywords Programming languages

Python3, Javascript, PHP, CSS, HTML, SQL Data formats

JSON Frameworks

flask, selenium, concurrent.futures Databases

sqlite3 Networking

router config, DNS Cybersecurity

UFW (firewall), ClamAV (antivirus), Fail2ban (IPS), password management, SSH Keys, Let’s Encrypt (SSL certificate) Linux

Raspberry Pi, Ubuntu Desktop, VSCode Category Keywords Category Category Category Keywords Keywords Keywords Programming languages Python3, Javascript, PHP, CSS, HTML, SQL Programming languages Programming languages Python3, Javascript, PHP, CSS, HTML, SQL Python3, Javascript, PHP, CSS, HTML, SQL Data formats JSON Data formats Data formats JSON JSON Frameworks flask, selenium, concurrent.futures Frameworks Frameworks flask, selenium, concurrent.futures flask, selenium, concurrent.futures Databases sqlite3 Databases Databases sqlite3 sqlite3 Networking router config, DNS Networking Networking router config, DNS router config, DNS Cybersecurity UFW (firewall), ClamAV (antivirus), Fail2ban (IPS), password management, SSH Keys, Let’s Encrypt (SSL certificate) Cybersecurity Cybersecurity UFW (firewall), ClamAV (antivirus), Fail2ban (IPS), password management, SSH Keys, Let’s Encrypt (SSL certificate) UFW ( firewall ), ClamAV ( antivirus ), Fail2ban ( IPS ), password management, SSH Keys, Let’s Encrypt ( SSL certificate ) firewall antivirus IPS SSL certificate Linux Raspberry Pi, Ubuntu Desktop, VSCode Linux Linux Raspberry Pi, Ubuntu Desktop, VSCode Raspberry Pi, Ubuntu Desktop, VSCode So, tell me, do you still think you need the latest laptop specs to become a developer? So, tell me, do you still think you need the latest laptop specs to become a developer?

RaspberryPi: Technology Overload - LAMP🕯 to UASP🐝

রাস্পবেরিপি: প্রযুক্তি ওভারলোড - LAMP🕯 থেকে UASP🐝

RaspberryPi: Technologie-Überlastung – LAMP🕯 zu UASP🐝

RaspberryPi: Sobrecarga tecnológica: LAMP🕯 a UASP🐝

RaspberryPi : surcharge technologique - LAMP🕯 vers UASP🐝

रास्पबेरीपाई: प्रौद्योगिकी अधिभार - LAMP🕯 से UASP🐝 तक

RaspberryPi: テクノロジーの過剰 - LAMP🕯からUASP🐝まで

RaspberryPi: 기술 과부하 - LAMP🕯에서 UASP🐝까지

RaspberryPi: sobrecarga de tecnologia - LAMP🕯 para UASP🐝

RaspberryPi: технологическая перегрузка — от LAMP🕯 до UASP🐝

RaspberryPi: Aşırı Teknoloji Yükü - LAMP🕯'den UASP🐝'ye

RaspberryPi: Quá tải công nghệ - LAMP🕯 đến UASP🐝

RaspberryPi：技术超载 - 从 LAMP🕯 到 UASP🐝

A time is coming when your thoughts will be the only activity you need to get things done. Have you ever been so caught up with work, you don't want to move a muscle? You are not willing to use your voice because you feel the ideas will escape once you do. So, what do you do when you suddenly wish your favorite songs were playing at that moment, but you feel too lazy to pick up your phone or call Siri's attention to turn on your playlist? If only your thoughts could make the orders, right? Here, you are thinking, "Siri, play me 'Easy on Me' by Adele" and seconds later the sound fills your workspace. Then you think, "Nope, too low. Siri, increase the volume to 10", and the volume gets adjusted to suit what’s on your mind perfectly. Your brain alone processes commands without any effort from your mouth. I guess that can be seen as a grand breakthrough in the history of neuroscience—or probably not! Let's find out what this means for the world collectively. What Exactly is Neurocomputing? Neurocomputing is a branch of neuroscience that deals with the examination of brain patterns and activities. It is a subfield of cognitive neuroscience that scientifically studies the biological mechanisms and reactions of the brain to different experiences. The term applies to the process of reading, analyzing, and interpreting brain activities by utilizing brain sensors and an imaging framework to examine how our brain reacts in response to different emotions. This is usually through the use of a Brain-Computer Interface Device. The framework, in this case, is called the "triad,” a 3-step process of emotion-valuation, sensory-motor, and meaning-knowledge evaluation. With the introduction of Al, neuroscientists hit a new milestone with brain activity studies. The Rise of Neurocomputing Would you have ever imagined that one day, the content of your thoughts could be read by devices? Science fiction? Sure! Why not? We see a lot of that. But reality? That's almost impossible (or so we thought). Lie detectors were the most mind readers, but they can never detect what your thoughts are word by word. However, technology always seems to awe us as time progresses because the technology we once thought only existed in movies is right here! The use of brainwave-controlled devices to read minds began with the invention of Electro Encephalogram (EEG) in the 1900s. History has it that the German psychiatrist, Hans Berger, created the in neurosurgery. first EEG brain recording These devices, fitted with sensors, were used mostly to monitor and record a patient's brain activity. When placed on your scalp, the sensors pick up electrical signals produced by the brain, which can be interpreted. Around 2008, consumer-focused EEG became commercialized for public use. and —both tech companies—were among the early players in this scene as they released EEG headsets with the promise to create mind-controlled video games. NeuroSky Emotive Furthermore, it began being tested in other areas besides video games, like how it could be used to control your phone or other activities by companies like and . iBrain Muse Relief from Brain-Computer Interfaces Technology Innovations and advanced companies like Meta and Neuralink notched it up with their research into Brain-Computer Interfaces (BCIs) - a technology that can pick thoughts directly from brain neurons and translate them into words. This technology uses AI algorithms to read brain activity and decode emotions into words. Between 2017 and 2019, Meta began funding . As of March 2022, the funded Nature Neuroscience, UCSF researchers achieved brain-to-text decoding with an average error rate as low as 3% when it was tested with vocabularies of up to 300 words—a huge advancement from previous studies. this technology research into At the same time, Elon Musk's Neuralink is already making a good deal of progress with its flexible ultra-thin threads that can be implanted directly into the brain, enabling the carrier to control their gadgets/devices with their thoughts. This is already being tested on paraplegics. The technology has been very much welcomed by paralytic patients who need to gain a good level of control over their lives again. Neuralink has already begun testing the brain threads on paraplegics. Case Study of Neurocomputing Although this technological concept sounds somewhat new, neurocomputing has been in the research and development stage for years, and test-flight gadgets are already being produced. The possibilities of mind reading and brainwave-controlled gadgets are endless. Scientists continue to look into ways to integrate them into our lives, experimenting across various sectors with the possible use of non-invasive EEG devices and BCIs. Many of these experiments are often procedures aimed at helping the physically and mentally disabled to communicate their needs and gain some control over their lives. The world is not new to cases of patients who can not speak due to sicknesses, paralysis, stroke, or just being born that way. So when, for the first time in history, researchers at the GrapheneX-UTS Human-centric Artificial Intelligence Centre, University of Technology Sydney, invented a portable non-invasive device that could translate thoughts into words, it was seen as a breakthrough in neurocomputing. Breakthrough at the GrapheneX-UTS Human-centric Artificial Intelligence Centre: At the time, though, the accuracy was questionable, but with the initial goal achieved, it would only take more years of developing it to increase its accuracy rating. We already find Meta and Neuralink taking up this task with BCIs and electron threads. Evolving neurocomputing also makes smooth communication possible between humans and machines, be it our gadgets, robots, or prosthetic arms. The history of neurocomputing and brain-controlled devices left a remarkable mark in the FIFA 2014 World Cup when, for the first time, the symbolic kick-off event for the tournament was led and completed by a paraplegic man using an advanced assisted mobility technology—a brain-controlled exoskeleton. The FIFA 2014 World Cup Kick-Off Event: This technology, by , a collaborative invention of over 100 scientists from around the world, made use of a set of non-invasive electrodes to read the brain signals from the paraplegic and transmit them to the lightweight exoskeleton triggering movements that helped the man complete the kick-off successfully. The Walk Again Project In the same year of the FIFA World Cup kick-off event, the director of the Center for Neuromodulation, Ohio State University, Dr. Ali Rezai, performed a on 26-year-old quadriplegic Ian Burkhart. Paralyzed Ian Burkhart Regained Mobility: life-changing surgery The surgery involved implanting a tiny 4 x 4 mm microchip into Burkhart's motor cortex, used alongside an electrical sleeve and purpose-made algorithms. This allowed the sensors to trigger his thoughts to control his hands and fingers while bypassing his damaged spinal cord. It was a success. This is not the only successful brain implant in the history of neurocomputing; a man paralyzed from the shoulders down has also been able to regain control of his paralyzed muscles by bypassing the injured spinal cord with the into his motor cortex. implantation of two aspirin-sized 96-channel electrode arrays EEG devices and BCIs are greatly contributing to improved quality of life for disabled people. Other Notable Strides: But we can't say that brain-controlled and mind-reading devices are only for the sick and disabled. These devices could also be used to carry out other tasks/activities for the good of everyone: BBC and This Place teamed up to create a mind-reading headset to enable its user to control the with their thoughts—goodbye to remote controls. BBC iPlayer A team led by an Associate Professor at the KU-KIST Graduate School of Converging Science and Technology, Korea University, . Suk-Won Hwang, developed E-Glasses This prototype eyeglass is made up of flexible electrode sensors located between the ears and eyes of the wearer. First, the electrodes consist of an EEG to monitor the brain's electrical activity and an ElectroOculogram (EOG) to track eye movements and transmit both from the glasses to a device for processing and interpretation. This glass can be used to monitor the mental health of the wearer, help them control games with their eyes, and turn on and off the sunglasses mode when the wearer needs it. Nissan and NASA are working together to build a self-driving robot car technology called that can read, monitor, and measure a driver's brain activity to know if he/she is alert to drive or not. Mind Sense In an exciting twist of things, in 2013, NASA came up with the crazy idea of using . Together with scientists from the University of Essex, they launched a project to control a virtual spaceship with the mind. BCIs to control planetary rovers A competition was held in 2016 by neuroscientists at the University of Florida, a competition that had pilot flying their drones to the finish line by using their minds. Brain Drone Race And the list goes on and on. But like every other technology and thing that exists, there will always be pros and cons to consider. The Ethical Considerations of Neurocomputing Neurocomputing is a technology that is already transforming lives, especially for paraplegics, who, in many cases, have been able to get robotic body parts that can be controlled with their minds or bypass spinal cord injuries to stimulate their bodies into motion through brain neuron implants. People who couldn't talk can now communicate their feelings and what they want/need and interact through mind-reading gadgets. For everyone else abled people, organizations, and companies that wish to apply these gadgets in their daily lives or their various sectors, it is very much achievable. It can bring "ease" into certain activities and, perhaps, create a more quiet world. However, the implantation of invasive BCIs into the brain involves a surgical procedure that is almost too risky to be considered. The brain is a fragile organ; damage to it can lead to mental abnormalities or even brain death. As such, the risk of brain implants makes this technology far-fetched for fully functional humans. Paraplegics, on the other hand, can wager these procedures because of the quest to have a better quality of life. A delicate situation, but if that is what it takes for them not to be stuck in a static world at the mercy of others, it is worth the risky shot. This is why BCIs by companies like Neuralink and Meta, although envisioned to cater to all and sundry, are more appealing to the paralytic section of the world at the moment. Because of these concerns, scientists are looking back into non-invasive methods of mind reading. Last year, researchers at the , University of Technology Sydney, invented a portable, non-invasive cap-like device that could translate thoughts into words when placed on the head. GrapheneX-UTS Human-centric Artificial Intelligence Centre Additionally, scientists from the University of Texas, Austin, developed to translate the thoughts in one's brain into actual speech by monitoring the brain's activity involving the use of fMRI and Al language models. a non-invasive technique The accuracy of these techniques was average. However, with the intended goal achieved, it would only take more years of development to increase its accuracy. Still, no one wants to walk around carrying a headpiece with cords sticking out, and neither can they carry fMRI machines all day. Hence, there is a need for less obvious, non-intrusive devices or less risky invasive BCIs. While the world can be swamped by Brainwave-controlled devices that read our minds, it poses serious concerns. One day, like every other day, we'll be carrying out activities with silent thoughts all in our heads, but this is the sad part: organizations would be able to read, monitor, store, access, and use these thoughts when needed. As tragic as this sounds, it is already in progress. The thoughts in our brain are currently our only inaccessible assets, our privacy safe, our most intimate thoughts, and our personal identity—no one should be able to access our minds. Data Privacy: But with the recent discoveries and technologies in neuroscience, this intrinsic privacy may be breached sooner than we know, leaving us truly vulnerable to Big Tech companies and organizations. If we lose control of our minds, if any company can spy into our thoughts, what else do we have left of ourselves? Just like we have on the internet, companies would be able to buy and access our brain data for targeted marketing. The first appeal for every product starts with the brain. You may not be able to say it, but you can think it accurately. Imagine advertisers having that exact information just as we feel it; then, they will be able to market their products in a practically irresistible way. Neurocomputing and mind-reading devices would make brain data available on a massive scale, and this is also very detrimental to us. Think about it; aside from compelling advertising, how safe are you? The brain is where all your secrets lie: your passwords, location, investments, amount of money you own, where you saved your assets, etc. A brain data hack would mean a loss too great to bear. The argument of some neuroscientists that the potential for misuse of neurocomputing and mind reading is so great that there needs to be a revamp of the human rights laws to protect us all is valid. Because this technology has what it takes to interfere with our most basic rights, the current laws are not fully equipped to salvage the situation; we need a new "jurisprudence of the mind" for our protection. So, in all, our biggest challenge is privacy and safety! What's the future? A quiet world. Maybe what we need? Or maybe not. Elon Musk and his company, Neuralink, have been at the forefront, pushing the concept of neurocomputing beyond the idea of it being the help for paraplegics only. For Musk, it would take conceptual interactions to a whole new level where words and conversations don't have to be verbalized, just thought. He calls it "consensual telepathy,” a realm where your speech becomes completely unnecessary. You can walk into a room with people conversing but not conversing because their thoughts are flying invisibly between them. Reading that now, it does sound uncanny. What becomes of our speech? Oh! I know what you are thinking, "there would never be a day when our speech isn't needed,” and of course, that's somewhat true. But come to think of it, before the advent of mobile phones, would there have been a day we thought we'd be so glued to these gadgets we'd rarely appreciate physical communication and rather be embedded in virtual conversations? I don't think so. When all you need is your thoughts to perform the most basic activities like ordering a coffee from a cafe, asking your friend to pass you the popcorn at a movie, communicating a proposal to your boss, conversing verbally on a date, etc., you may slowly lose touch of actual words. Almost the same way, we are slowly losing touch with writing on paper because we'd rather type into our computers, tablets, or phones. Well, there's no denying the fact that it sounds pretty interesting, too. You'd never have to say you don't know how to express yourself because your mind will do all the expressing for you where words would have escaped you. The concept of your feelings will flow just as you feel them, and no matter how disgruntled they are, your receiver will get the exact message with the fear, excitement, contempt, and all the fleeting emotions - conveyed just as it is. Also, the advancement of this technology would eliminate the language barrier. Whatever we think can be communicated directly to the recipient in whatever language desired. What neurocomputing proposes for the future is both unsettling and intriguing, but we really can't stop technology from evolving, and neither can we stop the future. We only hope that measures are instituted to mitigate the cons while we hope for the best.

CORTEXR

cortexr.com

-- employees

Since n.d.

COMPANY RANKING

CORTEXR

EVERGREEN INDEX #3250

Representing this company? Click here to claim and customize this page!

CORTEXR WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

CORTEXR

cortexr.com

-- employees

Since n.d.

COMPANY RANKING

CORTEXR

EVERGREEN INDEX #3250

RELATED COMPANIESRANK

STORIES ABOUT CORTEXR

Representing this company? Click here to claim and customize this page!

CORTEXR WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!