Myah  Conn

Myah Conn

1591688820

Headless Installation of Raspberry Pi Using NOOBS with SSH

Nearly every tutorial I see on the internet assumes the reader has an external monitor. Yeah, the installation will be a piece of cake in case you have an external monitor. But the price of an external monitor is more or less the same as Raspberry Pi (raspi). In many cases, the project we want to build with raspi doesn’t need an external monitor, and in many cases, I just use SSH to control my raspi. It such a waste to buy a monitor just for the installation.
The installation and control over raspi without a monitor is called headless. There is an installation software called New Out Of the Box Software (NOOBS) provide officially by raspi itself. NOOBS provides several OS to install it in our raspi but the official OS of raspi is Raspbian. This story will guide you on how to install Raspbian using NOOBS and make it ready to remote it with SSH. In this case, I am using a WI-FI network to remote into the raspi.

#raspberry-pi #iot #linux #internet-of-things #programming

What is GEEK

Buddha Community

Headless Installation of Raspberry Pi Using NOOBS with SSH

TensorFlow Lite Object Detection using Raspberry Pi and Pi Camera

I have not created the Object Detection model, I have just merely cloned Google’s Tensor Flow Lite model and followed their Raspberry Pi Tutorial which they talked about in the Readme! You don’t need to use this article if you understand everything from the Readme. I merely talk about what I did!

Prerequisites:

  • I have used a Raspberry Pi 3 Model B and PI Camera Board (3D printed a case for camera board). **I had this connected before starting and did not include this in the 90 minutes **(plenty of YouTube videos showing how to do this depending on what Pi model you have. I used a video like this a while ago!)

  • I have used my Apple Macbook which is Linux at heart and so is the Raspberry Pi. By using Apple you don’t need to install any applications to interact with the Raspberry Pi, but on Windows you do (I will explain where to go in the article if you use windows)

#raspberry-pi #object-detection #raspberry-pi-camera #tensorflow-lite #tensorflow #tensorflow lite object detection using raspberry pi and pi camera

Tools and Images to Build a Raspberry Pi n8n server

n8n-pi

Tools and Images to Build a Raspberry Pi n8n server

Introduction

The purpose of this project is to create a Raspberry Pi image preconfigured with n8n so that it runs out of the box.

What is n8n?

n8n is a no-code/low code environment used to connect and automate different systems and services. It is programmed using a series of connected nodes that receive, transform, and then transmit date from and to other nodes. Each node represents a service or system allowing these different entities to interact. All of this is done using a WebUI.

Why n8n-pi?

Whevever a new technology is released, two common barriers often prevent potential users from trying out the technology:

  1. System costs
  2. Installation & configuration challenges

The n8n-pi project eliminates these two roadblocks by preconfiguring a working system that runs on easily available, low cost hardware. For as little as $40 and a few minutes, they can have a full n8n system up and running.

Thanks!

This project would not be possible if it was not for the help of the following:

Documentation

All documentation for this project can be found at http://n8n-pi.tephlon.xyz.

Download Details:

Author: TephlonDude

GitHub: https://github.com/TephlonDude/n8n-pi

#pi #raspberry pi #raspberry #raspberry-pi

Myah  Conn

Myah Conn

1591688820

Headless Installation of Raspberry Pi Using NOOBS with SSH

Nearly every tutorial I see on the internet assumes the reader has an external monitor. Yeah, the installation will be a piece of cake in case you have an external monitor. But the price of an external monitor is more or less the same as Raspberry Pi (raspi). In many cases, the project we want to build with raspi doesn’t need an external monitor, and in many cases, I just use SSH to control my raspi. It such a waste to buy a monitor just for the installation.
The installation and control over raspi without a monitor is called headless. There is an installation software called New Out Of the Box Software (NOOBS) provide officially by raspi itself. NOOBS provides several OS to install it in our raspi but the official OS of raspi is Raspbian. This story will guide you on how to install Raspbian using NOOBS and make it ready to remote it with SSH. In this case, I am using a WI-FI network to remote into the raspi.

#raspberry-pi #iot #linux #internet-of-things #programming

Philian Mateo

Philian Mateo

1583288477

How to Install TensorFlow and Recognize images using Raspberry Pi

Introduction

This article demonstrates how to install TensorFlow and recognize images using Raspberry Pi.

Prerequisite

  • Raspberry Pi
  • TensorFlow
  • Putty or VNC View

**About TensorFlow **

  • TensorFlow is a free and open-source software library for dataflow
  • It is a symbolic math library.
  • TensorFlow is a computational framework for building machine learning models.

TensorFlow has two components

  • a graph protocol buffer
  • a runtime that executes the (distributed) graph

Types of an image

  • BINARY IMAGE
  • BLACK AND WHITE IMAG
  • 8-bit COLOR FORMAT
  • 16-bit COLOR FORMAT

A 16-bit color format is divided into three different colors which are Red, Green, and Blue (RGB).

Step 1

Let’s go to install the raspbian stretch operating system and also get the latest version of Python, so open the Linux terminal to update Python.

This is image title

sudo apt-get update    
python --version    
python3 --version    

Installing TensorFlow needs some library file, so Libatlas library is required by the TensorFlow package installation. Once the library file is installed, then install the TensorFlow package.

Before installing TensorFlow, install the Atlas library.

sudo apt install libatlas-base-dev  

Once that is finished install TensorFlow via pip3

pip3 install --user tensorflow  

Nowwe’ve  successfully installed TensorFlowTensorFlow version-1-9-0.

Step 2

Once we install the TensorFlow we’re ready to test the basic TensorFlow script provided by the TensorFlow site and first, you can test the Hello World program. Now, I create a  new Python file like tftest.py,

sudo nano tftest.py  

Next, you have to import the TensorFlow library.

import tensorflow as tf  
hello = tf.constant('Hello, TensorFlow')  
sess = tf.Session()  
print (sess.run(hello))

Just run the code. You can see the hello TensorFlow program is successfully printed.

Run the code from the terminal:

python3 tftest.py   

This is image title

Step 3

Clone the TensorFlow classification script.

git clone https://github.com/tensorflow/models.git  

This is a panda image for reference:

This is image title

Once the script is running the panda image will be recognized.

cd models/tutorials/image/imagenet  
python3 classify_image.py 

Source Code

from __future__ import absolute_import  
from __future__ import division  
from __future__ import print_function  
  
import argparse  
import os.path  
import re  
import sys  
import tarfile  
  
import numpy as np  
from six.moves import urllib  
import tensorflow as tf  
  
FLAGS = None  
  
  
DATA_URL = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz'  
  
class NodeLookup(object):  
  
  def __init__(self,  
               label_lookup_path=None,  
               uid_lookup_path=None):  
    if not label_lookup_path:  
      label_lookup_path = os.path.join(  
          FLAGS.model_dir, 'imagenet_2012_challenge_label_map_proto.pbtxt')  
    if not uid_lookup_path:  
      uid_lookup_path = os.path.join(  
          FLAGS.model_dir, 'imagenet_synset_to_human_label_map.txt')  
    self.node_lookup = self.load(label_lookup_path, uid_lookup_path)  
  
  def load(self, label_lookup_path, uid_lookup_path):  
    if not tf.gfile.Exists(uid_lookup_path):  
      tf.logging.fatal('File does not exist %s', uid_lookup_path)  
    if not tf.gfile.Exists(label_lookup_path):  
      tf.logging.fatal('File does not exist %s', label_lookup_path)  
  
    proto_as_ascii_lines = tf.gfile.GFile(uid_lookup_path).readlines()  
    uid_to_human = {}  
    p = re.compile(r'[n\d]*[ \S,]*')  
    for line in proto_as_ascii_lines:  
      parsed_items = p.findall(line)  
      uid = parsed_items[0]  
      human_string = parsed_items[2]  
      uid_to_human[uid] = human_string  
    node_id_to_uid = {}  
    proto_as_ascii = tf.gfile.GFile(label_lookup_path).readlines()  
    for line in proto_as_ascii:  
      if line.startswith('  target_class:'):  
        target_class = int(line.split(': ')[1])  
      if line.startswith('  target_class_string:'):  
        target_class_string = line.split(': ')[1]  
        node_id_to_uid[target_class] = target_class_string[1:-2]  
    node_id_to_name = {}  
    for key, val in node_id_to_uid.items():  
      if val not in uid_to_human:  
        tf.logging.fatal('Failed to locate: %s', val)  
      name = uid_to_human[val]  
      node_id_to_name[key] = name  
    return node_id_to_name 
  def id_to_string(self, node_id):  
    if node_id not in self.node_lookup:  
      return ''  
    return self.node_lookup[node_id]  
def create_graph():  
  with tf.gfile.FastGFile(os.path.join(  
      FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:  
    graph_def = tf.GraphDef()  
    graph_def.ParseFromString(f.read())  
    _ = tf.import_graph_def(graph_def, name='')  
def run_inference_on_image(image):   
  if not tf.gfile.Exists(image):  
    tf.logging.fatal('File does not exist %s', image)  
  image_data = tf.gfile.FastGFile(image, 'rb').read() 
  
  create_graph() 
  with tf.Session() as sess:  
    
    softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')  
    predictions = sess.run(softmax_tensor,  
                           {'DecodeJpeg/contents:0': image_data})  
    predictions = np.squeeze(predictions)  
 .  node_lookup = NodeLookup()  
    top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]  
    for node_id in top_k:  
      human_string = node_lookup.id_to_string(node_id)  
      score = predictions[node_id]  
      print('%s (score = %.5f)' % (human_string, score))  
  
def maybe_download_and_extract():  
  dest_directory = FLAGS.model_dir  
  if not os.path.exists(dest_directory):  
    os.makedirs(dest_directory)  
  filename = DATA_URL.split('/')[-1]  
  filepath = os.path.join(dest_directory, filename)  
  if not os.path.exists(filepath):  
    def _progress(count, block_size, total_size):  
      sys.stdout.write('\r>> Downloading %s %.1f%%' % (  
          filename, float(count * block_size) / float(total_size) * 100.0))  
      sys.stdout.flush()  
    filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)  
    print()  
    statinfo = os.stat(filepath)  
    print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')  
  tarfile.open(filepath, 'r:gz').extractall(dest_directory)  
  
def main(_):  
  maybe_download_and_extract()  
  image = (FLAGS.image_file if FLAGS.image_file else  
           os.path.join(FLAGS.model_dir, 'cropped_panda.jpg'))  
  run_inference_on_image(image)
  
if __name__ == '__main__':  
  parser = argparse.ArgumentParser()  
  parser.add_argument(  
      '--model_dir',  
      type=str,  
      default='/tmp/imagenet',  
      help="""\ 
    
  )  
  parser.add_argument(  
      '--image_file',  
      type=str,  
      default='',  
      help='Absolute path to image file.'  
  )  
  parser.add_argument(  
      '--num_top_predictions',  
      type=int,  
      default=5,  
      help='Display this many predictions.'  
  )  
  FLAGS, unparsed = parser.parse_known_args()  
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)  

OUTPUT

This is image title

The same method is used to classify the external images like the following terminal command.

python3 classify_image.py --image_file=/PATH/  

This is the very beginning of the TensorFlow Raspberry pi, just install the TensorFlow and Classify the image.

Summary

In this article, you learned how to install TensorFlow and do image recognition using TensorFlow and Raspberry Pi.

Thank you for reading!

#tensorflow #python #raspberry pi #raspberry-pi

The Raspberry Pi 400 - A full computer in a keyboard!

The Raspberry Pi 400 has arrived in the studio, and in this video I’ll give it a review. I’ll show an unboxing of the Personal Computer Kit from Canakit, which is a great way to get started on the Pi 400. Then I’ll show off the hardware, as well as the out-of-box experience.

#raspberry pi #pi #raspberry-pi