Protetto: Migrazione dei sistemi informatici: come eseguire un’analisi aziendale AS-IS

Il contenuto è protetto da password. Per visualizzarlo inserisci di seguito la password:

Installazione e preparazione domotica con OpenHab

In questo tutorial spiegheremo come poter implementare un sistema domotico d’avanguardia utilizzando le più moderne tecnologie.

Per maggiori informazioni contatta l'esperto che collabora con noi

Ditta Pietrantuono Pietro

Installazione, Manutenzione e Riparazione Impianti Elettrici/Domotici

info@informaticagestionale.it

cell. 339.2605170

Utilizziamo la seguente lista di tecnologie hardware e software:

  1. OpenHAB opensource
  2. Raspberry PI B+
  3. Raspbian
  4. LCD touchscreen 7 pollici
  5. KODI Media center
  6. protocollo di comunicazione ZWave
  7. 4 punti luci (device zwave) di cui 2 dimmer
  8. sistema di allarme interno (zwave)
  9. 1 sensore temperatura, umidità (zwave)
  10. termostato (zwave o powerLine)
  11. webcam

  • prima di procedere, scarichiamo la versione di raspbian per il nostro raspberry https://www.raspberrypi.org/downloads/raspbian/. Raspbian è il sistema operativo ottimizzato per raspberry
  • una volta scaricata l’immagine la installiamo su SD CARD seguendo le seguenti istruzioni:
    • dopo aver inserito la scheda nel PC, formattare la scheda SD in FAT32
    • con windows o mac utilizzare uno dei tanti programmi di preparazione  dischi di avvio
    • con ubuntu installare l’immagine nella partizione della scheda SD:
      sudo dd if=/imagePosition/image.img.xz of=/dev/sd* (Attenzione! sostituire * con la partizione esatta della scheda SD, altrimenti, rischiate di cancellare l'intero disco del PC)
  • per fare in modo che lo schermo si adatti perfettamente con lo schermo da 7 pollici si deve modificare il file /boot/config.txt sulla partizione della scheda SD.
7” raspberry LCD preparation
  • dopo aver preparato lo schermo LCD da 7 pollici con il raspberry inserire nell’apposita fessura la scheda SD opportunamente preparata (ricorda di cambiare la risoluzione sulla scheda nel file /boot/config.txt)
socket SD card
  • una volta collegato il raspberry con la rete ethernet (o wireless), accenderlo, aspettare che raspbian si avvii correttamente, e da questo momento, collegarsi al raspberry direttamente attraverso SSH di un’altro device (a meno che non si voglia continuare la configurazione direttamente sul raspberry stesso). ssh pi@ip_public
  • una volta connessi al raspberry inseriamo questi comandi per aggiornare ed aggiungere nuovi software

sudo apt-get update
sudo apt-get upgrade

sudo apt-get install screen mc vim git htop

  • continuare l’installazione seguendo queste istruzioni

https://docs.openhab.org/installation/linux.html#package-repository-installation

una volta installato OpenHab, è possibile iniziare la configurazione vera e propria installando gli addons preferiti (esempio zwave) e configurando gli items che vengono automaticamente generati durante il rilevamento.

OpenHab utilizza diversi sistemi dashboard. Nel nostro caso il sistema domotico appena configurato si presenta come in figura.

  • tasto di accensione di tutte le luci
  • dimmer presente in sala
  • dimmer presente in camera da letto
  • webcam in sala
  • barra per il controllo del volume del mediacenter
  • play/pause mediacenter
  • tasto muto mediacenter

Al termine della configurazione possiamo associare al nostro terminale tutti i dispositivi elencati sopra:

  1. colleghiamo la webcam con la porta USB del raspberry
  2. colleghiamo i punti luce, i sensori, il termostato e l’allarme con il server zwave direttamente dalla dashboard di openhab 
  3. il sistema può essere integrabile con altri dispositivi quali:
    1. sensore di presenza delle persone autorizzate
    2. sensori porta-finestra antifurto
    3. sensori volumetrici e così via

Questo tutorial era solo un esempio,

se desiderate anche voi un impianto domotico ma non avete le competenze tecniche allora provate a contattare gli esperti che collaborano con noi:

Ditta Pietrantuono Pietro

Installazione, Manutenzione e Riparazione Impianti Elettrici/Domotici

info@informaticagestionale.it

cell. 339.2605170

oltre alla configurazione ed alla predisposizione del pannello di controllo ci si occuperà anche della personalizzazione dei collegamenti elettrici con l’impianto di casa.

Overload informativo e nuove tecnologie

Le nuove tecnologie, se ben integrate all’interno di un contesto aziendale, permettono un efficientamento dei flussi lavorativi ed un conseguente miglioramento delle performance su diversi KPI.

L’insieme dei sensori, degli attuatori, degli algoritmi per elaborazione dati, delle analisi e della creatività con i quali queste tecnologie interagiscono possono ridurre sensibilmente i costi dovuti a sprechi durante i processi aziendali e possono migliorare i tempi di processo.

La vera sfida è sfruttare le tecnologie esistenti in maniera intelligente evitando in tutti i modi l’overload informativo. Ovvero, avere più dati di quanti l’organizzazione sia capace di elaborare per trarne vantaggio.

L’eccesso informativo può essere infatti controproducente se non si riesce a gestire. L’impiego delle ultime tecnologie (capaci di generare dati in qualsiasi momento) e l’abbondanza dei dati aziendali richiedono l’impiego di avanzati sistemi di analisi.

I dati di per se, presi singolarmente, possono non essere significativi.

Per generare informazione “utile”, i dati devono essere associati tra loro in maniera intelligente e secondo alcune regole che determinano i contesti sui quali vengono analizzati (ad esempio, il dato “nome di una persona” se viene associata al dato “cliente” ci fornisce l’informazione che quella persona è un cliente. Oppure, se prendiamo il dato temperatura “T0” ed il dato “macchinaA” allora abbiamo l’informazione che la macchinaA ha una temperatura T0).

Prima di iniziare nuovi progetti informatici bisognerebbe anzitutto capire quali sono le reali esigenze aziendali. Fare uno studio dei processi e definire i KPI sui quali intervenire per avere miglioramenti sia nel breve che nel medio periodo.

Dopo di che, definire le tecnologie da adottare che supportino il raggiungimento degli obiettivi cercando di affidarsi a soluzioni più avanzate che hanno la caratteristica di interagire facilmente ed a bassi costi con sistemi eterogenei.

Da tenere in considerazione che uno dei fattori più critici delle tecnologie “passate” era la difficoltà di interagire con i sistemi eterogenei. Per fare integrazione tra diversi sistemi erano necessarie ore di analisi, sviluppo e di costante monitoraggio dei dati. Oggi, grazie all’impiego di standard affidabili e poco costosi di comunicazione, è possibile integrare i diversi sistemi in poco tempo e con limitati sviluppi.   

Sperando di avervi dato altri spunti per vostri futuri progetti, se avete bisogno di altre informazioni, potete contattarci o scrivere commenti.

Creazione di una semplice web application utilizzando maven, jpa2, spring, struts2, mysql (parte 4)

Definito il nostro modello User, vogliamo creare alcuni servizi su di esso. In particolare vogliamo dare la possibilità al sistema di creare nuovi utenti, eliminarli, aggiornarli e prelevarli tutti in una lista.

Per fare questo creeremo un’interfaccia UserService.java.

package it.sample.webapp.service;

import java.util.List;

import org.springframework.transaction.annotation.Transactional;

import it.sample.webapp.model.User;

public interface UserService {
  /**
   * Creates a new user
   * @param user new user to be created
   * @return updated user object that should be used for further updates
   * @throws javax.persistence.PersistenceException when the user can not be 
   *       persisted. This is a <code>RuntimeException</code>
   */
  public User createUser(User user);
  
  /**
   * Deletes the specified user
   * @param user user object to be deleted
   * @throws javax.persistence.PersistenceException when the user can not be 
   *       deleted. This is a <code>RuntimeException</code>
   */
  public void deleteUser(User user);
  
  /**
   * Updates the specified user
   * @param user user object to be updated
   * @return updated user object that should be used for further updates
   * @throws javax.persistence.PersistenceException when the user can not be 
   *       persisted. This is a <code>RuntimeException</code>
   */
  public User updateUser(User user);
  
  /**
   * Gets the user using specified user id
   * @param id unique id assigned to the user
   * @return <code>User</code> object; <code>null</code> if the user does not 
   *       exist in the database
   */
  public User getUser(Long id);
  
  /**
   * Gets all the users
   * @return list of all the users
   */
  public List<User> getAllUsers();
  
  /**
   * Gets the user using specified user name
   * @param name user's name
   * @return <code>User</code> object corresponding to the specified name; 
   *     <code>null</code> if the user does not exist in the database
   */
  public User getUserByUserName(String username);
}

									

L’interfaccia sarà poi implementata dalla classe UserServiceImpl.java

package it.sample.webapp.service.impl;

import java.util.List;

import javax.persistence.NoResultException;

import org.apache.log4j.Logger;
import org.springframework.transaction.annotation.Transactional;

import it.sample.webapp.dao.jpa.UserDao;
import it.sample.webapp.model.User;
import it.sample.webapp.service.UserService;

@Transactional
public class UserServiceImpl implements UserService{
  Logger  logger = Logger.getLogger(this.getClass());
  private UserDao userDao;
  
  @Override
  public User createUser(User user) {
    return userDao.save(user);
  }

  @Override
  public void deleteUser(User user) {
    userDao.delete(user.getId());
  }

  @Override
  public List<User> getAllUsers() {
    return userDao.getAll();
  }

  @Override
  public User getUser(Long id) {
    User user = null;
    try {
      user = userDao.getById(id);
    }
    catch (NoResultException nsre) {
      if (logger.isDebugEnabled()) {
        logger.debug("No user found for the specified ID : [" + id + "]");
      }
      user = null;
    }
    return user;
  }

  @Override
  public User updateUser(User user) {
    return userDao.save(user);
  }

  @Override
  public User getUserByUserName(String username) {
    User user = null;
    try {
      user = userDao.getByUserName(username);
    }
    catch (NoResultException nsre) {
      if (logger.isDebugEnabled()) {
        logger.debug("No user found for the specified Name : [" + username + "]");
      }
      user = null;
    }
    return user;
  }
  
  /**
   * Sets the DAO used by this service for persisting <code>User</code> object
   * @param userDao the user DAO to be used for persistence
   */
  public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
  }

  /**
   * Gets the <code>User</code> DAO used for persistence
   * @return the user DAO used for persistence
   */
  public UserDao getUserDao() {
    return userDao;
  }
}

									

Adesso creiamo una classe SampleAction richiamata da struts in modo da scrivere un minimo di logica di business.

Leggi tutto “Creazione di una semplice web application utilizzando maven, jpa2, spring, struts2, mysql (parte 4)”

Creazione di una semplice web application utilizzando maven, jpa2, spring, struts2, mysql (parte 3)

Ora possiamo iniziare a costruire la nostra applicazione.

Per prima cosa implementiamo il modello. Il nostro dominio in questo caso è l’utente e sarà rappresentato dalla classe User.java. Questa classe rappresenterà il nostro utente nel sistema. Verranno quindi implementati i metodi setter/getter che modificheranno le proprietà id, username, password

User.java

package it.sample.webapp.model;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * Defines a model that represents a user in the system.
 */

@Entity
@Table(name = "user")
public class User implements Serializable {
  private static final long serialVersionUID = -2230673925164485629L;
  
  @Id
  @GeneratedValue
  private Long id;
  
  private String username;
  private String password;

  
  

  /**
   * Sets the unique id for this user
   * @param id unique id to be assigned
   */
  public void setId(Long id) {
    this.id = id;
  }
  
  /**
   * Gets the unique id assigned to this user
   * @return the unique id
   */
  public Long getId() {
    return id;
  }
  
  /**
   * Gets the name of this user
   * @return the name
   */
  public final String getUsername() {
    return username;
  }
  
  /**
   * Sets the name of this user. 
   * @param name the name to set
   */
  public final void setUsername(String username) {
    this.username = username;
  }
  
  public String getPassword() {
    return password;
  }

  public void setPassword(String password) {
    this.password = password;
  }


}

									

A questo punto possiamo implementare gli oggetti DAO per l’accesso al DB.

Per fare questo implementiamo prima un’interfaccia generica che espone i metodi principali di accesso al DB (delete, getAll, getById,save) e poi una classe astratta che esegue un’implementazione di default della classe GenericDao. Ci preoccuperemo di implementare l’interfaccia in un secondo momento.

GenericDao.java

package it.sample.webapp.dao;

import java.io.Serializable;
import java.util.List;

/**
 * Defines a generic data access object that is extended by all the DAOs in the
 * system. This interface defines the common CRUD methods like <code>save</code>, 
 * <code>delete</code> <code>getAll</code> and <code>getById</code>.
 */
public interface GenericDao <T, ID extends Serializable> {
  
  /**
   * Gets the list of all objects of this type  
   * @return list of this objects; the list can be empty
   */
  public List<T>  getAll();
  
  /**
   * Gets the object using specified primary key
   * @param id primary key (ID) of the object to retrieve
   * @return object corresponding to the specified primary key (ID)
   * @throws javax.persistence.NoResultException when object
   *     corresponding to the specified ID (primary key) is not found. This is a
   *     <code>RuntimeException</code>
   */
  public T getById(ID id);
  
  /**
   * Saves the specified object. Handles both insert as well as update
   * @param object the object to save
   * @return managed copy of the original object. Use this object if you want 
   *       the future changes managed (persisted).
   * @throws javax.persistence.PersistenceException when the specified object
   *     could not be persisted. This is a
   *     <code>RuntimeException</code>
   */
  public T save(T  object);
  
  /**
   * Deletes the object that corresponds to the specified primary key (ID)
   * @param object the object to delete
   * @throws javax.persistence.PersistenceException when the specified object
   *     could not be deleted. This is a
   *     <code>RuntimeException</code>
   */
  public void delete(ID  id);
}

									

BaseJpaDao.java

package it.sample.webapp.dao.jpa;

import java.io.Serializable;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import it.sample.webapp.dao.GenericDao;

/**
 * Defines a Base DAO that provides JPA implementation. 
 * This class keeps the reference to the <code>EntityManager</code> and 
 * provides a default implementation for methods defined in the <code>GenericDao</code>
 * interface.
 */
public abstract class BaseJpaDao<T, ID extends Serializable> implements GenericDao<T, ID> {
  private Class<T> persistentClass;
  protected EntityManager entityManager;

  /**
     * Constructor that takes in a class to see which type of entity to persist
     * @param persistentClass the class type you'd like to persist
     */
    public BaseJpaDao(final Class<T> persistentClass) {
        this.persistentClass = persistentClass;
    }
  
  /**
   * Gets the <code>EntityManager</code> used by this DAO
   * @return the entityManager used for persistence
   */
  public final EntityManager getEntityManager() {
    return entityManager;
  }

  /**
   * Sets the <code>EntityManager</code> used by this DAO
   * @param entityManager the entityManager to be used for persistence
   */
  @PersistenceContext
  public final void setEntityManager(EntityManager entityManager) {
    this.entityManager = entityManager;
  }
  
  @Override
  public void delete(ID id) {
    this.entityManager.remove(id);
    
  }

  @SuppressWarnings("unchecked")
  @Override
  public List<T> getAll() {
    Query q = this.entityManager.createQuery("FROM " + 
                         this.persistentClass.getName());
    return q.getResultList();
  }

  @Override
  public T getById(ID id) {
    final T data= this.entityManager.find(persistentClass, id);
    return data;
  }

  @Override
  public T save(T object) {
    try {
    final T data = this.entityManager.merge(object);
    return data;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

}

									

Leggi tutto “Creazione di una semplice web application utilizzando maven, jpa2, spring, struts2, mysql (parte 3)”