Cashback Autostrade: cos'è, come funziona e perché registrarsi

Un riassunto pratico e diretto del servizio Muovy / Cashback di Autostrade per l'Italia: che cosa offre, a chi è rivolto e come iscriversi per ottenere rimborsi sul pedaggio in caso di ritardi dovuti ai cantieri.

```

Che cos'è il Cashback di Autostrade?

Il Cashback di Autostrade è un servizio che permette agli utenti della rete gestita da Autostrade per l'Italia di richiedere e, in alcuni casi, ricevere automaticamente un rimborso parziale o totale del pedaggio quando il viaggio subisce ritardi causati da cantieri che riducono la capacità di transito. In pratica: se percorri l'autostrada e perdi tempo a causa di lavori che limitano le corsie, puoi avere indietro parte (o tutto) del pedaggio pagato.

Chi può usarlo e quanto costa?

• Il servizio è disponibile a persone fisiche e giuridiche, senza costi di registrazione o commissioni per richiedere il rimborso.
• Funziona con tutte le modalità di pagamento del pedaggio (telepedaggio, carte, contanti) purché siano rispettati i criteri di eleggibilità.

Quando scatta il rimborso e quanto si riceve?

I rimborsi vengono calcolati in base al ritardo accumulato e alla lunghezza del percorso; la percentuale può variare (es.: dal 25% fino al 100% del pedaggio) in base alle regole di calcolo previste dal servizio. Nel tempo le soglie temporali per l'attivazione sono state adeguate (in pratica il rimborso può scattare già dopo soglie di ritardo contenute, come 10 minuti in alcune modalità).

Perché registrarsi (vantaggi pratici)

1. Rimborsi automatici: registrando la targa o il dispositivo di telepedaggio sul portale/app, i rimborsi vengono riconosciuti automaticamente senza bisogno di caricare ogni volta ricevute.
2. Storico e tracciamento: il portale tiene traccia delle richieste e degli importi maturati, così hai tutto in un unico posto.
3. Compatibilità: disponibile per privati, aziende e per chi usa dispositivi Telepass o altri sistemi di telepedaggio.
4. Gratuito: non ci sono costi di adesione; il rimborso è erogato da Autostrade per l’Italia secondo i termini previsti.

Come registrarsi — procedura rapida

Puoi registrarti da browser sul portale Muovy Cashback o attraverso l'app ufficiale (Free To X / Muovy). Procedura tipo:

1. Vai su cashback.autostrade.it o scarica l'app Muovy / Free To X.
2. Crea un account con email e password o accedi con credenziali aziendali se richiesto.
3. Registra la/e targa/e del veicolo oppure associa il dispositivo di telepedaggio.
4. Accetta i termini e condizioni (leggi la sezione privacy e limiti di responsabilità).
5. Una volta registrato, il sistema può calcolare automaticamente i rimborsi maturati e guidarti nella richiesta di accredito.

Documentazione e prove

Se non puoi utilizzare l’abbinamento automatico (ad esempio hai pagato in contanti e non hai telepedaggio), la procedura permette di caricare le ricevute del pedaggio come prova per la richiesta di rimborso.

Sicurezza, privacy e attenzione

Registrando targhe e dati di viaggio presta attenzione a:

• Leggere l'informativa privacy e i termini d'uso: controlla cosa viene conservato e per quanto tempo.
• Verificare che il portale sia ufficiale (autostrade.it), per evitare phishing o siti imitatori.
• Usare password robuste e, se disponibile, l'autenticazione a due fattori per l'account.

Contro e limiti da considerare

• Il rimborso è legato a ritardi causati specificamente da cantieri e condizioni previste dai termini: non è un rimborso per traffico generico non imputabile ai lavori programmati.
• I tempi di accertamento e di erogazione possono richiedere un po' di tempo operativo: tenere monitorato lo stato delle richieste.
• In caso di società o flotte, verificare le procedure dedicate per adesioni massicce o retroattive.

Conclusione — conviene registrarsi?

Se usi l'autostrada con una certa regolarità, registrare la targa o il dispositivo è una mossa intelligente: è gratuito, può portare rimborsi reali in caso di ritardi dovuti a lavori e ti evita pratiche manuali ripetute. Se invece usi la rete in modo molto saltuario, valuta il tempo necessario per mantenere aggiornato il profilo e la convenienza nel tuo specifico caso.

Link utili

• Portale Muovy / Cashback: cashback.autostrade.it
• Pagina ufficiale Rimborso del pedaggio su Autostrade per l'Italia
• App Muovy / Free To X (Google Play / App Store)

Nota: le regole e le soglie possono essere aggiornate dal gestore; per informazioni aggiornate consulta sempre la documentazione ufficiale e i termini sul sito.

```

NETGUARD - Android sono controllo

Se ti è mai capitato che un’app consumi dati a tua insaputa, invii pubblicità ovunque o comunichi con server che non vorresti, NetGuard è uno strumento elegante e leggero per tornare padrone della rete sul tuo smartphone Android. È un firewall no-root che usa una VPN locale per filtrare il traffico e decidere quale app può uscire su Internet.

Perché usare NetGuard

Privacy: impedisci alle app di inviare dati quando non vuoi.
Risparmio dati: blocchi aggiornamenti e sincronizzazioni inutili sotto rete mobile.
Batteria: meno connessioni inutili = meno consumi.
Controllo totale: puoi gestire separatamente Wi-Fi e rete mobile per ogni singola app.

Funziona davvero senza root?

Sì. NetGuard crea una VPN locale interna al dispositivo che non invia traffico all’esterno. Serve solo a intercettare e filtrare i pacchetti prima che escano dal telefono. È un trucco pulito, stabile e sicuro.

Caratteristiche principali

Blocco per app: icone Wi-Fi e dati accanto a ogni applicazione.
Supporto IPv4/IPv6 e TCP/UDP: completo e moderno.
Log dettagliato: mostra quali app tentano di connettersi e verso quali indirizzi.
Modalità Lockdown: blocca tutto tranne le eccezioni.
Open-source: codice pubblico e verificabile.

Limiti da conoscere

Una sola VPN alla volta: Android non permette due VPN contemporaneamente. Se usi una VPN remota, NetGuard non può funzionare simultaneamente.
App di sistema: alcuni servizi possono continuare a gestire parte della connettività.
Notifiche: bloccare troppo può interrompere notifiche push o sincronizzazioni.

Installazione e primi passi

1. Installa NetGuard dal Play Store o da F-Droid/GitHub.
2. Avvia l’app e autorizza la creazione della VPN locale.
3. Disattiva l’ottimizzazione batteria per NetGuard (opzionale ma utile).
4. Gestisci le autorizzazioni rete di ogni app con un semplice tocco.

Consigli pratici

Blocca prima l’accesso ai dati mobili delle app non essenziali, poi rifinisci il Wi-Fi. Usa il log per individuare app troppo “chiacchierone”. Puoi anche combinare NetGuard con un buon ad-blocker per una difesa multilivello.

Pro e contro

Pro: no-root, open-source, leggero, semplice, molto efficace.
Contro: incompatibile con altre VPN, qualche limite con le app di sistema.

Verdetto

NetGuard è uno dei firewall più intelligenti e puliti disponibili su Android. Perfetto per chi vuole controllo granulare senza complicarsi la vita con i permessi di root. Una volta provato, diventa difficile farne a meno soprattutto quando scopri quante app vogliono connettersi anche a schermo spento.

Pulizia Cartella APPDATA

💻 Caccia ai Residui: Rimuovere in Sicurezza le Cartelle AppData Orfane

Ciao a tutti! Se il vostro PC sembra rallentare e lo spazio su disco scompare misteriosamente, la colpa potrebbe essere dei "residui" lasciati dalle applicazioni che avete disinstallato tempo fa. Questi file orfani si nascondono nelle cartelle AppData di Windows. 

Pulirli manualmente è rischioso, ma ho creato uno script PowerShell che automatizza il processo, includendo un backup di sicurezza (file ZIP) prima della cancellazione!

---

🛑 Avvertimenti Fondamentali

ATTENZIONE! L'utilizzo di script PowerShell richiede cautela.

• Backup Preventivo: Lo script crea un backup ZIP per ogni cartella, ma una revisione umana è essenziale.
• Valutazione Umana: Lo script identifica solo i potenziali residui. Dovete voi stessi confermare che la cartella non sia più in uso. Alcune Cartelle memorizzano dati importanti, fare una ricerca prima di eliminarla!!!
• Esecuzione Amministrativa: Lo script DEVE essere eseguito come Amministratore.

---

🚀 Istruzioni per l'Uso (PowerShell ISE)

1. Crea il file: Copia il codice completo (sotto) e incollalo in un Blocco Note. Salvalo come PulisciAppData.ps1.
2. Apri l'ISE: Clicca con il tasto destro sull'icona di PowerShell ISE e seleziona "Esegui come amministratore".
3. Carica lo Script: Nell'ISE, vai su File > Apri e carica il file PulisciAppData.ps1 salvato.
4. Avvia lo Script: Clicca sul pulsante "Esegui Script" (la freccia verde) all'interno dell'ISE.
5. Conferma: Lo script ti mostrerà l'elenco dei potenziali residui. Per ognuno, digita S (Sì per Backup e Cancella), N (No, salta) o A (Annulla tutte le operazioni e termina).

Liberamente ispirato al progetto KoKi7o/MS-Script su github

Esempio di Backup: Se cancelli AppData\Roaming\EASUS, verrà creato un file AppData\Roaming\EASUS.zip prima della cancellazione della cartella originale.

---

💻 Lo Script Completo (PulisciAppData.ps1)

Copia il codice seguente e salvalo nel tuo file .ps1:
NB. Se lo Script non dovesse funzionare digitare:
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

# App Leftover Finder - Trova i file residui delle applicazioni disinstallate.
# Esegui come Amministratore per i migliori risultati nella scansione del Registro di sistema.

Write-Host "=== App Leftover Finder ===" -ForegroundColor Cyan
Write-Host "Scansione per residui da applicazioni disinstallate...`n" -ForegroundColor Yellow

# --- FUNZIONI DI UTILITÀ ---
function Normalize-Name($name) {
    if ($name) {
        # Rimuove spazi, caratteri speciali e converte in minuscolo per il confronto
        return $name.ToLower().Trim() -replace '[^a-z0-9]', ''
    }
}

# --- 1/4 RACCOLTA E NORMALIZZAZIONE APPLICAZIONI INSTALLATE ---
Write-Host "[1/4] Acquisizione elenco applicazioni installate..." -ForegroundColor Green

# Percorsi comuni del Registro di sistema per le installazioni
$regPaths = @(
    "HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

# Ottiene i nomi delle app e li normalizza in un array di stringhe [string[]]
[string[]]$installedNames = $regPaths | ForEach-Object {
    Get-ItemProperty $_ -ErrorAction SilentlyContinue |
    Where-Object { $_.DisplayName } |
    ForEach-Object { Normalize-Name($_.DisplayName) }
}

# Aggiunge app di Windows Store (UWP)
$installedNames += Get-AppxPackage -ErrorAction SilentlyContinue | 
    ForEach-Object { Normalize-Name($_.Name) }

# Rimuove duplicati e valori vuoti
$installedNames = $installedNames | Select-Object -Unique | Where-Object { $_ }

Write-Host "Trovati $($installedNames.Count) nomi di applicazioni installate`n" -ForegroundColor White

# --- 2/4 & 3/4 SCANSIONE CARTELLE APPDATA ---
$appDataPaths = @(
    @{ Path = $env:LOCALAPPDATA; Location = "Local" },
    @{ Path = $env:APPDATA; Location = "Roaming" }
)

Write-Host "[2/4 & 3/4] Scansione cartelle AppData..." -ForegroundColor Green

$allFolders = @()
$appDataPaths | ForEach-Object {
    $location = $_.Location
    Get-ChildItem -Path $_.Path -Directory -ErrorAction SilentlyContinue |
    ForEach-Object {
        $allFolders += [PSCustomObject]@{
            Name = $_.Name
            FullName = $_.FullName
            Location = $location
            NormalizedName = Normalize-Name($_.Name)
        }
    }
}

Write-Host "Trovate $($allFolders.Count) cartelle da analizzare" -ForegroundColor White

# --- 4/4 ANALISI E IDENTIFICAZIONE DEI RESIDUI ---
Write-Host "[4/4] Analisi delle cartelle per residui...`n" -ForegroundColor Green

$leftovers = @()

foreach ($folder in $allFolders) {
    $folderName = $folder.NormalizedName
    
    $isInstalled = $false
    
    # Check 1: Corrispondenza esatta del nome normalizzato
    if ($installedNames -contains $folderName) {
        $isInstalled = $true
    }
    
    # Check 2: Controllo incrociato per nomi parziali/simili
    if (-not $isInstalled) {
        foreach ($appName in $installedNames) {
            if ($folderName -like "*$appName*" -or $appName -like "*$folderName*") {
                $isInstalled = $true
                break
            }
        }
    }
    
    if (-not $isInstalled) {
        # Calcolo delle dimensioni
        $size = (Get-ChildItem -Path $folder.FullName -Recurse -File -ErrorAction SilentlyContinue | 
                 Measure-Object -Property Length -Sum).Sum
        
        # Converte in MB e arrotonda
        $sizeMB = [math]::Round($size / 1MB, 2)
        
        if ($sizeMB -gt 0.01) { # Filtra le cartelle molto piccole (< 10 KB)
            $leftovers += [PSCustomObject]@{
                FolderName = $folder.Name
                Location = $folder.Location
                Path = $folder.FullName
                SizeMB = $sizeMB
            }
        }
    }
}

# --- RISULTATI E INIZIO CANCELLAZIONE ---
Write-Host "=== POTENTIAL LEFTOVERS FOUND ===" -ForegroundColor Cyan
Write-Host "Totale cartelle analizzate: $($allFolders.Count)" -ForegroundColor White
Write-Host "Residui potenziali: $($leftovers.Count)`n" -ForegroundColor Yellow

if ($leftovers.Count -eq 0) {
    Write-Host "Nessun residuo ovvio trovato!" -ForegroundColor Green
} else {
    # Ordina per dimensione (il più grande prima)
    $leftovers = $leftovers | Sort-Object -Property SizeMB -Descending
    
    Write-Host "Ecco l'elenco dei potenziali residui da analizzare:" -ForegroundColor Yellow
    $leftovers | Format-Table -AutoSize FolderName, Location, SizeMB, Path
    
    $totalSize = ($leftovers | Measure-Object -Property SizeMB -Sum).Sum
    Write-Host "`nSpazio totale occupato: $([math]::Round($totalSize, 2)) MB`n" -ForegroundColor Yellow
    
    # --- PROCESSO DI BACKUP E CANCELLAZIONE SICURA ---
    Write-Host "=== BACKUP E PULIZIA SICURA ===" -ForegroundColor Cyan
    Write-Host "Verrà chiesto di confermare la pulizia per ogni cartella. Il backup verrà creato come file ZIP nella stessa posizione della cartella." -ForegroundColor White
    
    $aborted = $false
    
    foreach ($item in $leftovers) {
        if ($aborted) { break }
        
        $zipPath = "$($item.Path).zip"
        
        Write-Host "`n------------------------------------------------------------" -ForegroundColor DarkGray
        Write-Host "Elaborazione: $($item.FolderName) | Dimensione: $($item.SizeMB) MB" -ForegroundColor Yellow
        Write-Host "Percorso: $($item.Path)" -ForegroundColor DarkGray
        
        $confirmation = Read-Host -Prompt "Vuoi effettuare il backup e cancellare questa cartella? (S)ì / (N)o / (A)nnulla tutto"
        
        switch ($confirmation.ToLower()) {
            "s" {
                Write-Host "-> Esecuzione Backup in: $zipPath" -ForegroundColor Green
                try {
                    # Compressione della cartella nel file ZIP
                    Compress-Archive -Path $item.Path -DestinationPath $zipPath -Force -ErrorAction Stop
                    
                    Write-Host "-> Backup completato. Cancellazione cartella originale..." -ForegroundColor Green
                    # Rimozione della cartella originale
                    Remove-Item -Path $item.Path -Recurse -Force -ErrorAction Stop
                    
                    Write-Host "-> Cancellazione di $($item.FolderName) completata con successo." -ForegroundColor Green
                } catch {
                    Write-Host "!!! ERRORE DURANTE L'OPERAZIONE per $($item.FolderName): $($_.Exception.Message)" -ForegroundColor Red
                    Write-Host "!!! La cartella originale potrebbe non essere stata cancellata. Procedi manualmente." -ForegroundColor Red
                }
            }
            "a" {
                $aborted = $true
                Write-Host "Pulizia annullata. Terminazione del processo." -ForegroundColor Red
            }
            "n" {
                Write-Host "-> Saltato: Nessuna azione intrapresa per $($item.FolderName)." -ForegroundColor Yellow
            }
            default {
                Write-Host "-> Input non valido. Saltato: Nessuna azione intrapresa per $($item.FolderName)." -ForegroundColor Yellow
            }
        }
    }
    
    Write-Host "`nPulizia completata." -ForegroundColor Cyan
}

# Correzione del metodo di pausa finale per la massima compatibilità
$null = Read-Host -Prompt "`nPremere Invio per uscire..."