KCS Mix Tape Kits Now Available!

Sun, 08 Jan 2023 13:00:00 -0500

Get your own KCS Mix Tape here!

Kansas City Standard (Cassette Tape) Decoder for the 6502 Computer

Sat, 07 Jan 2023 13:00:00 -0500

This is part of a multipart series where we’ll be modifying a homebuilt 6502 processor computer in strange and creative ways.

In this part of the series we’ll be building a circuit to demodulate (or decode) Kansas City Standard audio and load that onto our 6502 computer.

Kansas City Standard or BYTE Standard, was a standard developed by BYTE magazine back in in the late 70’s. It was used to store computer data on standard, low-cost, audio cassette tapes. It was designed to allow common people to be able store data at home as there weren’t many options to do so back around that time. There were even radio shows where they would broadcast out Kansas City Standard formatted audio and nerds like you and I would tune in to, listen to the broadcast and record the last part of the show to “download” a new computer program!

At the conclusion of this KCS build, we’ll be able to load our Ben Eater 6502 from tape!

Part 1:
We’ll go through the history of the Kansas City Standard, some deep level details, and then an overview/theory of how the circuit works. At the end of this video, we’ll have a demodulated UART stream ready to feed into the logic part of the circuit.

We’ll also be introduced to Mr. Monostable, a refined gentleman with a short temper.

If you’re interested in a kit to perform this build yourself. I’ll put one together if there’s enough community interest. (Update: I did!

Part 2:

In this video we latching (or holdon to) the data coming in and we FINALLY get to see some Kansas City Standard data being decoded!

Part 3:

In this video we take the next step in our project and can finally load data from the KCS circuit! We do this by adding an additional W65C22, adding some hardware to handle more interrupts, and update some code.

Part 4:

Here we build the bootloader for the 6502 in assembly and successfully launch a program that is stored on tape!

IT’S HERE!:

Introducing the KCS Mix Tape: A DIY Electronics Kit. This video covers the new kit as well as tuning. Enjoy!

The KCS Mix Tape can be purchased here.

I’ve published any code and the schematic for these videos on my GitHub.

…he’s watching.

EdgeRouter w/ Gigabit Internet Slow Fixed!

Wed, 04 Jan 2023 13:00:00 -0500

I recently upgraded my home Internet from Spectrum Ultra (500/20) to TDS Fiber Gigabit (1000/1000). However, when running speed tests on the new circuit I noticed that I was consistently getting speeds SLOWER than my Spectrum Circuit. I was getting around 250-300mbps.

This ended up being a configuration issue with my Ubiquiti EdgeRouter PRO-8, which is definitely capable of delivering gigabit speeds!

The very first things I checked, were to ensure I was running the latest code (v2.0.9-hotfix.5 at this time) and that hardware offloading was ENABLED:

$ configure
#set system offload hwnat disable
#set system offload ipsec enable
#set system offload ipv4 bonding enable
#set system offload ipv4 disable-flow-flushing-upon-fib-changes
#set system offload ipv4 forwarding enable
#set system offload ipv4 gre enable
#set system offload ipv4 pppoe enable
#set system offload ipv4 table-size 65536
#set system offload ipv4 vlan enable
#set system offload ipv6 bonding enable
#set system offload ipv6 forwarding enable
#set system offload ipv6 pppoe disable
#set system offload ipv6 table-size 65536
#set system offload ipv6 vlan enable
#commit

I was still seeing the issue, still had slow speeds. But, I also noticed in the GUI that when I was running my speed tests the CPU was maxing out at 100%. I jumped down to the CLI and ran “top”, to see what was pegging the CPU.

The ksoftirqd process was pegging the CPU on the EdgeRouter. This lead me to this post, which reminded me that I had played with Netflow a few years back.

$ $ configure
[edit]
# delete system flow-accounting
[edit]
# commit
[ system flow-accounting ]
Removing flow-accounting NFLOG for [eth7][ingress][post-dnat]
Removing flow-accounting NFLOG for [eth7][egress]
Stopping flow-accounting daemon [ingress]
Stopping flow-accounting daemon [egress]

[edit]
$ configure
[edit]
# save
Saving configuration to '/config/config.boot'...
Done
[edit]
# exit

After disabling flow accounting, this fixed it and I was getting really close to my Gigabit speeds!

Mutiple Ways to Reboot CradlePoint Devices [SSH, WGET, CURL, SMS, HTML (POST)]

Mon, 11 Jan 2016 12:35:14 -0500

Here are a couple ways I’ve come up with to reboot CradlePoint devices remotely. These were all tested on MBR1400 routers using v6.0.2 firmware. If you have proper HTTPS certificates installed for the web interface you can drop the ‘–no-check-certificate’ or the ‘–insecure’ options on the WGET and CURL commands. Also note that the CURL and WGET commands are using the password in the command. This can be insecure for many reasons.

Of course, you could always use the web interface too.

Using SSH:

ssh [user]@[ip address] 'reboot'

Using WGET:

wget --no-check-certificate https://[ip address]/api/control/system/reboot --http-user=[user] --http-password=[password] --post-data 'data=%221%22'

Using CURL:

curl --insecure https://[ip address]/api/control/system/reboot --anyauth --user [user]:[password] --data "data=%221%22"

Custom HTML using POST:
You can throw this code into a custom website, if you really feel the need.

<form action="https://[ip address]/api/control/system/reboot" method="post">
     <button type=submit name="data" value="1">Reboot CradlePoint</button>
</form>

Using SMS:
You can also use SMS to send a text message to the CradlePoint router instructing it to reboot. Unless you’ve changed the SMS password, the SMS password is the last eight characters of the MAC address. It’s specifically an SMS password (so it’s not tied to any user account).

The format of the text message:

[password],reboot<br />

You’ll receive a text back from the device:

How to Search Active Directory by 'objectSid' using PowerShell

Thu, 30 Jan 2014 13:37:42 -0500

Sometimes you may have a SID (objectSid) for an Active Directory object but not necessarily know which object it belongs to. You can find the object using PowerShell.

I came across this when recovering a hard drive for a company. The hard drive was from a domain computer and the NTFS permissions only showed the SID as the recovery computer was a workgroup computer and didn’t have access to the domain. I wanted to re-apply the NTFS permissions on the replaced drive so I needed to know which each SID belonged to.

Run the following on a computer that is a member of the domain:

Import-Module ActiveDirectory
Get-ADUser -Identity S-1-5-21-941005169-1824062477-405670111-1106

Streaming Google Music with MPD

Sat, 02 Mar 2013 14:38:35 -0500

I’ve been thinking about building a plugin for MPD that would allow it to talk with Google Music for a while now. Currently, when I purchase music from Google Music, I have to download it and push the new music up to my local music share on my network. Once my music is there, MPD can stream it without a problem… I love MPD!

I started to investigate the idea this weekend. I found these two projects that I wanted to share with you guys. They helped me prove out that the plugin I want to write is possible without TOO much work.

Unofficial Google Music API - An unofficial, opensource API written in Python for Google Music.
MPC - A linux terminal based MPD client.

First, by modifying the example.py in the Google Music API a little I was able to create a script that would sign into Google Music, find the first song in my library and grab the streaming URL of that song.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from getpass import getpass
from gmusicapi import Api
def ask_for_credentials():
    """Make an instance of the api and attempts to login with it.
    Return the authenticated api.
    """
    api = Api()
    logged_in = False
    attempts = 0
    while not logged_in and attempts < 3:
        email = raw_input("Email: ")
        password = getpass()
        logged_in = api.login(email, password)
        attempts += 1
    return api
def demonstration():
    """Demonstrate some api features."""
    api = ask_for_credentials()
    if not api.is_authenticated():
        print "Sorry, those credentials weren't accepted."
        return
    print "Successfully logged in."
    print
    #Get all of the users songs.
    #library is a big list of dictionaries, each of which contains a single song.
    print "Loading library...",
    library = api.get_all_songs()
    print "done."
    print len(library), "tracks detected."
    print
    #Show some info about a song. There is no guaranteed order;
    # this is essentially a random song.
    first_song = library[0]
    print "The first song I see is '{}' by '{}'.".format(
        first_song["name"],
        first_song["artist"])
    #We're going to create a new playlist and add a song to it.
    #Songs are uniquely identified by 'song ids', so let's get the id:
    song_id = first_song["id"]
    print (api.get_stream_url(song_id))
    #It's good practice to logout when finished.
    api.logout()
    print "All done!"
if __name__ == '__main__':
    demonstration()

When running the script above, it’ll ask for a Google account and password. Once they are entered the script will login and load the library of the account. It will grab the first song in the library and output the URL to stream the song. Now that I had the streaming URL, I needed a way to add that to my MPD queue.

mpc clear
mpc add "URL FROM SCRIPT ABOVE"
mpc play

Low and behold! When I hit play the song started playing! So now we know that it can work the next step is figuring out if there’s a way to tie the Google Music library in with MPD’s library.

Configure NetBIOS over TCP/IP with Group Policy

Mon, 25 Feb 2013 11:05:16 -0500

I came across a situation last week where I needed to finally disable NetBIOS over TCP/IP. While looking for a way to disable it, unfortunately, I found that there really isn’t a good clean way to do so using Group Policy. At least, if there was a good way, I couldn’t find it.

What I came up with was a VBScript that disables NetBIOS over TCP/IP for every NIC in a computer. The script can be easily modified to enable NetBIOS over TCP/IP as well. I’m currently using this as a Computer Startup Script. Once the script is run, the effects should take place on the next reboot.

The screenshot above shows you the settings we’re modifying. Use this as a reference so you know which line to uncomment in the script. By default I have the script set to 2 - Disable NetBIOS over TCP/IP.

'  Title:      Configure NetBIOS over TCP/IP
'   Date:      2/25/2013
'Updated:
' Author:      Gregory Strike
'    URL:      //www.gregorystrike.com/2013/02/25/configure-netbios-over-tcpip-group-policy.html
'
'Purpose:      The following script will itterate through all NICs on a computer
'              to configuure NetBIOS over TCP/IP.  It finds the NICs listed under:
'              HKLM\SYSTEM\CurrentControlSet\services\NetBT\Parameters\Interfaces
'
'              For each NIC under the key, it sets the NetbiosOptions value to one
'              of the below.  (Be sure to uncomment the setting you desire.)
'
'              0 - Default: Use DHCP setting from the DHCP Server
'              1 - Enable NetBIOS over TCP/IP
'              2 - Disable NetBIOS over TCP/IP
'
'Requirements: Administrative Privileges
const HKEY_LOCAL_MACHINE = &H80000002
strComputer = "."
Set ObjWMI = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & strComputer & "\root\default:StdRegProv")
'Set the path to the Network Interfaces
strKeyPath = "SYSTEM\CurrentControlSet\services\NetBT\Parameters\Interfaces"
'Get all the known interfaces
ObjWMI.EnumKey HKEY_LOCAL_MACHINE, strKeyPath, arrSubKeys
'If there was a problem getting strKeyPath, exit the script before throwing an error.
If IsNull(arrSubKeys) Then WScript.Quit
WScript.Echo Now() & " - Searching for Network Adapaters."
'Loop through all Network Interface Cards and disable NetBIOS over TCP/IP
For Each Adapter In arrSubKeys
	WScript.Echo Now() & " - Disabling NetBIOS over TCP/IP on '" & Adapter & "'"
	'Default: Use DHCP setting from the DHCP Server
	'objWMI.SetDWORDValue HKEY_LOCAL_MACHINE, strKeyPath & "\" & Adapter, "NetbiosOptions", 0
	'Enable NetBIOS over TCP/IP
	'objWMI.SetDWORDValue HKEY_LOCAL_MACHINE, strKeyPath & "\" & Adapter, "NetbiosOptions", 1
	'Disable NetBIOS over TCP/IP
	objWMI.SetDWORDValue HKEY_LOCAL_MACHINE, strKeyPath & "\" & Adapter, "NetbiosOptions", 2
Next
WScript.Echo Now() & " - Completed."

Enjoy!

Generate a Time Lapse Video from an Online Webcam Using Open Source

Fri, 14 Sep 2012 16:23:09 -0400

I’ve generated a couple time lapse videos in the past and I wanted to share my process with my readers.

Let’s say you’ve found a webcam source online and you wanted to capture a time lapse video from it. For instance, here is Old Faithful at Yellowstone National Park which publishes a .JPG every minute. How would you create a time lapse from it? And even better, how would you do it using completely FREE software?!

First, since the script is a Bash script you need to be running Bash. The easiest way to do this is to be running a version Linux (Ubuntu or Linux Mint are nice!) since Bash is usually the default shell. You could also use Cygwin to do this in Windows, but it is beyond the scope of this article on how to use it. From here on out, I will assume you are running Bash in Linux.

Way back in 2007 I published a Bash script that captures a URL at a provided interval and saves it to a directory. This is the heart the process. Go ahead and grab the script and save it in your home directory as iget.sh. Though it’s pretty self-explanatory there is a more detailed explanation on the script’s page as well. Once you have the script saved you need to give it execute permissions by running:

chmod +x ~/iget.sh

Now we’re ready to capture the images. Launch a terminal session and create a directory to store the webcam images. Once created, change to that directory.

mkdir webcam
cd webcam

Run the iget.sh script with the required parameters.

../iget.sh https://www.nps.gov/webcams-yell/oldfaithvc.jpg of.jpg 60

The first parameter is the URL to be downloaded. The second parameter (of.jpg) is a base file name, every file that is saved to your computer will be time stamped and ended with this. Make sure you use the same extension (.jpg) that the webcam is publishing. The third parameter (60) is the amount of seconds between captures. Since the Old Faithful webcam updates every minute, I’ve chosen 60 seconds.

Let the script run for as long as you want. After you’ve captured all the frames you want for your video, move on to the next step.

…Don’t worry, I’ll wait…

…Got them yet? Good!

Ok, the next step is to delete any duplicate frames that may exist. This can occur for a couple reasons but depending on what you’re using the video for you may or may not want to do this. I prefer to delete them since I mainly use it for entertainment purposes and it creates a smoother looking video. Save the following script to your home directory as rmdupe.sh.

#!/bin/bash

cksum * | sort -n > filelist

old=""
while read sum lines filename
do
      if [[ "$sum" != "$old" ]] ; then
            old="$sum"
            continue
      fi
      rm -f "$filename"

done < filelist

Give it execute permissions using chmod and then run it in the directory you saved the .JPG files to.

chmod +x ~/rmdupe.sh
~/rmdupe.sh

Great! Now we’ve got rid of all our duplicate files. The next step is to remove any frames that may be corrupt. To do this I’m going to use a utility called jpeginfo, don’t worry. It’s free. However, it may not be installed by default on your Linux distribution so you’ll have to install it.

sudo apt-get install jpeginfo

Once it’s installed run this in the directory. It may take a while to go through but it will validate the JPEGs in the directory and delete any that fail validation.

find . -name "*" -exec jpeginfo -c {} \; | grep -E "WARNING|ERROR" | cut -d " " -f 1 | xargs rm -r

Now for the fun part where we convert the JPEGs to a movie. To do this I’m going to use mencoder, another free utility available in Linux. To install it run this:

sudo apt-get install mencoder

And here’s a command to convert the JPGs to a movie. You can tweak the arguments to change the codec, framerate, bitrate so be sure to check out the documentation how to tweak it.

mencoder "mf://*.jpg" -mf fps=10 -o OldFaithful.avi -ovc lavc -lavcopts vcodec=msmpeg4v2:vbitrate=800

Once done, you’ll have a time lapse .AVI file! Here’s what it looked like after an afternoon of capturing.

Thanks for reading guys! Enjoy!

How to Deploy Adobe Reader (and Patches) with Active Directory

Thu, 23 Aug 2012 15:48:27 -0400

In my organization we push out Adobe Reader using an Active Directory policy. In order to do this using we use the Software Management features of Active Directory which requires an .MSI. Adobe supplies an .MSI for Adobe Reader and it’s relatively simple to deploy as long as it’s a base version (ie. no updates). However, If you have to apply the quarterly updates the process becomes a little less intuitive. It is my hope that contributing this information and the script below will make the process a little easier for people to keep their Adobe Reader patched.

First, if you are deploying Adobe Reader, Adobe requires that you sign Distribution Agreement with them. It’s free, really not that difficult and it’s the only way to legally obtain the .MSI required to do the deployment. So just do it.

The purpose of this post is really about how to patch an Adobe Reader .MSI with the .MSP in a way that you are still able to customize the patched version with the Adobe Customization Wizard and then have that in a ready state to deploy using Active Directory. I’m not going to cover much of how to configure the group policies, I’m assuming that you already have that knowledge. After all, you guys are smart! :)

Since the scheduled updates of Adobe Reader is quarterly, patching it has not been I did often. By the time the new patch came out, I had forgotten how to do the process and wasn’t able to devote the time into trying to do it again. So, to help with this I’ve written a script that will patch the Adobe Reader .MSI using the .MSP and then extract some files from the .EXE installer. I’ll explain it below.

ECHO OFF

REM Title:       AdobeReaderPatcher.cmd
REM Date:        8/22/2012
REM Author:      Gregory Strike
REM URL:         //www.gregorystrike.com/2012/08/23/how-to-deploy-adobe-reader-and-patches-with-active-directory/
REM
REM Purpose:     Automate the process of patching the Adobe Reader .MSI Installer
REM
REM Permissions: This script should be run from an elevated Command Prompt.
REM
REM This script was built using information I found at https://forums.adobe.com/message/4166521.

CLS

REM THESE MUST BE SET TO THE CORRECT VERSIONS!
SET BASEVER=1010
SET PATCHVER=1014
SET LANG=en_US

REM In most circumstances the variables following this line do not need to be modified.
SET BASE=AdbeRdr
SET PATCH=AdbeRdrUpd
SET CURDIR=%~dp0
SET AIPDIR=%CURDIR%AIP
SET EXEDIR=%CURDIR%EXE

REM Checking prerequisites
ECHO Checking prerequisites...
IF NOT EXIST %CURDIR%%BASE%%BASEVER%_%LANG%.msi GOTO :MISSINGFILE
IF NOT EXIST %CURDIR%%PATCH%%PATCHVER%.msp GOTO :MISSINGFILE
IF NOT EXIST %CURDIR%%BASE%%PATCHVER%_%LANG%.exe GOTO MISSINGFILE

IF EXIST %AIPDIR% GOTO :FOLDEREXISTS
IF EXIST %EXEDIR% GOTO :FOLDEREXISTS

REM Creating AIP Folder base
ECHO Creating AIP Folder base...
msiexec /a %CURDIR%%BASE%%BASEVER%_%LANG%.msi TARGETDIR="%AIPDIR%" /passive

REM Patching AIP with .MSP
ECHO Patching AIP with .MSP...
msiexec /a %AIPDIR%\%BASE%%BASEVER%_%LANG%.msi /p %CURDIR%%PATCH%%PATCHVER%.msp /passive

REM Renaming .MSI in AIP
ECHO Renaming .MSI in AIP...
RENAME %AIPDIR%\%BASE%%BASEVER%_%LANG%.msi %BASE%%PATCHVER%_%LANG%.msi

REM Extracting Setup Files from Base .EXE
ECHO Extracting Setup Files from Base .EXE...
%CURDIR%%BASE%%PATCHVER%_%LANG%.exe -sfx_o"%EXEDIR%" -sfx_ne
COPY %EXEDIR%\Setup.exe %AIPDIR%\Setup.exe
COPY %EXEDIR%\Setup.ini %AIPDIR%\Setup.ini

REM Updating Setup.ini
ECHO Updating Setup.ini...

TYPE %EXEDIR%\Setup.ini | FINDSTR /I /V \[Product\] > %AIPDIR%\Setup1.ini
TYPE %AIPDIR%\Setup1.ini | FINDSTR /I /V MSI= > %AIPDIR%\Setup2.ini
TYPE %AIPDIR%\Setup2.ini | FINDSTR /I /V PATCH= > %AIPDIR%\Setup.ini
DEL %AIPDIR%\Setup1.ini
DEL %AIPDIR%\Setup2.ini

ECHO. >> %AIPDIR%\Setup.ini
ECHO [Product] >> %AIPDIR%\Setup.ini
ECHO MSI=%BASE%%PATCHVER%_%LANG%.msi >> %AIPDIR%\Setup.ini

GOTO :END

:MISSINGFILE
ECHO.
ECHO ERROR - One of the following files was not found:
ECHO %BASE%%BASEVER%_%LANG%.msi
ECHO %PATCH%%PATCHVER%.msp
ECHO %BASE%%PATCHVER%_%LANG%.exe
ECHO.
ECHO 1. Verify these files exist in the same directory as this script (%CURDIR%).
ECHO 2. Verify the BASEVER, PATCHVER and LANG variables at the top are correct.

GOTO :END

:FOLDEREXISTS
ECHO.
ECHO ERROR - One or both of these folders already exists:
ECHO %AIPDIR%
ECHO %EXEDIR%
ECHO.
ECHO Please delete these folders and rerun the script.
ECHO.

:END
ECHO.
ECHO Script Complete.

Unless Adobe changes the process or naming convention of their files this script should take three files and output a working AIP (Administrator Install Point) directory with a patched .MSI that is ready to deploy via Group Policy. It follows all the steps that Adobe has laid out but simply automates it. Using this, the AIP is also in a state that can be customized by the Adobe Customization Wizard if you need to create a transform (.MST) to customize the options that are deployed. You only need this script if you are deploying a PATCHED .MSI. If you are using a base version this is unnecessary.

Here’s a list of the files you need. You should be able to pull these from Adobe’s FTP site (ftp://ftp.adobe.com/pub/adobe/reader/win/). They should all be downloaded and placed in the same folder. Again, remember the Distribution Agreement mentioned above.

File	Example Filename
The script above, Silly!	AdobeReaderPatcher.cmd
The base .MSI	AdbeRdr1010_en_US.msi
The .MSP patch	AdbeRdrUpd1014.msp
The .EXE installer for the new version	AdbeRdr1014_en_US.exe

Once all the files are downloaded and located in the same folder you need to update some variables in the script so that it knows which versions it’s working with. The script doesn’t modify it’s logic based on these variables, it’s really just using them to generate filenames on the fly. The script above was written shortly after Adobe Reader X v10.1.4 was released so it is already set to take the v10.1.0 .MSI and apply the v10.1.4 .MSP to the en_US version. Note the following lines in the script is where you make the modifications.

REM THESE MUST BE SET TO THE CORRECT VERSIONS!
SET BASEVER=1010
SET PATCHVER=1014
SET LANG=en_US

Once your changes are saved, launch an elevated Command Prompt and CD to your working directory.

Once there run AdobeReaderPatcher.cmd (or whatever you named it), and it will go through the patching process.

The script will generate a directory called “AIP”. When all is done, this will be the folder you copy to your network share or customize with the Adobe Customization Wizard. I should mention that the two setup (setup.exe and setup.ini) files that are copied are pulled from the .EXE. It’s actually the only reason we need the .EXE. Some of the options you may choose in the Adobe Customization Wizard require these files.

It’ll be interesting to see if this works with the next version of Adobe Reader X (v10.1.5?). Good luck everyone!

How to Check S.M.A.R.T Status of Hard Drive Remotely

Fri, 03 Aug 2012 10:54:47 -0400

SMART (Self-Monitoring, Analysis and Reporting Technology) is a technology incorporated into most hard drives that monitors the health the drive. Using SMART, the drive will log read/write failures. If the number of failures reach a certain threshold the drive can communicate that back to the BIOS or operating system and alert the user that the drive is failing. It’s then up to the user to replace the drive before the loss of data.

I needed a way to check the SMART status of a drive remotely and was able to come up with a couple different methods to do it. I wasn’t interested in any of the metrics, only whether or not SMART thought the drive was failing. So all of the examples below will give you the same answers but I thought I’d share the code for accessing it with a couple different languages. All of the examples are remotely querying the computer using WMI, so it is important that you have security to WMI on the remote computer.

This example, from Command Prompt using WMIC, will grab the Caption and Status for all drives on the computer. Grabbing the caption is beneficial for identifying which status belongs to which drive.

WMIC /Node:REMOTECOMPUTER DiskDrive GET Caption, Status

Here’s an example using PowerShell:

$WMI = Get-WMIObject -Computer REMOTECOMPUTER -Class Win32_DiskDrive
ForEach ($Drive in $WMI){
     $Drive.Caption + ": " + $Drive.Status
}

And finally an example using VBScript:

strComputer = "REMOTECOMPUTER"
Set objWMIService = GetObject("winmgmts:" _
    & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")

Set colDrives = objWMIService.ExecQuery("Select * from Win32_DiskDrive")

For Each Drive in colDrives
    WScript.Echo Drive.Caption & ": " & Drive.Status
Next

Running any of the above should give you the Caption and Status of the drive. If the status is “Degraded” or “Pred Fail” it’s likely that the drive is going to fail and the drive needs to be replaced. There are other values that status could be set to, for a more detailed explanation see Win32_DiskDrive class on MSDN.

One thing to note is just because SMART or the Status say the drive is fine doesn’t mean it is. If the drive is having issues and the logged failures on the drive haven’t crossed a threshold the drive may still report as “OK”. However, if SMART is saying there’s a problem, you should be able to trust it.